@open-mercato/shared 0.9.1-develop.7574.1.837288eec1 → 0.10.1-develop.7576.1.21d5b50435

package/src/lib/db/advisoryLock.ts

@@ -1,271 +0,0 @@
-import type { EntityManager } from '@mikro-orm/postgresql'
-import { calculateBackoffDelayMs } from '../delivery/retry'
-import { isTransientLockDbError } from './pg-errors'
-
-/** @internal */
-export type AdvisoryLockWaitResult<T> = { done: true; value: T } | { done: false }
-
-export type AdvisoryLockOptions<T> = {
-  /** Total waiting budget from the call start. Default 15_000. */
-  waitDeadlineMs?: number
-  /** @internal Called after each failed attempt, with no connection held; `done: true` short-circuits. */
-  onWait?: () => Promise<AdvisoryLockWaitResult<T>>
-  /** Per process and key namespace: at most this many lock transactions at once (attempts included).
-   *  Waiting for a slot holds no connection and counts against `waitDeadlineMs`. Default: unlimited. */
-  maxConcurrentHolders?: number
-}
-
-const ADVISORY_LOCK_UNAVAILABLE_BRAND = Symbol.for('@open-mercato/shared:AdvisoryLockUnavailableError')
-
-/**
- * The helper's own work failed with an error `isTransientLockDbError` accepts (kept as `cause`), or
- * the wait ran out. `deadline`: the wait budget ran out (contention or no free holder slot), so `fn`
- * never ran. `transient_db`: the begin or the lock query failed, so `fn` never ran. `commit_unknown`:
- * `fn` returned and the flush or commit after it failed, so its writes may or may not be committed.
- * `reason` is additive-only; branch on it, never on the message.
- */
-export type AdvisoryLockUnavailableReason = 'deadline' | 'transient_db' | 'commit_unknown'
-
-const ADVISORY_LOCK_UNAVAILABLE_MESSAGES: Record<AdvisoryLockUnavailableReason, string> = {
-  deadline: '[internal] Advisory lock not acquired before the wait deadline',
-  transient_db: '[internal] Advisory lock transaction failed with a transient database error',
-  commit_unknown: '[internal] Advisory lock transaction failed after its callback returned; the commit outcome is unknown',
-}
-
-export class AdvisoryLockUnavailableError extends Error {
-  static [Symbol.hasInstance](value: unknown): boolean {
-    return typeof value === 'object' && value !== null && Reflect.get(value, ADVISORY_LOCK_UNAVAILABLE_BRAND) === true
-  }
-
-  readonly reason: AdvisoryLockUnavailableReason
-  readonly key: string
-  constructor(reason: AdvisoryLockUnavailableReason, key: string, cause?: unknown) {
-    super(ADVISORY_LOCK_UNAVAILABLE_MESSAGES[reason], cause === undefined ? undefined : { cause })
-    Object.defineProperty(this, ADVISORY_LOCK_UNAVAILABLE_BRAND, { value: true, enumerable: false })
-    this.name = 'AdvisoryLockUnavailableError'
-    this.reason = reason
-    this.key = key
-  }
-}
-
-const DEFAULT_WAIT_DEADLINE_MS = 15_000
-const BACKOFF_ATTEMPT_CAP = 5
-const BACKOFF_OPTIONS = { baseDelayMs: 50, maxJitterMs: 25 }
-const KEY_NAMESPACE_PATTERN = /^[a-z][a-z0-9_]*$/
-const ADVISORY_LOCK_SQL = 'select pg_try_advisory_xact_lock(hashtextextended(?, 0)) as locked'
-
-/**
- * `disableContextResolution` keeps the fork off an outer transaction resolved from the
- * async context, `useContext: false` keeps the fork's own transaction from joining one
- * later, `disableTransactions: false` keeps a source EntityManager with transactions disabled
- * from turning the lock into a statement-scoped no-op, and the cloned event manager carries
- * the request's subscribers (tenant field encryption among them) into the lock transaction.
- */
-const LOCK_FORK_OPTIONS = {
-  disableContextResolution: true,
-  clear: true,
-  useContext: false,
-  disableTransactions: false,
-  cloneEventManager: true,
-}
-
-/**
- * Holder slots live on `globalThis` so duplicated module instances in one process (dev
- * HMR, standalone server chunks) count against one limit. The map is created once and
- * never replaced; each namespace entry is created on first use and kept.
- */
-const GLOBAL_SLOTS_KEY = '__openMercatoAdvisoryLockSlots__'
-
-type SlotWaiter = {
-  limit: number
-  grant: () => void
-}
-
-type NamespaceSlots = {
-  held: number
-  waiters: SlotWaiter[]
-}
-
-type SlotRelease = () => void
-
-type AttemptOutcome<T> = { acquired: true; value: T } | { acquired: false }
-
-const NOT_ACQUIRED: AttemptOutcome<never> = { acquired: false }
-
-const releaseNothing: SlotRelease = () => undefined
-
-function getSlotRegistry(): Map<string, NamespaceSlots> {
-  const globals = globalThis as Record<string, unknown>
-  const existing = globals[GLOBAL_SLOTS_KEY]
-  if (existing instanceof Map) return existing as Map<string, NamespaceSlots>
-  const created = new Map<string, NamespaceSlots>()
-  globals[GLOBAL_SLOTS_KEY] = created
-  return created
-}
-
-function getNamespaceSlots(namespace: string): NamespaceSlots {
-  const registry = getSlotRegistry()
-  const existing = registry.get(namespace)
-  if (existing) return existing
-  const created: NamespaceSlots = { held: 0, waiters: [] }
-  registry.set(namespace, created)
-  return created
-}
-
-function handOffSlots(slots: NamespaceSlots): void {
-  let index = 0
-  while (index < slots.waiters.length) {
-    const waiter = slots.waiters[index]
-    if (slots.held >= waiter.limit) {
-      index += 1
-      continue
-    }
-    slots.waiters.splice(index, 1)
-    slots.held += 1
-    waiter.grant()
-  }
-}
-
-function createSlotRelease(slots: NamespaceSlots): SlotRelease {
-  let released = false
-  return () => {
-    if (released) return
-    released = true
-    slots.held -= 1
-    handOffSlots(slots)
-  }
-}
-
-function acquireSlot(namespace: string, limit: number, key: string, deadlineAt: number): Promise<SlotRelease> {
-  const slots = getNamespaceSlots(namespace)
-  if (slots.held < limit) {
-    slots.held += 1
-    return Promise.resolve(createSlotRelease(slots))
-  }
-  const remainingMs = deadlineAt - Date.now()
-  if (remainingMs <= 0) return Promise.reject(new AdvisoryLockUnavailableError('deadline', key))
-  return new Promise<SlotRelease>((resolve, reject) => {
-    const waiter: SlotWaiter = {
-      limit,
-      grant: () => {
-        clearTimeout(deadlineTimer)
-        resolve(createSlotRelease(slots))
-      },
-    }
-    const deadlineTimer = setTimeout(() => {
-      const position = slots.waiters.indexOf(waiter)
-      if (position >= 0) slots.waiters.splice(position, 1)
-      reject(new AdvisoryLockUnavailableError('deadline', key))
-    }, remainingMs)
-    slots.waiters.push(waiter)
-  })
-}
-
-function parseKeyNamespace(key: unknown): string {
-  const separator = typeof key === 'string' ? key.indexOf(':') : -1
-  if (typeof key === 'string' && separator > 0 && separator < key.length - 1) {
-    const namespace = key.slice(0, separator)
-    if (KEY_NAMESPACE_PATTERN.test(namespace)) return namespace
-  }
-  throw new TypeError('[internal] Advisory lock key must be "<namespace>:<parts>" with a namespace matching ^[a-z][a-z0-9_]*$')
-}
-
-function resolveWaitDeadlineMs(value: number | undefined): number {
-  if (value === undefined) return DEFAULT_WAIT_DEADLINE_MS
-  if (Number.isFinite(value) && value >= 0) return value
-  throw new TypeError('[internal] Advisory lock waitDeadlineMs must be a finite number of at least 0')
-}
-
-function resolveMaxConcurrentHolders(value: number | undefined): number | null {
-  if (value === undefined) return null
-  if (Number.isInteger(value) && value > 0) return value
-  throw new TypeError('[internal] Advisory lock maxConcurrentHolders must be a positive integer')
-}
-
-function sleep(delayMs: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, delayMs))
-}
-
-async function attemptLock<T>(
-  lockEm: EntityManager,
-  key: string,
-  fn: (txEm: EntityManager) => Promise<T>,
-): Promise<AttemptOutcome<T>> {
-  const callback: { thrown: boolean; returned: boolean; error: unknown } = { thrown: false, returned: false, error: undefined }
-  try {
-    return await lockEm.transactional(async (txEm): Promise<AttemptOutcome<T>> => {
-      const rows = await txEm.execute<Array<{ locked: boolean }>>(ADVISORY_LOCK_SQL, [key])
-      if (rows[0]?.locked !== true) return NOT_ACQUIRED
-      try {
-        const value = await fn(txEm)
-        callback.returned = true
-        return { acquired: true, value }
-      } catch (error) {
-        callback.thrown = true
-        callback.error = error
-        throw error
-      }
-    })
-  } catch (error) {
-    if (callback.thrown) throw callback.error
-    if (isTransientLockDbError(error)) {
-      throw new AdvisoryLockUnavailableError(callback.returned ? 'commit_unknown' : 'transient_db', key, error)
-    }
-    throw error
-  }
-}
-
-/**
- * Runs `fn` in one transaction that holds `pg_try_advisory_xact_lock(hashtextextended(key, 0))`.
- * - `key` is `<namespace>:<parts>` with namespace `^[a-z][a-z0-9_]*$`; anything else throws `TypeError`.
- * - `waitDeadlineMs` must be a finite number ≥ 0 and `maxConcurrentHolders` a positive integer;
- *   anything else throws `TypeError` before any connection is taken.
- * - Pass the request (container) EntityManager. The helper forks it with
- *   `{ disableContextResolution: true, clear: true, useContext: false, disableTransactions: false, cloneEventManager: true }`,
- *   so the lock transaction never nests in a caller's transaction and commits on its own.
- * - `fn` MUST do all DB I/O on `txEm`, MUST flush its own writes, MUST be bounded (≤ one external
- *   call), MUST NOT call `transactional` again (it only opens a savepoint in the lock transaction) and
- *   MUST NOT fork or use `getConnection().execute` (another pooled connection, outside the lock).
- * - `txEm` carries the request EntityManager's subscribers (cloned event manager).
- * - A failed attempt ends its empty transaction, so waiters hold no connection between attempts.
- *   They back off 50 ms doubling up to 800 ms (plus up to 24 ms jitter), never past
- *   `waitDeadlineMs` measured from the call start, then retry.
- * - With `maxConcurrentHolders`, each attempt first takes a per-process slot for the key
- *   namespace and gives it back when the attempt fails or the lock transaction settles.
- * - Errors from the helper's own begin, lock query and commit that `isTransientLockDbError` accepts,
- *   and the deadline, throw `AdvisoryLockUnavailableError` (its `reason` says whether `fn` ran); any
- *   other error from them, and every error thrown by `fn`, propagates unchanged (a throw from `fn`
- *   rolls back).
- */
-export async function withAdvisoryXactLock<T>(
-  em: EntityManager,
-  key: string,
-  fn: (txEm: EntityManager) => Promise<T>,
-  options: AdvisoryLockOptions<T> = {},
-): Promise<T> {
-  const namespace = parseKeyNamespace(key)
-  const waitDeadlineMs = resolveWaitDeadlineMs(options.waitDeadlineMs)
-  const maxConcurrentHolders = resolveMaxConcurrentHolders(options.maxConcurrentHolders)
-  const deadlineAt = Date.now() + waitDeadlineMs
-  const lockEm = em.fork(LOCK_FORK_OPTIONS)
-  for (let attempt = 1; ; attempt += 1) {
-    const releaseSlot = maxConcurrentHolders === null
-      ? releaseNothing
-      : await acquireSlot(namespace, maxConcurrentHolders, key, deadlineAt)
-    let outcome: AttemptOutcome<T>
-    try {
-      outcome = await attemptLock(lockEm, key, fn)
-    } finally {
-      releaseSlot()
-    }
-    if (outcome.acquired) return outcome.value
-    const remainingMs = deadlineAt - Date.now()
-    if (remainingMs <= 0) throw new AdvisoryLockUnavailableError('deadline', key)
-    await sleep(Math.min(calculateBackoffDelayMs(Math.min(attempt, BACKOFF_ATTEMPT_CAP), BACKOFF_OPTIONS), remainingMs))
-    if (options.onWait) {
-      const waitResult = await options.onWait()
-      if (waitResult.done) return waitResult.value
-    }
-    if (Date.now() >= deadlineAt) throw new AdvisoryLockUnavailableError('deadline', key)
-  }
-}

package/src/lib/openapi/__tests__/optional-path-params.test.ts

@@ -1,102 +0,0 @@
-import { z } from 'zod'
-import { buildOpenApiDocument } from '../generator'
-import type { Module } from '../../../modules/registry'
-
-type ParameterNode = { name?: string; in?: string; required?: boolean }
-type OperationNode = { operationId?: string; parameters?: ParameterNode[] }
-
-const noopHandler = async () => new Response(null)
-
-function imageModule(extraApis: unknown[] = [], operationId?: string): Module {
-  return {
-    id: 'attachments',
-    apis: [
-      {
-        path: '/attachments/image/[id]/[[...slug]]',
-        handlers: { GET: noopHandler },
-        docs: {
-          methods: {
-            GET: {
-              summary: 'Serve image',
-              ...(operationId ? { operationId } : {}),
-              pathParams: z.object({ id: z.string().uuid() }),
-              responses: [{ status: 200, description: 'Image' }],
-            },
-          },
-        },
-      },
-      ...extraApis,
-    ],
-  } as unknown as Module
-}
-
-function operation(doc: ReturnType<typeof buildOpenApiDocument>, path: string): OperationNode | undefined {
-  return (doc.paths[path] as Record<string, OperationNode> | undefined)?.get
-}
-
-function collectPathParameterViolations(doc: ReturnType<typeof buildOpenApiDocument>): string[] {
-  const violations: string[] = []
-  const operationIds = new Set<string>()
-  for (const [path, item] of Object.entries(doc.paths)) {
-    const templateNames = Array.from(path.matchAll(/\{([^}]+)\}/g), (match) => match[1])
-    for (const [method, op] of Object.entries(item as Record<string, OperationNode>)) {
-      const pathParams = (op.parameters ?? []).filter((param) => param.in === 'path')
-      for (const param of pathParams) {
-        if (param.required !== true) violations.push(`${method} ${path}: path parameter ${param.name} is not required`)
-        if (!templateNames.includes(param.name ?? '')) violations.push(`${method} ${path}: path parameter ${param.name} is not in the template`)
-      }
-      for (const name of templateNames) {
-        if (!pathParams.some((param) => param.name === name)) violations.push(`${method} ${path}: template variable ${name} is not declared`)
-      }
-      if (op.operationId) {
-        if (operationIds.has(op.operationId)) violations.push(`${method} ${path}: duplicate operationId ${op.operationId}`)
-        operationIds.add(op.operationId)
-      }
-    }
-  }
-  return violations
-}
-
-describe('buildOpenApiDocument optional catch-all path parameters', () => {
-  it('emits id-only and id-plus-slug paths with only required path parameters', () => {
-    const doc = buildOpenApiDocument([imageModule()])
-
-    expect(collectPathParameterViolations(doc)).toEqual([])
-
-    const withSlug = operation(doc, '/attachments/image/{id}/{slug}')
-    const withoutSlug = operation(doc, '/attachments/image/{id}')
-    expect(withSlug?.parameters?.filter((param) => param.in === 'path').map((param) => param.name)).toEqual(['id', 'slug'])
-    expect(withoutSlug?.parameters?.filter((param) => param.in === 'path').map((param) => param.name)).toEqual(['id'])
-  })
-
-  it('keeps the published operationId on the slug path and gives the id-only path a distinct one', () => {
-    const doc = buildOpenApiDocument([imageModule()])
-
-    expect(operation(doc, '/attachments/image/{id}/{slug}')?.operationId).toBe('attachments_get_attachments_image_id_slug')
-    expect(operation(doc, '/attachments/image/{id}')?.operationId).toBe('attachments_get_attachments_image_id')
-  })
-
-  it('derives a distinct id-only operationId from an explicit operationId', () => {
-    const doc = buildOpenApiDocument([imageModule([], 'serveImage')])
-
-    expect(operation(doc, '/attachments/image/{id}/{slug}')?.operationId).toBe('serveImage')
-    expect(operation(doc, '/attachments/image/{id}')?.operationId).toBe('serveImage_without_slug')
-  })
-
-  it('never replaces a concrete route that owns the id-only path, whichever is registered first', () => {
-    const concreteRoute = {
-      path: '/attachments/image/[id]',
-      handlers: { GET: noopHandler },
-      docs: { methods: { GET: { summary: 'Concrete', operationId: 'concreteImage', responses: [{ status: 200, description: 'OK' }] } } },
-    }
-    const after = buildOpenApiDocument([imageModule([concreteRoute])])
-    const before = buildOpenApiDocument([
-      { id: 'other', apis: [concreteRoute] } as unknown as Module,
-      imageModule(),
-    ])
-
-    expect(operation(after, '/attachments/image/{id}')?.operationId).toBe('concreteImage')
-    expect(operation(before, '/attachments/image/{id}')?.operationId).toBe('concreteImage')
-    expect(collectPathParameterViolations(after)).toEqual([])
-  })
-})

package/src/lib/query/__tests__/empty-ids-filter.pg.test.ts

@@ -1,89 +0,0 @@
-/**
- * End-to-end proof for #7502 against a real PostgreSQL: a `?ids=` filter that
- * leaves no valid id (`{ id: { $in: [] } }`, the shape `mergeIdFilter` produces
- * for an unparseable or disjoint id list) must answer an empty page, not a
- * 42601 syntax error from Kysely compiling `in ()`.
- *
- * Gated on OM_COUNT_CAP_PG_URL (a throwaway database — the suite creates and
- * drops its own table). Example:
- *   docker run --rm -d -p 54329:5432 -e POSTGRES_PASSWORD=t postgres:16
- *   OM_COUNT_CAP_PG_URL=postgres://postgres:t@localhost:54329/postgres yarn jest empty-ids-filter.pg
- */
-import { Kysely, PostgresDialect, sql } from 'kysely'
-import { BasicQueryEngine } from '../engine'
-
-const PG_URL = process.env.OM_COUNT_CAP_PG_URL
-const maybe = PG_URL ? describe : describe.skip
-
-const TENANT = '11111111-1111-4111-8111-111111111111'
-const ORG = '22222222-2222-4222-8222-222222222222'
-const ENTITY = 'capcheck:om_emptyids_order'
-const TABLE = 'om_emptyids_orders'
-const ID_A = '33333333-3333-4333-8333-000000000001'
-const ID_B = '33333333-3333-4333-8333-000000000002'
-
-maybe('empty $in/$nin filter against PostgreSQL', () => {
-  jest.setTimeout(30_000)
-  let db: Kysely<any>
-
-  beforeAll(async () => {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { Pool } = require('pg')
-    db = new Kysely<any>({ dialect: new PostgresDialect({ pool: new Pool({ connectionString: PG_URL }) }) })
-    await sql`drop table if exists om_emptyids_orders`.execute(db)
-    await sql`create table om_emptyids_orders (
-      id uuid primary key,
-      tenant_id uuid not null,
-      organization_id uuid not null,
-      deleted_at timestamptz,
-      status text not null
-    )`.execute(db)
-    await sql`insert into om_emptyids_orders (id, tenant_id, organization_id, deleted_at, status) values
-      (${ID_A}::uuid, ${TENANT}::uuid, ${ORG}::uuid, null, 'open'),
-      (${ID_B}::uuid, ${TENANT}::uuid, ${ORG}::uuid, null, 'closed')`.execute(db)
-  })
-
-  afterAll(async () => {
-    await sql`drop table if exists om_emptyids_orders`.execute(db)
-    await db.destroy()
-  })
-
-  const makeEngine = () => new BasicQueryEngine({} as any, () => db as any)
-  const baseOpts = {
-    tenantId: TENANT,
-    organizationId: ORG,
-    fields: ['id'],
-    page: { page: 1, pageSize: 10 },
-  }
-
-  test('?ids= with no valid id returns an empty page instead of a 500 (AND path)', async () => {
-    const result = await makeEngine().query(ENTITY, {
-      ...baseOpts,
-      filters: { id: { $in: [] } },
-    })
-    expect(result.items).toEqual([])
-    expect(result.total).toBe(0)
-  })
-
-  test('a disjoint ?id=&?ids= intersection inside an $or group still matches the other disjunct', async () => {
-    const result = await makeEngine().query(ENTITY, {
-      ...baseOpts,
-      filters: {
-        $or: [
-          { id: { $in: [] } },
-          { status: { $eq: 'closed' } },
-        ],
-      },
-    })
-    expect(result.items.map((row: any) => row.id)).toEqual([ID_B])
-    expect(result.total).toBe(1)
-  })
-
-  test('an empty $nin excludes nothing, matching every row', async () => {
-    const result = await makeEngine().query(ENTITY, {
-      ...baseOpts,
-      filters: { id: { $nin: [] } },
-    })
-    expect(result.total).toBe(2)
-  })
-})

package/src/lib/query/__tests__/engine.empty-in-filter.test.ts

@@ -1,79 +0,0 @@
-/**
- * #7502: `mergeIdFilter` deliberately produces `{ $in: [] }` for a `?ids=` param
- * that left no valid UUID (or a disjoint `?id=`+`?ids=` intersection) — the
- * correct "match nothing" semantics. Both engine where-builders used to pass
- * that empty array straight to Kysely's `.where(column, 'in', [])`, which
- * compiles to invalid SQL (`in ()`) and makes Postgres answer 42601/500
- * instead of an empty page. These tests pin the guard directly on the two
- * private builder methods — no real SQL execution needed to prove the shape
- * changed; `count-cap-plan.test.ts`-style Postgres-gated tests cover the
- * end-to-end compiled-SQL behavior.
- */
-import { BasicQueryEngine } from '../engine'
-
-describe('applyColumnOp empty $in/$nin guard (#7502)', () => {
-  const engine = new BasicQueryEngine({} as any, () => ({}) as any)
-
-  function callApplyColumnOp(op: string, value: unknown) {
-    const calls: any[] = []
-    const builder: any = {
-      where: (...args: any[]) => {
-        calls.push(args)
-        return builder
-      },
-    }
-    ;(engine as any).applyColumnOp(builder, 'id', op, value)
-    return calls
-  }
-
-  test('empty $in does not reach Kysely as an empty in-list', () => {
-    const calls = callApplyColumnOp('in', [])
-    expect(calls).toHaveLength(1)
-    // Pre-fix this called builder.where('id', 'in', []) -- three arguments, the
-    // shape Kysely compiles to invalid SQL. Post-fix it is a single predicate arg.
-    expect(calls[0]).not.toEqual(['id', 'in', []])
-    expect(calls[0]).toHaveLength(1)
-  })
-
-  test('non-empty $in keeps the original in-list predicate', () => {
-    const calls = callApplyColumnOp('in', ['a'])
-    expect(calls[0]).toEqual(['id', 'in', ['a']])
-  })
-
-  test('empty $nin does not reach Kysely as an empty not-in-list', () => {
-    const calls = callApplyColumnOp('nin', [])
-    expect(calls[0]).toHaveLength(1)
-    expect(calls[0]).not.toEqual(['id', 'not in', []])
-  })
-
-  test('non-empty $nin keeps the original not-in-list predicate', () => {
-    const calls = callApplyColumnOp('nin', ['a'])
-    expect(calls[0]).toEqual(['id', 'not in', ['a']])
-  })
-})
-
-describe('buildColumnOpExpression empty $in/$nin guard (#7502, OR-group path)', () => {
-  const engine = new BasicQueryEngine({} as any, () => ({}) as any)
-
-  function callBuildColumnOpExpression(op: string, value: unknown) {
-    const eb: any = (...args: any[]) => ({ kind: 'cmp', args })
-    eb.val = (v: any) => ({ kind: 'val', value: v })
-    return (engine as any).buildColumnOpExpression(eb, 'id', op, value)
-  }
-
-  test('empty $in compiles to a never-match literal, not an empty in-list comparison', () => {
-    expect(callBuildColumnOpExpression('in', [])).toEqual({ kind: 'val', value: false })
-  })
-
-  test('non-empty $in keeps the original in-list comparison', () => {
-    expect(callBuildColumnOpExpression('in', ['a'])).toEqual({ kind: 'cmp', args: ['id', 'in', ['a']] })
-  })
-
-  test('empty $nin compiles to an always-match literal, not an empty not-in-list comparison', () => {
-    expect(callBuildColumnOpExpression('nin', [])).toEqual({ kind: 'val', value: true })
-  })
-
-  test('non-empty $nin keeps the original not-in-list comparison', () => {
-    expect(callBuildColumnOpExpression('nin', ['a'])).toEqual({ kind: 'cmp', args: ['id', 'not in', ['a']] })
-  })
-})