@teleporthq/teleport-plugin-next-data-source 0.43.74 → 0.44.0

package/__tests__/infinite-scroll.test.ts

@@ -1,7 +1,13 @@
+/* tslint:disable:function-constructor */
 import * as types from '@babel/types'
 import generator from '@babel/generator'
 import { ComponentStructure } from '@teleporthq/teleport-types'
 import { createNextArrayMapperPaginationPlugin } from '../src/pagination-plugin'
+import {
+  buildAccumulatingRequestMark,
+  buildAccumulatingResponseHandler,
+  getInfiniteScrollVars,
+} from '../src/infinite-scroll'
 import {
   makeMultiMapperUidl,
   makeUidlNode,
@@ -11,9 +17,10 @@ import {
 
 const runPlugin = async (
   repeater: RepeaterOptions,
-  controls: string[] = ['previous', 'next']
+  controls: string[] = ['previous', 'next'],
+  rootTag?: string
 ): Promise<string> => {
-  const chunk = makeWidgetComponentChunk({ controls })
+  const chunk = makeWidgetComponentChunk({ controls, rootTag })
   const structure: ComponentStructure = {
     uidl: { name: 'TestComponent', node: makeUidlNode(repeater) },
     chunks: [chunk],
@@ -31,7 +38,7 @@ describe('pagination plugin — infinite scroll', () => {
     const code = await runPlugin({ infiniteScroll: true })
     const flat = collapse(code)
 
-    expect(flat).toContain('const ds_0_accumRef = useRef({ sig: "", pages: {} })')
+    expect(flat).toContain('const ds_0_accumRef = useRef({ sig: "", pages: {}, latest: null })')
     expect(flat).toContain('const [ds_0_hasMoreFlag, setDs_0_hasMoreFlag] = useState(true)')
     // Two independent end-of-data signals: a short page, and the counted total.
     expect(flat).toContain(
@@ -42,12 +49,18 @@ describe('pagination plugin — infinite scroll', () => {
     // change must start a fresh list rather than interleave two result sets.
     expect(flat).toContain('const sig = JSON.stringify({ ...params, page: 0 })')
     expect(flat).toContain('if (ds_0_accumRef.current.sig !== sig)')
-    expect(flat).toContain('ds_0_accumRef.current = { sig, pages: {} }')
+    expect(flat).toContain('ds_0_accumRef.current.pages = {}')
     expect(flat).toContain('ds_0_accumRef.current.pages[page] = rows')
+    // fetchData records the request the list stands on before making it.
+    expect(flat).toContain(
+      'ds_0_accumRef.current.latest = { sig: JSON.stringify({ ...params, page: 0 }), page: Number(params.page) || 1 }'
+    )
     // A short page is the only end signal a source that cannot count gives.
     expect(flat).toContain('setDs_0_hasMoreFlag(rows.length >= 20)')
     // Numeric sort, so page 10 does not land between 1 and 2.
-    expect(flat).toContain('.map(Number).sort((a, b) => a - b).reduce(')
+    expect(flat).toMatch(
+      /\.map\(Number\)\.filter\(\(?p\)? => p <= last\)\.sort\(\(a, b\) => a - b\)\.reduce\(/
+    )
   })
 
   it('keeps the page out of the provider key and suppresses initialData', async () => {
@@ -82,6 +95,30 @@ describe('pagination plugin — infinite scroll', () => {
     )
   })
 
+  it('builds the sentinel as an element its parent may hold', async () => {
+    // A <div> among a table's rows is moved out of the table by the parser:
+    // the server's markup and the client's tree then differ and hydration fails.
+    const inBody = collapse(
+      await runPlugin({ infiniteScroll: true }, ['previous', 'next'], 'tbody')
+    )
+    expect(inBody).toContain(
+      '<tr ref={ds_0_sentinelRef} aria-hidden="true" style={{ height: "1px" }}><td style={{ padding: 0, border: 0 }} /></tr>'
+    )
+    expect(inBody).not.toContain('<div ref={ds_0_sentinelRef}')
+
+    const inList = collapse(await runPlugin({ infiniteScroll: true }, ['previous', 'next'], 'ul'))
+    expect(inList).toContain(
+      '<li ref={ds_0_sentinelRef} aria-hidden="true" style={{ height: "1px", listStyle: "none" }} />'
+    )
+
+    const inParagraph = collapse(
+      await runPlugin({ infiniteScroll: true }, ['previous', 'next'], 'p')
+    )
+    expect(inParagraph).toContain(
+      '<span ref={ds_0_sentinelRef} aria-hidden="true" style={{ display: "block", height: "1px" }} />'
+    )
+  })
+
   it('wires the authored Load More button instead, with no observer', async () => {
     const code = await runPlugin({ infiniteScroll: true, infiniteScrollLoadMore: true }, [
       'load-more',
@@ -141,3 +178,115 @@ describe('pagination plugin — infinite scroll', () => {
     expect(code).not.toContain('setDs_0_page(page => Math.max(1, page - 1))')
   })
 })
+
+/**
+ * The accumulator, executed: `fetchData` as the page emits it, answered in
+ * the orders a browser can produce. A sort (filter, search) change made on
+ * page 2 fires page 2 under the new query first, then page 1 once the page is
+ * reset — and `DataProvider` renders whichever answer lands last.
+ */
+describe('the appending list, run', () => {
+  const PER_PAGE = 2
+
+  interface Deferred {
+    params: { page: number; sorts: string }
+    resolve: (rows: string[]) => void
+    result: Promise<string[]>
+  }
+
+  function bootList() {
+    const vars = getInfiniteScrollVars(0)
+    const mark = generator(types.program([buildAccumulatingRequestMark(vars)])).code
+    const handler = generator(buildAccumulatingResponseHandler(vars, PER_PAGE)).code
+    const accumRef = { current: { sig: '', pages: {}, latest: null } }
+    const hasMore: boolean[] = []
+    const fetchData = new Function(
+      'ds_0_accumRef',
+      'setDs_0_hasMoreFlag',
+      'answer',
+      `return function fetchData(params) { ${mark}; return answer(params).then(${handler}) }`
+    )(
+      accumRef,
+      (value: boolean) => hasMore.push(value),
+      (params: Deferred['params']) => {
+        let resolve: (rows: string[]) => void = () => undefined
+        const answered = new Promise<{ data: string[] }>((done) => {
+          resolve = (rows) => done({ data: rows })
+        })
+        requests.push({ params, resolve, result: undefined as never })
+        return answered
+      }
+    ) as (params: Deferred['params']) => Promise<string[]>
+    const requests: Deferred[] = []
+    const request = (page: number, sorts: string): Deferred => {
+      const result = fetchData({ page, sorts })
+      const made = requests[requests.length - 1]
+      made.result = result
+      return made
+    }
+    return { request, hasMore }
+  }
+
+  const rowsOf = (sorts: string, page: number) => [`${sorts}${page}a`, `${sorts}${page}b`]
+
+  it('restarts at page 1 after a sort change on page 2, and loads page 2 on the next click', async () => {
+    const list = bootList()
+    const first = list.request(1, 'A')
+    first.resolve(rowsOf('A', 1))
+    const second = list.request(2, 'A')
+    second.resolve(rowsOf('A', 2))
+    expect(await second.result).toEqual([...rowsOf('A', 1), ...rowsOf('A', 2)])
+
+    const stray = list.request(2, 'B')
+    const restart = list.request(1, 'B')
+    stray.resolve(rowsOf('B', 2))
+    // The stray page changes nothing: the list on show stays until page 1 answers.
+    expect(await stray.result).toEqual([...rowsOf('A', 1), ...rowsOf('A', 2)])
+    restart.resolve(rowsOf('B', 1))
+    expect(await restart.result).toEqual(rowsOf('B', 1))
+
+    const next = list.request(2, 'B')
+    next.resolve(rowsOf('B', 2))
+    expect(await next.result).toEqual([...rowsOf('B', 1), ...rowsOf('B', 2)])
+  })
+
+  it('keeps the restarted list when the stray page answers last', async () => {
+    const list = bootList()
+    list.request(1, 'A').resolve(rowsOf('A', 1))
+    const second = list.request(2, 'A')
+    second.resolve(rowsOf('A', 2))
+    await second.result
+
+    const stray = list.request(2, 'B')
+    const restart = list.request(1, 'B')
+    restart.resolve(rowsOf('B', 1))
+    expect(await restart.result).toEqual(rowsOf('B', 1))
+    stray.resolve(rowsOf('B', 2))
+    expect(await stray.result).toEqual(rowsOf('B', 1))
+  })
+
+  it('never lets a late answer to an earlier query replace the list', async () => {
+    const list = bootList()
+    const before = list.request(1, 'A')
+    const after = list.request(1, 'B')
+    after.resolve(rowsOf('B', 1))
+    expect(await after.result).toEqual(rowsOf('B', 1))
+    before.resolve(rowsOf('A', 1))
+    expect(await before.result).toEqual(rowsOf('B', 1))
+  })
+
+  it('ends the list on a short page of the request it stands on only', async () => {
+    const list = bootList()
+    const stray = list.request(2, 'A')
+    const page1 = list.request(1, 'A')
+    stray.resolve(['A2a'])
+    await stray.result
+    expect(list.hasMore).toEqual([])
+    page1.resolve(rowsOf('A', 1))
+    await page1.result
+    const page2 = list.request(2, 'A')
+    page2.resolve(['A2a'])
+    expect(await page2.result).toEqual([...rowsOf('A', 1), 'A2a'])
+    expect(list.hasMore).toEqual([true, false])
+  })
+})

package/__tests__/list-sort-order.test.ts

@@ -0,0 +1,61 @@
+import { parse } from '@babel/parser'
+import { generateDataSourceFetcher } from '../src/data-source-fetchers'
+
+/**
+ * How the SQL routes of the platform's listings order what a visitor's sort
+ * leaves tied or empty: a post without a reading time comes after the others
+ * whichever way the list is sorted ("longest read first" opened on them), and
+ * equal rows keep one order across pages.
+ *
+ * Pinned on the route the project generator ships (`generateDataSourceFetcher`),
+ * for both databases a blog can live in.
+ */
+
+const ROUTES = [
+  ['teleport', { host: 'db', database: 'blog' }],
+  ['postgresql', { connectionString: 'postgres://user:pw@host:5432/db' }],
+] as const
+
+const routeFor = (type: string, config: object, tableName: string): string =>
+  generateDataSourceFetcher(
+    { type, config } as unknown as Parameters<typeof generateDataSourceFetcher>[0],
+    tableName
+  )
+
+const orderByLines = (route: string): string[] =>
+  route.split('\n').filter((line) => line.includes('ORDER BY') && line.includes('Clauses.join'))
+
+describe.each(ROUTES)('the %s route of the blog listing', (type, config) => {
+  const route = routeFor(type, config, 'teleport_blog_posts')
+
+  it('parses as valid JavaScript', () => {
+    expect(() => parse(route, { sourceType: 'module', plugins: ['jsx'] })).not.toThrow()
+  })
+
+  it('puts the rows without a value last, in both directions', () => {
+    expect(route).toMatch(/\$\{orderOf\(sort\)\} NULLS LAST`/)
+    expect(route).toMatch(/\$\{sortByDirection\} NULLS LAST\$\{tiebreak\}`/)
+  })
+
+  it('falls back to a plain ORDER BY when the database rejects it', () => {
+    expect(route).toMatch(/plainClauses = valid\.map\(\(sort\) => `[^`]*\$\{orderOf\(sort\)\}`\)/)
+    expect(route).toContain('const usedRewrittenSort = orderBySql !== plainOrderBySql')
+    expect(route).toContain('if (!usedRewrittenSort) throw sortError')
+    expect(route).toContain('baseSql + plainOrderBySql + sqlTail')
+  })
+
+  it('breaks ties by id, in the ORDER BY and in its fallback', () => {
+    expect(route).toContain(`fields.includes("id") ? '' : ", \\"id\\" " + direction`)
+    const lines = orderByLines(route)
+    expect(lines).toHaveLength(2)
+    lines.forEach((line) => expect(line).toMatch(/\$\{tiebreak\}/))
+  })
+})
+
+describe('a table no listing sorts for visitors', () => {
+  it('gets the empty-values-last order but no tiebreaker', () => {
+    const route = routeFor('teleport', { host: 'db', database: 'store' }, 'teleport_orders')
+    expect(route).toMatch(/\$\{orderOf\(sort\)\} NULLS LAST`/)
+    expect(route).toContain("const rowOrderTiebreak = () => ''")
+  })
+})

package/__tests__/null-filter-where.test.ts

@@ -0,0 +1,132 @@
+/* tslint:disable:function-constructor */
+import { generateDataSourceFetcherWithCore } from '../src/data-source-fetchers'
+
+/**
+ * A board's "No status" column lists the rows whose status is empty. The GUI
+ * sends that condition as `{ operand: '=', destination: null }` (and "has a
+ * status" as `'!='` + null), the one null shape every fetcher answers with
+ * `IS NULL` / `IS NOT NULL`. An operand the fetchers do not know is dropped
+ * with its null value — and a list whose only condition was dropped reads the
+ * whole table: every row in "No status", whose move button then overwrote the
+ * real statuses. Verdicts come from the SQL the executed route sends.
+ */
+
+interface Captured {
+  sql: string
+  params: unknown[]
+}
+
+const bootRoute = (type: 'teleport' | 'postgresql') => {
+  const dataSource = {
+    id: 'ds-1',
+    name: 'db',
+    type,
+    config:
+      type === 'teleport'
+        ? {
+            host: 'teleporthq.secrets.TELEPORT_DB_HOST',
+            port: 5432,
+            user: 'teleporthq.secrets.TELEPORT_DB_USER',
+            password: 'teleporthq.secrets.TELEPORT_DB_PASSWORD',
+            database: 'teleporthq.secrets.TELEPORT_DB_NAME',
+            selectedTables: {
+              team_events: { columns: [{ name: 'id' }, { name: 'priority' }] },
+            },
+          }
+        : { host: 'h', port: 5432, user: 'u', password: 'p', database: 'd' },
+  }
+  const code = generateDataSourceFetcherWithCore(dataSource as never, 'team_events', false, {})
+    .replace(
+      "import { Client, types as pgTypes } from 'pg'",
+      "const { Client, types: pgTypes } = require('pg')"
+    )
+    .replace(/^export default async function handler/m, 'async function handler')
+    .replace(/^export \{[^}]*\}\s*$/m, '')
+    .replace(/^export default \{[^}]*\}\s*$/m, '')
+    .concat('\nmodule.exports = { handler: handler }')
+
+  const captured: Captured[] = []
+  class FakeClient {
+    public async connect(): Promise<void> {
+      return
+    }
+    public async end(): Promise<void> {
+      return
+    }
+    public async query(sql: string, params: unknown[] = []): Promise<{ rows: any[] }> {
+      captured.push({ sql, params })
+      return { rows: [] }
+    }
+  }
+  const moduleObj: { exports: any } = { exports: {} }
+  new Function('require', 'module', 'exports', 'process', 'console', code)(
+    (name: string) => {
+      if (name === 'pg') {
+        return { Client: FakeClient }
+      }
+      throw new Error('unexpected require: ' + name)
+    },
+    moduleObj,
+    moduleObj.exports,
+    { env: {} },
+    { error: () => undefined, warn: () => undefined, log: () => undefined }
+  )
+
+  return async (filters: unknown): Promise<Captured> => {
+    captured.length = 0
+    let status = 0
+    const res = {
+      status(statusCode: number) {
+        status = statusCode
+        return this
+      },
+      json() {
+        return this
+      },
+      setHeader() {
+        return this
+      },
+    }
+    await moduleObj.exports.handler(
+      { method: 'GET', query: { filters: JSON.stringify(filters) }, headers: {} },
+      res
+    )
+    expect(status).toBe(200)
+    const select = captured.find((entry) => /FROM\s+"?team_events"?/i.test(entry.sql))
+    if (!select) {
+      throw new Error('the route never read team_events')
+    }
+    return select
+  }
+}
+
+// The domain → UIDL mapper's output for one condition in the inspector's group.
+const condition = (operand: string, destination: unknown = null) => [
+  {
+    type: 'group',
+    operator: 'and',
+    children: [{ type: 'condition', source: 'priority', destination, operand }],
+  },
+]
+
+describe.each(['teleport', 'postgresql'] as const)('the %s read route', (type) => {
+  const read = bootRoute(type)
+
+  it('answers "is empty" (= null) with IS NULL', async () => {
+    expect((await read(condition('='))).sql).toMatch(/WHERE\s+priority IS NULL/)
+  })
+
+  it('answers "is not empty" (!= null) with IS NOT NULL', async () => {
+    expect((await read(condition('!='))).sql).toMatch(/WHERE\s+priority IS NOT NULL/)
+  })
+
+  it('still binds a plain value as a parameter', async () => {
+    const select = await read(condition('=', 'high'))
+    expect(select.sql).toMatch(/WHERE\s+priority = \$1/)
+    expect(select.params).toEqual(expect.arrayContaining(['high']))
+  })
+
+  it('reads the whole table for an operand it does not know — why the mapper never sends one', async () => {
+    expect((await read(condition('is_null'))).sql).not.toMatch(/WHERE/)
+  })
+})

package/__tests__/pagination-filter-groups.test.ts

@@ -0,0 +1,186 @@
+import * as types from '@babel/types'
+import generator from '@babel/generator'
+import {
+  ChunkDefinition,
+  ChunkType,
+  ComponentStructure,
+  FileType,
+} from '@teleporthq/teleport-types'
+import { createNextArrayMapperPaginationPlugin } from '../src/pagination-plugin'
+import {
+  makeUidlNode,
+  makeWidgetComponentChunk,
+  type RepeaterOptions,
+} from './_helpers/pagination-widget-fixture'
+
+/**
+ * A list filter can say "Category is Commercial OR Narrative" — an "any of"
+ * group. The paginated and searchable lists used to flatten that group into a
+ * flat list the fetcher joined with AND, so the published site showed the rows
+ * that were BOTH Commercial and Narrative: none. The group now reaches the
+ * fetcher as a group, in the browser fetch and in the build-time prefetch
+ * alike, and the fetcher's own `normalizeFilterTree` honours its operator
+ * (`filter-groups.test.ts`).
+ */
+
+const condition = (source: string, destination: unknown, operand = '=') => ({
+  type: 'condition',
+  source,
+  destination,
+  operand,
+})
+
+const group = (operator: 'and' | 'or', children: unknown[]) => ({
+  type: 'group',
+  operator,
+  children,
+})
+
+const stateRef = (id: string) => ({ type: 'dynamic', content: { referenceType: 'state', id } })
+
+const collapse = (code: string): string => code.replace(/\s+/g, ' ')
+
+// The page's `getStaticProps` as the main data-source plugin leaves it: a
+// `Promise.all` of prefetches and a `props` object, which the pagination plugin
+// extends with the paginated list's first page and its count.
+const makeGetStaticPropsChunk = (): ChunkDefinition => ({
+  name: 'getStaticProps',
+  type: ChunkType.AST,
+  fileType: FileType.JS,
+  linkAfter: ['jsx-component'],
+  meta: {},
+  content: types.exportNamedDeclaration(
+    types.functionDeclaration(
+      types.identifier('getStaticProps'),
+      [types.identifier('context')],
+      types.blockStatement([
+        types.tryStatement(
+          types.blockStatement([
+            types.variableDeclaration('const', [
+              types.variableDeclarator(
+                types.arrayPattern([]),
+                types.awaitExpression(
+                  types.callExpression(
+                    types.memberExpression(types.identifier('Promise'), types.identifier('all')),
+                    [types.arrayExpression([])]
+                  )
+                )
+              ),
+            ]),
+            types.returnStatement(
+              types.objectExpression([
+                types.objectProperty(types.identifier('props'), types.objectExpression([])),
+              ])
+            ),
+          ]),
+          types.catchClause(
+            types.identifier('error'),
+            types.blockStatement([
+              types.returnStatement(
+                types.objectExpression([
+                  types.objectProperty(types.identifier('props'), types.objectExpression([])),
+                ])
+              ),
+            ])
+          )
+        ),
+      ]),
+      false,
+      true
+    )
+  ),
+})
+
+const runPlugin = async (repeater: RepeaterOptions) => {
+  const chunk = makeWidgetComponentChunk({ controls: ['previous', 'next'] })
+  const staticProps = makeGetStaticPropsChunk()
+  const structure: ComponentStructure = {
+    uidl: { name: 'TestComponent', node: makeUidlNode(repeater) },
+    chunks: [chunk, staticProps],
+    dependencies: {},
+    options: { dataSources: {}, extractedResources: {} },
+  } as never
+  await createNextArrayMapperPaginationPlugin()(structure)
+  return {
+    component: collapse(generator(chunk.content as types.Node).code),
+    staticProps: collapse(generator(staticProps.content as types.Node).code),
+  }
+}
+
+const OR_GROUP = [
+  group('or', [condition('Category', 'Commercial'), condition('Category', 'Narrative')]),
+]
+
+const expectOrGroup = (code: string) => {
+  expect(code).toContain('type: "group"')
+  expect(code).toContain('operator: "or"')
+  expect(code).toContain('source: "Category", destination: "Commercial", operand: "="')
+  expect(code).toContain('source: "Category", destination: "Narrative", operand: "="')
+  // The two conditions sit INSIDE the group's children, never beside it.
+  expect(code).toMatch(/children: \[[^\]]*Commercial[^\]]*Narrative[^\]]*\]/)
+}
+
+describe('pagination plugin — filter groups', () => {
+  it('a paginated list keeps an or-group as an or-group in its browser fetch', async () => {
+    const { component } = await runPlugin({ paginated: true, filters: OR_GROUP })
+    expectOrGroup(component)
+  })
+
+  it('a searchable list keeps it too', async () => {
+    const { component } = await runPlugin({
+      paginated: true,
+      searchEnabled: true,
+      filters: OR_GROUP,
+    })
+    expectOrGroup(component)
+  })
+
+  it('the build-time prefetch and its count carry the same group', async () => {
+    const { staticProps } = await runPlugin({ paginated: true, filters: OR_GROUP })
+    expect(staticProps).toContain('page: 1')
+    expectOrGroup(staticProps)
+    // Once for the first page, once for the count.
+    expect(staticProps.match(/operator: "or"/g)).toHaveLength(2)
+  })
+
+  it('the runtime drop of empty destinations lets a group through and prunes inside it', async () => {
+    const { component } = await runPlugin({
+      paginated: true,
+      filters: [
+        group('or', [
+          condition('Category', 'Commercial'),
+          condition('Category', stateRef('picked')),
+        ]),
+      ],
+    })
+    // Every level is filtered; the predicate keeps groups themselves.
+    expect(component).toContain('__f.type === "group" ||')
+    expect(component).toMatch(/children: \[.*\]\.filter\(__f =>/)
+    // The state-bound leaf is still a dependency of the fetch params.
+    expect(component).toContain('picked')
+  })
+
+  it('the prefetch prunes a dynamic leaf but keeps the group around its static sibling', async () => {
+    const { staticProps } = await runPlugin({
+      paginated: true,
+      filters: [
+        group('or', [
+          condition('Category', 'Commercial'),
+          condition('Category', stateRef('picked')),
+        ]),
+      ],
+    })
+    expect(staticProps).toContain('operator: "or"')
+    expect(staticProps).toContain('destination: "Commercial"')
+    expect(staticProps).not.toContain('picked')
+  })
+
+  it('a legacy flat condition list still works', async () => {
+    const { component } = await runPlugin({
+      paginated: true,
+      filters: [{ source: 'Category', destination: 'Commercial', operand: '=' }],
+    })
+    expect(component).toContain('source: "Category", destination: "Commercial", operand: "="')
+    expect(component).not.toContain('type: "group"')
+  })
+})

package/__tests__/pg-date-parser.test.ts

@@ -0,0 +1,73 @@
+/* tslint:disable:function-constructor */
+import { generateDataSourceFetcherWithCore } from '../src/data-source-fetchers'
+
+/**
+ * A Postgres DATE is a calendar day. node-pg reads it as midnight in the
+ * server's time zone, so a server east of UTC served `2026-10-09` as
+ * `2026-10-08T21:00:00.000Z`: the list showed the day before, and an edit form
+ * that loaded the row saved that day back. Every Postgres fetcher keeps the
+ * day as its own text; a stand-in driver without `types` still loads.
+ */
+
+type ParserSpy = Array<{ oid: number; parse: (value: string) => unknown }>
+
+const bootFetcher = (type: 'teleport' | 'postgresql', withTypes: boolean): ParserSpy => {
+  const dataSource = {
+    id: 'ds-1',
+    name: 'db',
+    type,
+    config:
+      type === 'teleport'
+        ? {
+            host: 'teleporthq.secrets.TELEPORT_DB_HOST',
+            port: 5432,
+            user: 'teleporthq.secrets.TELEPORT_DB_USER',
+            password: 'teleporthq.secrets.TELEPORT_DB_PASSWORD',
+            database: 'teleporthq.secrets.TELEPORT_DB_NAME',
+            selectedTables: { orders: { columns: [{ name: 'id' }, { name: 'due' }] } },
+          }
+        : { host: 'h', port: 5432, user: 'u', password: 'p', database: 'd' },
+  }
+  const code = generateDataSourceFetcherWithCore(dataSource as never, 'orders', false, {})
+  expect(code.startsWith("import { Client, types as pgTypes } from 'pg'")).toBe(true)
+  const runnable = code
+    .replace(
+      "import { Client, types as pgTypes } from 'pg'",
+      "const { Client, types: pgTypes } = require('pg')"
+    )
+    .replace(/^export default async function handler/m, 'async function handler')
+    .replace(/^export \{[^}]*\}\s*$/m, '')
+    .replace(/^export default \{[^}]*\}\s*$/m, '')
+  const registered: ParserSpy = []
+  const types = {
+    setTypeParser: (oid: number, parse: (value: string) => unknown) =>
+      registered.push({ oid, parse }),
+  }
+  new Function('require', 'module', 'exports', 'process', 'console', runnable)(
+    (name: string) => {
+      if (name === 'pg') {
+        return withTypes ? { Client: class {}, types } : { Client: class {} }
+      }
+      throw new Error('unexpected require: ' + name)
+    },
+    { exports: {} },
+    {},
+    { env: {} },
+    { error: () => undefined, warn: () => undefined, log: () => undefined }
+  )
+  return registered
+}
+
+describe.each(['teleport', 'postgresql'] as const)('%s fetcher DATE columns', (type) => {
+  it('keeps a DATE as the day it names', () => {
+    const registered = bootFetcher(type, true)
+    const date = registered.find(({ oid }) => oid === 1082)
+    expect(date).toBeDefined()
+    expect(date?.parse('2026-10-09')).toBe('2026-10-09')
+    expect(registered.map(({ oid }) => oid)).toEqual([1082])
+  })
+
+  it('loads with a driver that has no type registry', () => {
+    expect(bootFetcher(type, false)).toEqual([])
+  })
+})