chore: import upstream snapshot with attribution

apps/sim/lib/logs/list-logs.test.ts

@@ -0,0 +1,195 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { selectMock } = vi.hoisted(() => ({ selectMock: vi.fn() }))
+
+vi.mock('@sim/db', () => {
+  const instance = { select: selectMock }
+  return { db: instance, dbReplica: instance }
+})
+
+// Local drizzle-orm mock: the global mock's `sql` lacks `.as()` and the chain
+// mock doesn't support `.orderBy().limit()`. We only need condition/sql builders
+// to produce truthy stubs (the mocked db ignores them).
+vi.mock('drizzle-orm', () => {
+  const make = (): Record<string, unknown> => {
+    const o: Record<string, unknown> = {}
+    o.as = () => o
+    o.mapWith = () => o
+    return o
+  }
+  const sql = Object.assign((..._args: unknown[]) => make(), {
+    raw: (..._args: unknown[]) => make(),
+    join: (..._args: unknown[]) => make(),
+  })
+  const op =
+    (type: string) =>
+    (...args: unknown[]) => ({ type, args })
+  return {
+    sql,
+    and: op('and'),
+    or: op('or'),
+    eq: op('eq'),
+    ne: op('ne'),
+    gt: op('gt'),
+    gte: op('gte'),
+    lt: op('lt'),
+    lte: op('lte'),
+    inArray: op('inArray'),
+    isNull: op('isNull'),
+    isNotNull: op('isNotNull'),
+    asc: op('asc'),
+    desc: op('desc'),
+  }
+})
+
+vi.mock('@/lib/logs/folder-expansion', () => ({
+  expandFolderIdsWithDescendants: vi.fn(async (_ws: string, ids: string | undefined) => ids),
+}))
+
+// listLogs gates workspace access at entry; the resolver is tested separately.
+vi.mock('@/lib/workspaces/permissions/utils', () => ({
+  checkWorkspaceAccess: vi.fn(async () => ({
+    exists: true,
+    hasAccess: true,
+    canWrite: true,
+    canAdmin: true,
+    workspace: { id: 'ws-1', name: 'Test', ownerId: 'user-1', organizationId: null },
+  })),
+}))
+
+import type { ListLogsParams } from './list-logs'
+import { decodeCursor, listLogs } from './list-logs'
+
+/** A chainable, thenable query-builder stub that resolves to the given rows. */
+function builder(rows: unknown[]) {
+  const b: Record<string, unknown> = {}
+  for (const method of ['from', 'leftJoin', 'innerJoin', 'where', 'orderBy', 'limit']) {
+    b[method] = () => b
+  }
+  ;(b as { then: unknown }).then = (resolve: (value: unknown) => unknown) => resolve(rows)
+  return b
+}
+
+function workflowRow(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'log-1',
+    workflowId: 'wf-1',
+    executionId: 'exec-1',
+    deploymentVersionId: null,
+    level: 'info',
+    status: 'success',
+    trigger: 'manual',
+    startedAt: new Date('2026-01-01T00:00:00.000Z'),
+    endedAt: new Date('2026-01-01T00:00:01.000Z'),
+    totalDurationMs: 1000,
+    costTotal: '0.1',
+    createdAt: new Date('2026-01-01T00:00:00.000Z'),
+    workflowName: 'My Workflow',
+    workflowDescription: null,
+    workflowFolderId: null,
+    workflowUserId: 'user-1',
+    workflowWorkspaceId: 'ws-1',
+    workflowCreatedAt: new Date('2026-01-01T00:00:00.000Z'),
+    workflowUpdatedAt: new Date('2026-01-01T00:00:00.000Z'),
+    pausedStatus: null,
+    pausedTotalPauseCount: 0,
+    pausedResumedCount: 0,
+    deploymentVersion: null,
+    deploymentVersionName: null,
+    sortValue: new Date('2026-01-01T00:00:00.000Z'),
+    ...overrides,
+  }
+}
+
+function jobRow(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'job-log-1',
+    executionId: 'job-exec-1',
+    level: 'info',
+    status: 'success',
+    trigger: 'schedule',
+    startedAt: new Date('2026-01-01T00:00:05.000Z'),
+    endedAt: new Date('2026-01-01T00:00:06.000Z'),
+    totalDurationMs: 1000,
+    cost: { total: 0.2 },
+    createdAt: new Date('2026-01-01T00:00:05.000Z'),
+    jobTitle: 'Nightly report',
+    sortValue: new Date('2026-01-01T00:00:05.000Z'),
+    ...overrides,
+  }
+}
+
+function baseParams(overrides: Partial<ListLogsParams> = {}): ListLogsParams {
+  return {
+    workspaceId: 'ws-1',
+    limit: 100,
+    sortBy: 'date',
+    sortOrder: 'desc',
+    ...overrides,
+  } as ListLogsParams
+}
+
+describe('listLogs', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('merges workflow and job rows into summaries', async () => {
+    selectMock
+      .mockReturnValueOnce(builder([workflowRow()]))
+      .mockReturnValueOnce(builder([jobRow()]))
+
+    const result = await listLogs(baseParams(), 'user-1')
+
+    expect(result.data).toHaveLength(2)
+    const wf = result.data.find((r) => r.id === 'log-1')!
+    expect(wf).toMatchObject({
+      executionId: 'exec-1',
+      workflowId: 'wf-1',
+      cost: { total: 0.1 },
+      duration: '1000ms',
+      jobTitle: null,
+    })
+    const job = result.data.find((r) => r.id === 'job-log-1')!
+    expect(job).toMatchObject({
+      executionId: 'job-exec-1',
+      workflowId: null,
+      jobTitle: 'Nightly report',
+    })
+    expect(result.nextCursor).toBeNull()
+  })
+
+  it('returns a decodable nextCursor when results exceed the limit', async () => {
+    // limit 1, two workflow rows → page of 1, hasMore true
+    selectMock
+      .mockReturnValueOnce(
+        builder([
+          workflowRow({ id: 'log-a', sortValue: new Date('2026-01-02T00:00:00.000Z') }),
+          workflowRow({ id: 'log-b', sortValue: new Date('2026-01-01T00:00:00.000Z') }),
+        ])
+      )
+      .mockReturnValueOnce(builder([]))
+
+    const result = await listLogs(baseParams({ limit: 1 }), 'user-1')
+
+    expect(result.data).toHaveLength(1)
+    expect(result.nextCursor).not.toBeNull()
+    const decoded = decodeCursor(result.nextCursor!)
+    expect(decoded?.id).toBe('log-a')
+  })
+
+  it('excludes job logs when a workflow-specific filter is present', async () => {
+    selectMock.mockReturnValueOnce(builder([workflowRow()]))
+
+    const result = await listLogs(baseParams({ workflowIds: 'wf-1' }), 'user-1')
+
+    // Only the workflow query runs; the job query is Promise.resolve([]).
+    expect(selectMock).toHaveBeenCalledTimes(1)
+    expect(result.data).toHaveLength(1)
+    expect(result.data[0].workflowId).toBe('wf-1')
+  })
+})