chore: import upstream snapshot with attribution

apps/sim/lib/table/__tests__/find-row-matches.test.ts

@@ -0,0 +1,115 @@
+/**
+ * @vitest-environment node
+ *
+ * Unit-tests the result mapping and truncation logic of `findRowMatches`. The
+ * SQL itself runs against a mocked `db.execute`, so these assertions cover the
+ * JS-side shaping (ordinal coercion, column rename, LIMIT+1 truncation), not
+ * the query semantics — those need a real Postgres.
+ */
+import { dbChainMock, dbChainMockFns, resetDbChainMock } from '@sim/testing'
+import { sql } from 'drizzle-orm'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ColumnDefinition, TableDefinition } from '@/lib/table/types'
+
+vi.mock('@sim/db', () => dbChainMock)
+
+vi.mock('@/lib/table/sql', () => ({
+  buildFilterClause: vi.fn(() => sql`true`),
+  buildSortClause: vi.fn(() => sql`true`),
+  escapeLikePattern: vi.fn((s: string) => s),
+}))
+
+vi.mock('@/lib/table/trigger', () => ({ fireTableTrigger: vi.fn() }))
+vi.mock('@/lib/table/workflow-columns', () => ({
+  assertValidSchema: vi.fn(),
+  scheduleRunsForRows: vi.fn(),
+  scheduleRunsForTable: vi.fn(),
+  stripGroupDeps: vi.fn(),
+}))
+vi.mock('@/lib/table/validation', () => ({
+  validateRowSize: vi.fn(() => ({ valid: true, errors: [] })),
+  validateRowAgainstSchema: vi.fn(() => ({ valid: true, errors: [] })),
+  coerceRowToSchema: vi.fn(() => ({ valid: true, errors: [] })),
+  coerceRowValues: vi.fn(),
+  validateTableName: vi.fn(() => ({ valid: true, errors: [] })),
+  validateTableSchema: vi.fn(() => ({ valid: true, errors: [] })),
+  getUniqueColumns: vi.fn(() => []),
+  checkUniqueConstraintsDb: vi.fn(async () => ({ valid: true, errors: [] })),
+  checkBatchUniqueConstraintsDb: vi.fn(async () => ({ valid: true, errors: [] })),
+}))
+
+import { findRowMatches } from '@/lib/table/rows/service'
+import { buildFilterClause, buildSortClause } from '@/lib/table/sql'
+
+const COLUMNS: ColumnDefinition[] = [
+  { name: 'name', type: 'string' },
+  { name: 'email', type: 'string' },
+]
+
+const TABLE: TableDefinition = {
+  id: 'tbl-1',
+  name: 'People',
+  description: null,
+  schema: { columns: COLUMNS },
+  metadata: null,
+  rowCount: 0,
+  maxRows: 1000,
+  workspaceId: 'ws-1',
+  createdBy: 'user-1',
+  archivedAt: null,
+  createdAt: new Date('2024-01-01'),
+  updatedAt: new Date('2024-01-01'),
+}
+
+describe('findRowMatches', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    resetDbChainMock()
+  })
+
+  it('returns empty without querying when the table has no columns', async () => {
+    const result = await findRowMatches({ ...TABLE, schema: { columns: [] } }, { q: 'x' }, 'req')
+    expect(result).toEqual({ matches: [], truncated: false })
+    expect(dbChainMockFns.execute).not.toHaveBeenCalled()
+  })
+
+  it('maps rows to matches, coercing the bigint ordinal and renaming the column', async () => {
+    dbChainMockFns.execute.mockResolvedValue([
+      { ordinal: '2', id: 'r2', column_name: 'name' },
+      { ordinal: 5, id: 'r5', column_name: 'email' },
+    ])
+    const result = await findRowMatches(TABLE, { q: 'a' }, 'req')
+    expect(result.truncated).toBe(false)
+    expect(result.matches).toEqual([
+      { ordinal: 2, rowId: 'r2', column: 'name' },
+      { ordinal: 5, rowId: 'r5', column: 'email' },
+    ])
+  })
+
+  it('flags truncation and caps the result when the DB returns LIMIT+1 rows', async () => {
+    const over = Array.from({ length: 1001 }, (_, i) => ({
+      ordinal: i,
+      id: `r${i}`,
+      column_name: 'name',
+    }))
+    dbChainMockFns.execute.mockResolvedValue(over)
+    const result = await findRowMatches(TABLE, { q: 'a' }, 'req')
+    expect(result.truncated).toBe(true)
+    expect(result.matches).toHaveLength(1000)
+  })
+
+  it('threads filter and sort through the SQL builders', async () => {
+    dbChainMockFns.execute.mockResolvedValue([])
+    await findRowMatches(
+      TABLE,
+      { q: 'a', filter: { name: { $contains: 'a' } }, sort: { name: 'asc' } },
+      'req'
+    )
+    expect(buildFilterClause).toHaveBeenCalledWith(
+      { name: { $contains: 'a' } },
+      expect.any(String),
+      COLUMNS
+    )
+    expect(buildSortClause).toHaveBeenCalledWith({ name: 'asc' }, expect.any(String), COLUMNS)
+  })
+})