address more nits

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/components/resource/resource.tsx

@@ -495,17 +495,22 @@ const DataRow = memo(function DataRow({
   const isActiveDropTarget = rowDragDrop?.activeDropTargetId === row.id
   const isDragging = rowDragDrop?.draggedRowIds?.has(row.id) ?? false
   const isAnyDragActive = rowDragDrop?.isAnyDragActive ?? false
+  const hasActiveSelection = (selectable?.selectedIds.size ?? 0) > 0
 
   const handleClick = useCallback(
     (e: React.MouseEvent<HTMLTableRowElement>) => {
-      if (selectable && !selectable.disabled && (e.shiftKey || !onRowClick)) {
+      if (
+        selectable &&
+        !selectable.disabled &&
+        (e.shiftKey || e.metaKey || e.ctrlKey || !onRowClick || hasActiveSelection)
+      ) {
         e.preventDefault()
         selectable.onSelectRow(row.id, !isSelected, e.shiftKey)
         return
       }
       onRowClick?.(row.id)
     },
-    [isSelected, onRowClick, row.id, selectable]
+    [hasActiveSelection, isSelected, onRowClick, row.id, selectable]
   )
 
   const handleMouseEnter = useCallback(() => {

apps/sim/lib/workflows/schedules/orchestration.test.ts

@@ -0,0 +1,125 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  mockSelect,
+  mockUpdate,
+  mockUpdateSet,
+  mockUpdateWhere,
+  mockRecordAudit,
+  mockCaptureServerEvent,
+} = vi.hoisted(() => ({
+  mockSelect: vi.fn(),
+  mockUpdate: vi.fn(),
+  mockUpdateSet: vi.fn(),
+  mockUpdateWhere: vi.fn(),
+  mockRecordAudit: vi.fn(),
+  mockCaptureServerEvent: vi.fn(),
+}))
+
+vi.mock('@sim/audit', () => ({
+  AuditAction: { SCHEDULE_UPDATED: 'SCHEDULE_UPDATED' },
+  AuditResourceType: { SCHEDULE: 'SCHEDULE' },
+  recordAudit: mockRecordAudit,
+}))
+
+vi.mock('@sim/db', () => ({
+  db: {
+    select: mockSelect,
+    update: mockUpdate,
+  },
+  workflowSchedule: {
+    id: 'id',
+    sourceWorkspaceId: 'sourceWorkspaceId',
+    sourceType: 'sourceType',
+    archivedAt: 'archivedAt',
+    timezone: 'timezone',
+    status: 'status',
+    cronExpression: 'cronExpression',
+    jobTitle: 'jobTitle',
+  },
+}))
+
+vi.mock('@sim/logger', () => ({
+  createLogger: () => ({
+    error: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+  }),
+}))
+
+vi.mock('drizzle-orm', () => ({
+  and: vi.fn(),
+  eq: vi.fn(),
+  isNull: vi.fn(),
+}))
+
+vi.mock('@/lib/posthog/server', () => ({
+  captureServerEvent: mockCaptureServerEvent,
+}))
+
+import { performUpdateJob } from '@/lib/workflows/schedules/orchestration'
+
+const BASE_JOB = {
+  id: 'job-1',
+  sourceWorkspaceId: 'workspace-1',
+  sourceType: 'job',
+  archivedAt: null,
+  timezone: 'UTC',
+  cronExpression: null,
+  jobTitle: 'Nightly task',
+  status: 'disabled',
+}
+
+function mockExistingJob(job: typeof BASE_JOB) {
+  mockSelect.mockReturnValue({
+    from: vi.fn().mockReturnValue({
+      where: vi.fn().mockReturnValue({
+        limit: vi.fn().mockReturnValue([job]),
+      }),
+    }),
+  })
+}
+
+describe('performUpdateJob', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockUpdateSet.mockReturnValue({ where: mockUpdateWhere })
+    mockUpdate.mockReturnValue({ set: mockUpdateSet })
+    mockUpdateWhere.mockResolvedValue(undefined)
+  })
+
+  it('does not schedule a next run when editing time on a disabled job', async () => {
+    mockExistingJob({ ...BASE_JOB, status: 'disabled' })
+
+    const result = await performUpdateJob({
+      jobId: 'job-1',
+      workspaceId: 'workspace-1',
+      userId: 'user-1',
+      time: '2099-01-01T09:00:00Z',
+    })
+
+    expect(result.success).toBe(true)
+    expect(mockUpdateSet).toHaveBeenCalledTimes(1)
+    expect(mockUpdateSet.mock.calls[0][0]).not.toHaveProperty('nextRunAt')
+  })
+
+  it('schedules the next run when editing time on an active job', async () => {
+    mockExistingJob({ ...BASE_JOB, status: 'active' })
+
+    const result = await performUpdateJob({
+      jobId: 'job-1',
+      workspaceId: 'workspace-1',
+      userId: 'user-1',
+      time: '2099-01-01T09:00:00Z',
+    })
+
+    expect(result.success).toBe(true)
+    expect(mockUpdateSet).toHaveBeenCalledTimes(1)
+    expect(mockUpdateSet.mock.calls[0][0]).toMatchObject({
+      nextRunAt: new Date('2099-01-01T09:00:00Z'),
+    })
+  })
+})

apps/sim/lib/workflows/schedules/orchestration.ts

@@ -267,6 +267,8 @@ export async function performUpdateJob(
     }
     if (params.successCondition !== undefined) updates.successCondition = params.successCondition
     if (params.maxRuns !== undefined) updates.maxRuns = params.maxRuns
+    const effectiveStatus = updates.status ?? job.status
+
     if (params.cronExpression !== undefined) {
       const timezone = params.timezone || job.timezone || 'UTC'
       const validation = validateCronExpression(params.cronExpression, timezone)
@@ -278,7 +280,7 @@ export async function performUpdateJob(
         }
       }
       updates.cronExpression = params.cronExpression
-      if ((updates.status ?? job.status) === 'active') updates.nextRunAt = validation.nextRun
+      if (effectiveStatus === 'active') updates.nextRunAt = validation.nextRun
     }
     if (params.time !== undefined && params.time !== null) {
       const timezone = params.timezone || job.timezone || 'UTC'
@@ -292,7 +294,9 @@ export async function performUpdateJob(
       }
       const cronExpression =
         params.cronExpression !== undefined ? params.cronExpression : job.cronExpression
-      if (!cronExpression || parsed > new Date()) updates.nextRunAt = parsed
+      if (effectiveStatus === 'active' && (!cronExpression || parsed > new Date())) {
+        updates.nextRunAt = parsed
+      }
     }
 
     const updatedFields = Object.keys(updates).filter((key) => key !== 'updatedAt')