@happyvertical/sql 0.112.2 → 0.113.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (44) hide show
  1. package/AGENT.md +18 -0
  2. package/README.md +100 -1
  3. package/dist/chunks/{duckdb-DCV4JFWK.js → duckdb-aMJ05d68.js} +11 -4
  4. package/dist/chunks/duckdb-aMJ05d68.js.map +1 -0
  5. package/dist/chunks/{postgres-dialect-CaNhva-C.js → postgres-dialect-C8GwYO-9.js} +14 -3
  6. package/dist/chunks/postgres-dialect-C8GwYO-9.js.map +1 -0
  7. package/dist/chunks/{query-Dz0TZ0pY.js → query-CcLSVKOo.js} +3 -46
  8. package/dist/chunks/query-CcLSVKOo.js.map +1 -0
  9. package/dist/chunks/{sqlite-nNhv0FMq.js → sqlite-DAzuB3Hb.js} +18 -11
  10. package/dist/chunks/sqlite-DAzuB3Hb.js.map +1 -0
  11. package/dist/chunks/sqlite-engine-ByvkAlrK.js +205 -0
  12. package/dist/chunks/sqlite-engine-ByvkAlrK.js.map +1 -0
  13. package/dist/chunks/{sqlite-native-CZGNm9zh.js → sqlite-native-Dj0hF4qn.js} +13 -6
  14. package/dist/chunks/sqlite-native-Dj0hF4qn.js.map +1 -0
  15. package/dist/chunks/{schema-manager-psLzQ2yh.js → types-DihIt7ez.js} +73 -2
  16. package/dist/chunks/types-DihIt7ez.js.map +1 -0
  17. package/dist/duckdb.d.ts.map +1 -1
  18. package/dist/index.d.ts +2 -2
  19. package/dist/index.d.ts.map +1 -1
  20. package/dist/index.js +31 -6
  21. package/dist/index.js.map +1 -1
  22. package/dist/json.d.ts.map +1 -1
  23. package/dist/pglite.d.ts.map +1 -1
  24. package/dist/pglite.js +9 -2
  25. package/dist/pglite.js.map +1 -1
  26. package/dist/postgres.d.ts.map +1 -1
  27. package/dist/query.js +3 -3
  28. package/dist/shared/reopen.d.ts +7 -0
  29. package/dist/shared/reopen.d.ts.map +1 -0
  30. package/dist/shared/sqlite-engine.d.ts +32 -0
  31. package/dist/shared/sqlite-engine.d.ts.map +1 -0
  32. package/dist/shared/types.d.ts +91 -0
  33. package/dist/shared/types.d.ts.map +1 -1
  34. package/dist/sqlite-native.d.ts.map +1 -1
  35. package/dist/sqlite.d.ts.map +1 -1
  36. package/package.json +3 -3
  37. package/dist/chunks/duckdb-DCV4JFWK.js.map +0 -1
  38. package/dist/chunks/postgres-dialect-CaNhva-C.js.map +0 -1
  39. package/dist/chunks/query-Dz0TZ0pY.js.map +0 -1
  40. package/dist/chunks/schema-manager-psLzQ2yh.js.map +0 -1
  41. package/dist/chunks/sqlite-connection-cache-BycfrYfi.js +0 -70
  42. package/dist/chunks/sqlite-connection-cache-BycfrYfi.js.map +0 -1
  43. package/dist/chunks/sqlite-nNhv0FMq.js.map +0 -1
  44. package/dist/chunks/sqlite-native-CZGNm9zh.js.map +0 -1
@@ -1 +0,0 @@
1
- {"version":3,"file":"query-Dz0TZ0pY.js","names":[],"sources":["../../src/aggregate-expression.ts","../../src/aggregate.ts","../../src/shared/duckdb-schema-utils.ts","../../src/shared/types.ts","../../src/query.ts"],"sourcesContent":["// biome-ignore-all lint/suspicious/noThenProperty: CASE nodes are closed data, not thenable functions.\nimport { quoteLiteralIdentifier } from './shared/alter-utils.js';\nimport type { SqlAdapterType } from './shared/utils.js';\n\n/**\n * Closed, structured expression nodes for {@link buildAggregate}.\n *\n * An expression is data, never SQL text: every node is checked against a fixed\n * set of operators, column references are validated identifiers, and literals\n * are either inlined after validation (finite numbers, booleans, null) or\n * bound as parameters (strings, dates). There is no raw-SQL escape hatch.\n */\n\n/** A scalar a node may hold. Strings and dates are bound; the rest are inlined. */\nexport type AggregateLiteral =\n | string\n | number\n | boolean\n | Date\n | TypedDateLiteral\n | null;\n\nexport type AggregateArithmeticOp = 'add' | 'sub' | 'mul' | 'div';\nexport type AggregateComparisonOp = 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte';\n\nexport type AggregateOperand =\n /** A column, bare (`qty`) or qualified by a table alias (`wo.estimated_hours`). */\n | { col: string }\n /** A literal value. */\n | { value: AggregateLiteral }\n | AggregateExpression;\n\n/** JSON-safe calendar date or UTC datetime (offsets are canonicalized to UTC). */\nexport interface TypedDateLiteral {\n kind: 'date' | 'datetime';\n iso: string;\n}\n\nexport type PortableExpression =\n | {\n op: 'case';\n branches: { when: AggregateOperand; then: AggregateOperand }[];\n else: AggregateOperand;\n }\n | {\n op: 'if';\n condition: AggregateOperand;\n then: AggregateOperand;\n else: AggregateOperand;\n }\n | { op: 'round'; value: AggregateOperand; digits: AggregateOperand }\n | {\n op:\n | 'abs'\n | 'floor'\n | 'ceil'\n | 'lower'\n | 'upper'\n | 'trim'\n | 'length'\n | 'year'\n | 'month'\n | 'day';\n value: AggregateOperand;\n }\n | { op: 'least' | 'greatest' | 'concat'; operands: AggregateOperand[] }\n | { op: 'mod'; left: AggregateOperand; right: AggregateOperand }\n | {\n op: 'substring';\n value: AggregateOperand;\n start: AggregateOperand;\n length: AggregateOperand;\n }\n | { op: 'daysBetween'; later: AggregateOperand; earlier: AggregateOperand }\n | { op: 'addDays'; value: AggregateOperand; days: AggregateOperand };\n\nexport type AggregateExpression =\n | PortableExpression\n /**\n * `left op right`. `div` yields a fractional result on every dialect (integer\n * operands are not truncated) and NULL, not an error, for a zero divisor.\n */\n | {\n op: AggregateArithmeticOp;\n left: AggregateOperand;\n right: AggregateOperand;\n }\n /**\n * Seconds from `earlier` to `later`, both timestamps; fractional, NULL if\n * either is NULL. Positive when `later` is after `earlier`.\n */\n | { op: 'secondsBetween'; later: AggregateOperand; earlier: AggregateOperand }\n /**\n * A comparison. `eq`/`ne` against a NULL literal compare with IS [NOT] NULL;\n * any other comparison involving NULL is NULL (not true), as in SQL.\n */\n | {\n op: AggregateComparisonOp;\n left: AggregateOperand;\n right: AggregateOperand;\n }\n | { op: 'and' | 'or'; operands: AggregateOperand[] }\n | { op: 'not'; operand: AggregateOperand }\n | { op: 'isNull' | 'isNotNull'; operand: AggregateOperand }\n /** The first operand that is not NULL. */\n | { op: 'coalesce'; operands: AggregateOperand[] }\n /**\n * The operand as text (`CAST(x AS TEXT)`; `VARCHAR` on DuckDB/JSON), NULL\n * stays NULL. Lets a join compare keys of different types, such as a text\n * reference with a uuid id, without an error for a value that is not a uuid.\n * Comparing a cast column cannot use that column's index.\n */\n | { op: 'asText'; operand: AggregateOperand };\n\n/** A table joined to the aggregate's `from`. */\nexport interface AggregateJoin {\n /** The joined table. */\n table: string;\n /** Its alias in the query; referenced as `alias.column`. Unique, no dots. */\n alias: string;\n /** `inner` (default) or `left`. */\n type?: 'inner' | 'left';\n /**\n * The join condition. Callers put a tenant equality here (for example\n * `eq(a.tenant_id, b.tenant_id)`) so ids that collide across tenants never\n * match; the builder does not know what a tenant is.\n */\n on: AggregateExpression;\n}\n\nconst MAX_DEPTH = 24;\n/** Node budget for a whole spec (every select item, join, filter and predicate together). */\nconst MAX_NODES = 1024;\n\nconst ARITHMETIC: Record<AggregateArithmeticOp, string> = {\n add: '+',\n sub: '-',\n mul: '*',\n div: '/',\n};\nconst COMPARISON: Record<AggregateComparisonOp, string> = {\n eq: '=',\n ne: '<>',\n lt: '<',\n lte: '<=',\n gt: '>',\n gte: '>=',\n};\n\n/** Where an expression renders: its identifier checks and its parameter numbering. */\nexport interface ExpressionContext {\n adapterType: SqlAdapterType | undefined;\n /** The parameter index the next bound value takes. Advanced as values are bound. */\n nextIndex: number;\n /** Values bound so far, in index order. */\n values: unknown[];\n /** Validates (and returns) an identifier; throws on anything unsafe. */\n identifier: (identifier: string) => string;\n /** Called with each column reference so the caller can check its table alias. */\n onColumn?: (column: string) => void;\n /** Nodes rendered so far across every expression of one build; capped at {@link MAX_NODES}. */\n nodeCount?: number;\n /** Public rendering policy; omitted by the aggregate builder for compatibility. */\n mode?: 'ddl' | 'query';\n columnType?: (column: string) => ExpressionResultType;\n /** Cumulative rendering work, including SQL duplicated by portable guards. */\n sqlWork?: number;\n}\n\ninterface RenderState {\n ctx: ExpressionContext;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction literal(value: unknown, state: RenderState): string {\n const { ctx } = state;\n if (isRecord(value) && 'kind' in value) return typedDate(value, state);\n if (value === null) return 'NULL';\n if (typeof value === 'boolean') return value ? 'TRUE' : 'FALSE';\n if (typeof value === 'number') {\n if (!Number.isFinite(value)) {\n throw new ExpressionError(\n 'INVALID_EXPRESSION',\n 'Aggregate expression numbers must be finite',\n );\n }\n // Inlined: a finite number cannot carry SQL, and an inlined number avoids\n // an untyped parameter (`$1 + $2`) that Postgres cannot infer.\n return String(value);\n }\n if (value instanceof Date) {\n if (Number.isNaN(value.getTime())) {\n throw new ExpressionError(\n 'INVALID_EXPRESSION',\n 'Aggregate expression dates must be valid',\n );\n }\n if (ctx.mode === 'ddl')\n fail(\n 'NON_IMMUTABLE',\n 'Legacy Date literals are not immutable; use a typed date literal',\n );\n const placeholder = `$${ctx.nextIndex++}`;\n ctx.values.push(value.toISOString());\n // DuckDB/JSON cannot infer a timestamp from a bound string (issue #540),\n // and Postgres cannot type two bare parameters (`$1 - $2`).\n if (ctx.adapterType === 'duckdb' || ctx.adapterType === 'json') {\n return `CAST(${placeholder} AS TIMESTAMP)`;\n }\n if (ctx.adapterType === 'postgres') {\n return `CAST(${placeholder} AS TIMESTAMPTZ)`;\n }\n return placeholder;\n }\n if (typeof value === 'string') {\n if (ctx.mode && value.includes('\\0'))\n fail('INVALID_EXPRESSION', 'NUL is not a portable SQL string');\n if (ctx.mode === 'ddl')\n return quoteString(value, ctx.adapterType === 'postgres');\n const placeholder = `$${ctx.nextIndex++}`;\n ctx.values.push(value);\n return placeholder;\n }\n throw new ExpressionError(\n 'INVALID_EXPRESSION',\n 'Aggregate expression literal must be a string, number, boolean, Date or null',\n );\n}\n\nfunction secondsBetween(\n adapterType: SqlAdapterType | undefined,\n later: string,\n earlier: string,\n): string {\n if (adapterType === 'postgres') {\n // A float like the other dialects: EXTRACT returns numeric, which drivers hand back as a string.\n return `CAST(EXTRACT(EPOCH FROM (${later} - ${earlier})) AS DOUBLE PRECISION)`;\n }\n if (adapterType === 'duckdb' || adapterType === 'json') {\n return `epoch(${later}) - epoch(${earlier})`;\n }\n // SQLite stores timestamps as ISO text; julianday reads that and the\n // difference is in days.\n return `((julianday(${later}) - julianday(${earlier})) * 86400.0)`;\n}\n\nfunction renderOperandUnchecked(\n node: unknown,\n state: RenderState,\n depth: number,\n): string {\n if (depth > MAX_DEPTH) {\n throw new ExpressionError(\n 'EXPRESSION_LIMIT',\n `Aggregate expression is nested deeper than ${MAX_DEPTH}`,\n );\n }\n state.ctx.nodeCount = (state.ctx.nodeCount ?? 0) + 1;\n if (state.ctx.nodeCount > MAX_NODES) {\n throw new ExpressionError(\n 'EXPRESSION_LIMIT',\n `Aggregate expression has more than ${MAX_NODES} nodes`,\n );\n }\n if (!isRecord(node)) {\n throw new ExpressionError(\n 'INVALID_EXPRESSION',\n 'Aggregate expression node must be an object',\n );\n }\n const { ctx } = state;\n if (\n ctx.mode ||\n (typeof node.op === 'string' && Object.hasOwn(PORTABLE_FIELDS, node.op))\n )\n validateShape(node);\n\n if ('col' in node) {\n ctx.onColumn?.(node.col as string);\n const column = ctx.identifier(node.col as string);\n return column;\n }\n if ('value' in node && !('op' in node)) {\n return literal(node.value, state);\n }\n\n const op = node.op;\n const child = (value: unknown) => renderOperand(value, state, depth + 1);\n\n if (typeof op === 'string' && Object.hasOwn(ARITHMETIC, op)) {\n const arithmetic = op as AggregateArithmeticOp;\n const left = child(node.left);\n const right = child(node.right);\n if (arithmetic === 'div') {\n // `* 1.0` keeps integer operands fractional (SQLite and Postgres truncate\n // integer division); NULLIF turns a zero divisor into NULL.\n const quotient = `((${left} * 1.0) / NULLIF(${right}, 0))`;\n // A float on every dialect: Postgres would otherwise return numeric,\n // which drivers hand back as a string.\n if (ctx.adapterType === 'postgres') {\n return `CAST(${quotient} AS DOUBLE PRECISION)`;\n }\n if (ctx.adapterType === 'duckdb' || ctx.adapterType === 'json') {\n return `CAST(${quotient} AS DOUBLE)`;\n }\n return quotient;\n }\n return `(${left} ${ARITHMETIC[arithmetic]} ${right})`;\n }\n if (op === 'secondsBetween') {\n if (ctx.mode === 'ddl') {\n requireTemporal(node.later, state);\n requireTemporal(node.earlier, state);\n }\n return secondsBetween(\n ctx.adapterType,\n temporalSeconds(node.later, child(node.later), ctx),\n temporalSeconds(node.earlier, child(node.earlier), ctx),\n );\n }\n if (typeof op === 'string' && Object.hasOwn(COMPARISON, op)) {\n const comparison = op as AggregateComparisonOp;\n const against = (side: unknown): boolean =>\n isRecord(side) && 'value' in side && side.value === null;\n if ((comparison === 'eq' || comparison === 'ne') && against(node.right)) {\n return `(${child(node.left)} IS ${comparison === 'eq' ? 'NULL' : 'NOT NULL'})`;\n }\n if ((comparison === 'eq' || comparison === 'ne') && against(node.left)) {\n return `(${child(node.right)} IS ${comparison === 'eq' ? 'NULL' : 'NOT NULL'})`;\n }\n return `(${child(node.left)} ${COMPARISON[comparison]} ${child(node.right)})`;\n }\n if (op === 'and' || op === 'or') {\n const operands = node.operands;\n if (!Array.isArray(operands) || operands.length === 0) {\n throw new ExpressionError(\n 'INVALID_EXPRESSION',\n `Aggregate expression ${op} requires at least one operand`,\n );\n }\n return `(${operands.map(child).join(op === 'and' ? ' AND ' : ' OR ')})`;\n }\n if (op === 'not') {\n return `(NOT ${child(node.operand)})`;\n }\n if (op === 'isNull' || op === 'isNotNull') {\n return `(${child(node.operand)} IS ${op === 'isNull' ? 'NULL' : 'NOT NULL'})`;\n }\n if (op === 'coalesce') {\n const operands = node.operands;\n if (!Array.isArray(operands) || operands.length === 0) {\n throw new ExpressionError(\n 'INVALID_EXPRESSION',\n 'Aggregate expression coalesce requires at least one operand',\n );\n }\n return `COALESCE(${operands.map(child).join(', ')})`;\n }\n if (op === 'asText') {\n if (\n ctx.mode === 'ddl' &&\n !['number', 'text', 'boolean', 'null'].includes(\n resultType(node.operand, ctx),\n )\n ) {\n fail(\n 'NON_IMMUTABLE',\n 'Generated asText requires known number/text/boolean input; date output depends on session settings',\n );\n }\n const type =\n ctx.adapterType === 'duckdb' || ctx.adapterType === 'json'\n ? 'VARCHAR'\n : 'TEXT';\n return `CAST(${child(node.operand)} AS ${type})`;\n }\n const portable = renderPortable(node, state, child);\n if (portable !== undefined) return portable;\n throw new ExpressionError(\n 'INVALID_EXPRESSION',\n `Unsupported aggregate expression operator: ${String(op)}`,\n );\n}\n\n/**\n * Render an expression node to SQL, binding its string and date literals into\n * `ctx` as numbered parameters. Throws on any unknown operator, unsafe\n * identifier, non-finite number, or an expression too large to be legitimate.\n */\nexport function renderAggregateExpression(\n node: AggregateOperand,\n ctx: ExpressionContext,\n): string {\n let sql = renderOperand(node, { ctx }, 0);\n // Keep dates native inside the expression tree, then expose canonical ISO\n // text at its boundary. PostgreSQL date_out depends on DateStyle.\n if (resultType(node, ctx) === 'date' && isRecord(node) && 'op' in node) {\n if (ctx.adapterType === 'postgres') sql = postgresDateISO(sql);\n else if (ctx.adapterType === 'duckdb' || ctx.adapterType === 'json')\n sql = `CAST(${sql} AS VARCHAR)`;\n ctx.sqlWork = (ctx.sqlWork ?? 0) + sql.length;\n if (ctx.sqlWork > MAX_SQL_WORK)\n fail('EXPRESSION_LIMIT', 'Expression date output exceeds SQL limit');\n }\n return sql;\n}\n\nexport type ExpressionResultType =\n | 'number'\n | 'text'\n | 'boolean'\n | 'date'\n | 'datetime'\n | 'null'\n | 'unknown';\nexport type ExpressionErrorCode =\n | 'INVALID_EXPRESSION'\n | 'NON_IMMUTABLE'\n | 'EXPRESSION_LIMIT';\n\n/** Coded validation failures suitable for persisted/untrusted expression data. */\nexport class ExpressionError extends Error {\n constructor(\n public readonly code: ExpressionErrorCode,\n message: string,\n ) {\n super(message);\n this.name = 'ExpressionError';\n }\n}\n\nfunction fail(code: ExpressionErrorCode, message: string): never {\n throw new ExpressionError(code, message);\n}\n\n// Check every intermediate fragment before its parent can duplicate it. A depth\n// bound alone permits exponential growth in SQL emitted for NULL guards.\nconst MAX_SQL_WORK = 262_144;\nfunction renderOperand(\n node: unknown,\n state: RenderState,\n depth: number,\n): string {\n const sql = renderOperandUnchecked(node, state, depth);\n state.ctx.sqlWork = (state.ctx.sqlWork ?? 0) + sql.length;\n if (state.ctx.sqlWork > MAX_SQL_WORK) {\n fail(\n 'EXPRESSION_LIMIT',\n `Expression SQL exceeds ${MAX_SQL_WORK} characters of rendering work`,\n );\n }\n return sql;\n}\n\nfunction quoteString(value: string, postgres = false): string {\n if (postgres)\n return `(E'${value.replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"''\")}' COLLATE \"C\")`;\n return `'${value.replace(/'/g, \"''\")}'`;\n}\n\nfunction typedDate(value: Record<string, unknown>, state: RenderState): string {\n const { kind, iso } = value;\n if (\n (kind !== 'date' && kind !== 'datetime') ||\n typeof iso !== 'string' ||\n Object.keys(value).some((key) => key !== 'kind' && key !== 'iso')\n ) {\n fail('INVALID_EXPRESSION', 'Expected typed date {kind, iso}');\n }\n // Date.parse normalizes invalid days, so validate the calendar separately.\n const match = /^(\\d{4})-(\\d{2})-(\\d{2})/.exec(iso);\n if (!match || Number(match[1]) < 1)\n fail('INVALID_EXPRESSION', 'Invalid ISO calendar date');\n const year = Number(match[1]);\n const month = Number(match[2]);\n const day = Number(match[3]);\n const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);\n const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n if (month < 1 || month > 12 || day < 1 || day > days[month - 1]) {\n fail('INVALID_EXPRESSION', 'Invalid ISO calendar date');\n }\n let canonical = iso;\n if (kind === 'date') {\n if (!/^\\d{4}-\\d{2}-\\d{2}$/.test(iso))\n fail('INVALID_EXPRESSION', 'Date requires YYYY-MM-DD');\n } else {\n if (\n !/^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d{1,3})?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$/.test(\n iso,\n )\n ) {\n fail(\n 'INVALID_EXPRESSION',\n 'Datetime requires ISO seconds and an explicit UTC offset',\n );\n }\n const date = new Date(iso);\n if (!Number.isFinite(date.getTime()))\n fail('INVALID_EXPRESSION', 'Invalid ISO datetime');\n canonical = date.toISOString();\n if (!/^\\d{4}-/.test(canonical) || canonical.startsWith('0000'))\n fail('INVALID_EXPRESSION', 'Datetime outside years 0001..9999');\n }\n const { ctx } = state;\n let sql: string;\n if (ctx.mode === 'ddl')\n sql = quoteString(canonical, ctx.adapterType === 'postgres');\n else {\n sql = `$${ctx.nextIndex++}`;\n ctx.values.push(canonical);\n }\n if (\n ctx.adapterType === 'postgres' ||\n ctx.adapterType === 'duckdb' ||\n ctx.adapterType === 'json'\n ) {\n // A timestamp WITHOUT time zone contains canonical UTC wall-clock fields.\n // Never cast via timestamptz (whose date extraction depends on TimeZone).\n if (kind === 'datetime') {\n const utc = canonical.slice(0, -1).replace('T', ' ');\n if (ctx.mode === 'ddl')\n sql = quoteString(utc, ctx.adapterType === 'postgres');\n else ctx.values[ctx.values.length - 1] = utc;\n }\n return `CAST(${sql} AS ${kind === 'date' ? 'DATE' : 'TIMESTAMP'})`;\n }\n return sql;\n}\n\nfunction resultType(\n node: unknown,\n ctx: ExpressionContext,\n depth = 0,\n budget = { nodes: 0 },\n): ExpressionResultType {\n if (depth > MAX_DEPTH || ++budget.nodes > MAX_NODES)\n fail(\n 'EXPRESSION_LIMIT',\n 'Expression type analysis exceeds depth/node limit',\n );\n if (!isRecord(node)) return 'unknown';\n if ('col' in node) return ctx.columnType?.(node.col as string) ?? 'unknown';\n if (!('op' in node) && 'value' in node) {\n const value = node.value;\n if (value === null) return 'null';\n if (value instanceof Date) return 'unknown';\n if (isRecord(value) && (value.kind === 'date' || value.kind === 'datetime'))\n return value.kind;\n if (typeof value === 'number') return 'number';\n if (typeof value === 'boolean') return 'boolean';\n if (typeof value === 'string') return 'text';\n }\n const op = node.op;\n if (\n typeof op === 'string' &&\n (Object.hasOwn(ARITHMETIC, op) || Object.hasOwn(COMPARISON, op))\n ) {\n return Object.hasOwn(ARITHMETIC, op) ? 'number' : 'boolean';\n }\n if (['and', 'or', 'not', 'isNull', 'isNotNull'].includes(op as string))\n return 'boolean';\n if (\n [\n 'round',\n 'abs',\n 'floor',\n 'ceil',\n 'least',\n 'greatest',\n 'mod',\n 'length',\n 'year',\n 'month',\n 'day',\n 'daysBetween',\n 'secondsBetween',\n ].includes(op as string)\n )\n return 'number';\n if (\n ['concat', 'lower', 'upper', 'trim', 'substring', 'asText'].includes(\n op as string,\n )\n )\n return 'text';\n if (op === 'addDays') return 'date';\n const merge = (nodes: unknown[]) => {\n const types = nodes\n .map((n) => resultType(n, ctx, depth + 1, budget))\n .filter((t) => t !== 'null');\n return !types.length\n ? 'null'\n : types.every((t) => t === types[0])\n ? types[0]\n : 'unknown';\n };\n if (op === 'if') return merge([node.then, node.else]);\n if (op === 'case' && Array.isArray(node.branches))\n return merge([\n ...node.branches.map((b) => (isRecord(b) ? b.then : undefined)),\n node.else,\n ]);\n if (op === 'coalesce' && Array.isArray(node.operands))\n return merge(node.operands);\n return 'unknown';\n}\n\nfunction requireTemporal(node: unknown, state: RenderState): void {\n const type = resultType(node, state.ctx);\n if (type !== 'date' && type !== 'datetime' && type !== 'null') {\n fail(\n 'NON_IMMUTABLE',\n 'Generated date operations require typed date/datetime operands (timezone-free UTC); unknown or timestamptz columns are unsafe',\n );\n }\n}\n\n/** Guard portable integer arguments; dynamic out-of-range inputs yield NULL. */\nfunction integerArg(\n node: unknown,\n sql: string,\n min: number,\n max: number,\n): string {\n if (\n isRecord(node) &&\n !('op' in node) &&\n 'value' in node &&\n node.value !== null\n ) {\n if (\n typeof node.value !== 'number' ||\n !Number.isInteger(node.value) ||\n node.value < min ||\n node.value > max\n ) {\n fail('INVALID_EXPRESSION', `Expected integer argument in ${min}..${max}`);\n }\n }\n return `CASE WHEN ${sql} BETWEEN ${min} AND ${max} THEN CASE WHEN ${sql} = CAST(${sql} AS INTEGER) THEN CAST(${sql} AS INTEGER) ELSE NULL END ELSE NULL END`;\n}\n\nfunction renderPortable(\n node: Record<string, unknown>,\n state: RenderState,\n child: (node: unknown) => string,\n): string | undefined {\n const { op } = node;\n const pg = state.ctx.adapterType === 'postgres';\n const duck =\n state.ctx.adapterType === 'duckdb' || state.ctx.adapterType === 'json';\n const numeric = (sql: string) =>\n pg\n ? `CAST(${sql} AS DOUBLE PRECISION)`\n : duck\n ? `CAST(${sql} AS DOUBLE)`\n : sql;\n const strict = (args: string[], body: string) =>\n `(CASE WHEN ${args.map((a) => `${a} IS NULL`).join(' OR ')} THEN NULL ELSE ${body} END)`;\n if (op === 'case' || op === 'if') {\n const branches =\n op === 'if' ? [{ when: node.condition, then: node.then }] : node.branches;\n if (!Array.isArray(branches) || branches.length === 0)\n fail('INVALID_EXPRESSION', 'case requires at least one when/then branch');\n const sql = branches.map((b) => {\n if (!isRecord(b))\n fail('INVALID_EXPRESSION', 'case branch requires when/then');\n return `WHEN ${child(b.when)} THEN ${child(b.then)}`;\n });\n const expression = `(CASE ${sql.join(' ')} ELSE ${child(node.else)} END)`;\n return resultType(node, state.ctx) === 'number'\n ? numeric(expression)\n : expression;\n }\n if (op === 'least' || op === 'greatest' || op === 'concat') {\n if (\n !Array.isArray(node.operands) ||\n node.operands.length < (op === 'concat' ? 1 : 2)\n )\n fail(\n 'INVALID_EXPRESSION',\n `${op} requires at least ${op === 'concat' ? 1 : 2} operands`,\n );\n const args = node.operands.map(child);\n if (op === 'concat') return `(${args.join(' || ')})`;\n const fn =\n !pg && !duck ? (op === 'least' ? 'MIN' : 'MAX') : op.toUpperCase();\n return numeric(strict(args, `${fn}(${args.join(', ')})`));\n }\n if (op === 'mod') {\n const left = child(node.left),\n right = child(node.right);\n // Native % is integer-only on SQLite; use truncation toward zero for a\n // fractional remainder with the dividend's sign on every backend.\n const quotient = `((${left} * 1.0) / NULLIF(${right}, 0))`;\n const ceil =\n !pg && !duck ? sqliteIntegral(quotient, 'ceil') : `CEIL(${quotient})`;\n const floor =\n !pg && !duck ? sqliteIntegral(quotient, 'floor') : `FLOOR(${quotient})`;\n return numeric(\n `(${left} - (CASE WHEN ${quotient} < 0 THEN ${ceil} ELSE ${floor} END) * ${right})`,\n );\n }\n if (op === 'round') {\n const value = child(node.value),\n digitsSql = child(node.digits);\n const digits = integerArg(node.digits, digitsSql, -12, 12);\n if (pg)\n return `CAST(ROUND(CAST(${value} AS NUMERIC), (${digits})) AS DOUBLE PRECISION)`;\n if (duck) return `ROUND(CAST(${value} AS DOUBLE), (${digits}))`;\n // SQLite ignores negative digits; implement those by scaling first.\n const factor = `(CASE (${digits}) ${Array.from({ length: 12 }, (_, i) => `WHEN -${i + 1} THEN ${10 ** (i + 1)}`).join(' ')} ELSE NULL END)`;\n return `(CASE WHEN (${digits}) < 0 THEN ROUND((${value} * 1.0) / ${factor}, 0) * ${factor} ELSE ROUND(${value}, (${digits})) END)`;\n }\n if (op === 'substring') {\n const value = child(node.value),\n start = child(node.start),\n length = child(node.length);\n return `SUBSTR(${value}, (${integerArg(node.start, start, 1, 2147483647)}), (${integerArg(node.length, length, 0, 2147483647)}))`;\n }\n if (op === 'daysBetween') {\n if (state.ctx.mode === 'ddl') {\n requireTemporal(node.later, state);\n requireTemporal(node.earlier, state);\n }\n const later = child(node.later),\n earlier = child(node.earlier);\n if (pg || duck)\n return `CAST((CAST(${later} AS DATE) - CAST(${earlier} AS DATE)) AS ${pg ? 'DOUBLE PRECISION' : 'DOUBLE'})`;\n return `(julianday(DATE(${later})) - julianday(DATE(${earlier})))`;\n }\n if (op === 'addDays') {\n if (state.ctx.mode === 'ddl') requireTemporal(node.value, state);\n const value = child(node.value),\n daysSql = child(node.days);\n const days = integerArg(node.days, daysSql, -365000, 365000);\n const added =\n pg || duck\n ? `(CAST(${value} AS DATE) + (${days}))`\n : `DATE(${value}, CAST((${days}) AS TEXT) || ' days')`;\n // Bound native dates before parents can extract parts or boundary output\n // can format a year wider than four digits. SQLite also accepts year 0000.\n const bound = (iso: string) =>\n pg || duck ? `CAST('${iso}' AS DATE)` : `'${iso}'`;\n return `(CASE WHEN ${added} BETWEEN ${bound('0001-01-01')} AND ${bound('9999-12-31')} THEN ${added} ELSE NULL END)`;\n }\n if (op === 'year' || op === 'month' || op === 'day') {\n if (state.ctx.mode === 'ddl') requireTemporal(node.value, state);\n const value = child(node.value);\n if (pg || duck)\n return `CAST(EXTRACT(${op.toUpperCase()} FROM CAST(${value} AS TIMESTAMP)) AS INTEGER)`;\n return `CAST(STRFTIME('${op === 'year' ? '%Y' : op === 'month' ? '%m' : '%d'}', ${value}) AS INTEGER)`;\n }\n if (op === 'lower' || op === 'upper') {\n // SQLite case conversion is ASCII-only. Use that exact contract on every\n // backend rather than expose collation/Unicode-version-dependent results.\n let value = child(node.value);\n if (pg)\n return `TRANSLATE(${value}, '${op === 'lower' ? 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' : 'abcdefghijklmnopqrstuvwxyz'}', '${op === 'lower' ? 'abcdefghijklmnopqrstuvwxyz' : 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'}')`;\n for (let i = 0; i < 26; i++) {\n const upper = String.fromCharCode(65 + i),\n lower = String.fromCharCode(97 + i);\n value = `REPLACE(${value}${pg ? ' COLLATE \"C\"' : ''}, ${quoteString(op === 'lower' ? upper : lower, pg)}, ${quoteString(op === 'lower' ? lower : upper, pg)})`;\n }\n return value;\n }\n if ((op === 'floor' || op === 'ceil') && !pg && !duck)\n return sqliteIntegral(child(node.value), op);\n if (\n op === 'abs' ||\n op === 'floor' ||\n op === 'ceil' ||\n op === 'trim' ||\n op === 'length'\n )\n return ['abs', 'floor', 'ceil'].includes(op)\n ? numeric(`${op.toUpperCase()}(${child(node.value)})`)\n : `${op.toUpperCase()}(${child(node.value)})`;\n return undefined;\n}\n\nexport interface RenderExpressionOptions {\n dialect: 'sqlite' | 'postgres' | 'duckdb' | 'json';\n mode: 'ddl' | 'query';\n /** Maps a logical column to an identifier, never to SQL. Dots delimit parts. */\n resolveColumn?: (\n column: string,\n ) => string | { name: string; type: ExpressionResultType };\n}\nexport interface RenderExpressionResult {\n sql: string;\n values: unknown[];\n resultType: ExpressionResultType;\n immutable: Record<'sqlite' | 'postgres' | 'duckdb', boolean>;\n}\n\n/** Render a closed scalar expression. DDL additionally requires immutability. */\nexport function renderExpression(\n node: AggregateOperand,\n options: RenderExpressionOptions,\n): RenderExpressionResult {\n if (\n !['sqlite', 'postgres', 'duckdb', 'json'].includes(options.dialect) ||\n !['ddl', 'query'].includes(options.mode)\n )\n fail('INVALID_EXPRESSION', 'Invalid expression dialect or mode');\n const columns = new Map<\n string,\n { name: string; type: ExpressionResultType }\n >();\n const resolve = (name: string) => {\n if (typeof name !== 'string' || !name.length || name.includes('\\0'))\n fail('INVALID_EXPRESSION', 'Invalid expression column');\n let column = columns.get(name);\n if (!column) {\n const found = options.resolveColumn?.(name) ?? name;\n column =\n typeof found === 'string' ? { name: found, type: 'unknown' } : found;\n if (\n !column ||\n typeof column.name !== 'string' ||\n !column.name.length ||\n column.name.includes('\\0') ||\n column.name.split('.').some((p) => !p)\n )\n fail('INVALID_EXPRESSION', 'Invalid resolved column identifier');\n columns.set(name, column);\n }\n return column;\n };\n const ctx: ExpressionContext = {\n adapterType: options.dialect,\n nextIndex: 1,\n values: [],\n mode: options.mode,\n identifier: (name) =>\n resolve(name).name.split('.').map(quoteLiteralIdentifier).join('.'),\n columnType: (name) => resolve(name).type,\n };\n const sql = renderAggregateExpression(node, ctx);\n // Validate DDL in each dialect as well: metadata describes portability,\n // independent of the dialect selected for this query.\n const immutable = { sqlite: true, postgres: true, duckdb: true };\n for (const dialect of ['sqlite', 'postgres', 'duckdb'] as const) {\n try {\n renderAggregateExpression(node, {\n ...ctx,\n adapterType: dialect,\n mode: 'ddl',\n nextIndex: 1,\n values: [],\n nodeCount: 0,\n sqlWork: 0,\n });\n } catch (error) {\n if (error instanceof ExpressionError && error.code === 'NON_IMMUTABLE')\n immutable[dialect] = false;\n else throw error;\n }\n }\n if (options.mode === 'ddl' && !Object.values(immutable).every(Boolean))\n fail(\n 'NON_IMMUTABLE',\n 'Expression must be immutable on every dialect for generated use',\n );\n return {\n sql,\n values: ctx.values,\n resultType: resultType(node, ctx),\n immutable,\n };\n}\n\n// libsql registers math extensions without SQLITE_DETERMINISTIC. Express these\n// using core arithmetic so generated columns/indexes work on that adapter too.\nfunction sqliteIntegral(value: string, op: 'floor' | 'ceil'): string {\n const trunc = `CAST(${value} AS INTEGER)`;\n return `(CASE WHEN ${value} >= 4503599627370496 OR ${value} <= -4503599627370496 THEN ${value} WHEN ${trunc} ${op === 'floor' ? '>' : '<'} ${value} THEN ${trunc} ${op === 'floor' ? '-' : '+'} 1 ELSE ${trunc} END)`;\n}\nfunction postgresDateISO(value: string): string {\n const part = (unit: string, width: number) =>\n `LPAD(CAST(CAST(EXTRACT(${unit} FROM ${value}) AS INTEGER) AS TEXT), ${width}, '0')`;\n return `(${part('YEAR', 4)} || '-' || ${part('MONTH', 2)} || '-' || ${part('DAY', 2)})`;\n}\n\nconst PORTABLE_FIELDS: Record<string, string[]> = {\n case: ['branches', 'else'],\n if: ['condition', 'then', 'else'],\n round: ['value', 'digits'],\n abs: ['value'],\n floor: ['value'],\n ceil: ['value'],\n lower: ['value'],\n upper: ['value'],\n trim: ['value'],\n length: ['value'],\n year: ['value'],\n month: ['value'],\n day: ['value'],\n least: ['operands'],\n greatest: ['operands'],\n concat: ['operands'],\n mod: ['left', 'right'],\n substring: ['value', 'start', 'length'],\n daysBetween: ['later', 'earlier'],\n addDays: ['value', 'days'],\n};\nfunction validateShape(node: Record<string, unknown>): void {\n let fields: string[];\n if (!('op' in node)) fields = 'col' in node ? ['col'] : ['value'];\n else {\n const op = node.op;\n if (typeof op !== 'string')\n fail('INVALID_EXPRESSION', 'Expression requires an operator');\n if (Object.hasOwn(PORTABLE_FIELDS, op))\n fields = ['op', ...PORTABLE_FIELDS[op]];\n else if (Object.hasOwn(ARITHMETIC, op) || Object.hasOwn(COMPARISON, op))\n fields = ['op', 'left', 'right'];\n else if (op === 'secondsBetween') fields = ['op', 'later', 'earlier'];\n else if (['and', 'or', 'coalesce'].includes(op))\n fields = ['op', 'operands'];\n else if (['not', 'isNull', 'isNotNull', 'asText'].includes(op))\n fields = ['op', 'operand'];\n else\n fail(\n 'INVALID_EXPRESSION',\n `Unsupported aggregate expression operator: ${op}`,\n );\n }\n if (\n fields.some((key) => !Object.hasOwn(node, key)) ||\n Object.keys(node).some((key) => !fields.includes(key))\n )\n fail('INVALID_EXPRESSION', 'Expression has missing or unknown fields');\n if (node.op === 'case' && Array.isArray(node.branches)) {\n for (const b of node.branches)\n if (\n !isRecord(b) ||\n Object.keys(b).length !== 2 ||\n !Object.hasOwn(b, 'when') ||\n !Object.hasOwn(b, 'then')\n )\n fail('INVALID_EXPRESSION', 'case branch requires only when/then');\n }\n}\n\nfunction temporalSeconds(\n node: unknown,\n sql: string,\n ctx: ExpressionContext,\n): string {\n if (\n (ctx.adapterType === 'postgres' ||\n ctx.adapterType === 'duckdb' ||\n ctx.adapterType === 'json') &&\n resultType(node, ctx) === 'date'\n )\n return `CAST(${sql} AS TIMESTAMP)`;\n return sql;\n}\n","import {\n type AggregateJoin,\n type AggregateOperand,\n type ExpressionContext,\n renderAggregateExpression,\n} from './aggregate-expression.js';\nimport {\n type IdentifierOptions,\n identifierParts,\n isLegacyNumericSqlToken,\n quoteLiteralIdentifier,\n renderIdentifier,\n} from './shared/alter-utils.js';\nimport type { WhereClause } from './shared/types.js';\nimport {\n buildWhere,\n parseConditionKey,\n raw,\n type SqlAdapterType,\n unwrapRawKey,\n} from './shared/utils.js';\n\nexport type AggregateTimeBucketUnit =\n | 'minute'\n | 'hour'\n | 'day'\n | 'week'\n | 'month'\n | 'quarter'\n | 'year';\n\nexport type AggregateFunction =\n | 'count'\n | 'sum'\n | 'avg'\n | 'min'\n | 'max'\n | (string & {});\n\nexport type AggregateSelectExpr =\n | { column: string; as?: string }\n /** A row expression used as a grouping key (a computed column of each row). */\n | { expr: AggregateOperand; as: string }\n | {\n fn: AggregateFunction;\n column?: string;\n /** A row expression to aggregate in place of `column` (not both). */\n expr?: AggregateOperand;\n /**\n * Aggregate only the rows this predicate holds for (a filtered count or\n * sum). Rows where it is false or NULL are skipped. With `count` and no\n * column or expression it counts the matching rows.\n */\n filter?: AggregateOperand;\n as: string;\n distinct?: boolean;\n }\n | {\n bucket: AggregateTimeBucketUnit;\n column: string;\n as: string;\n };\n\nexport interface AggregateSpec {\n from: string;\n /** Alias for `from`, so its columns can be qualified (`o.total`) beside joined tables. */\n fromAlias?: string;\n /**\n * Tables joined to `from`, in order. With joins, a column naming a table must\n * be qualified by `from`, `fromAlias` or a join alias.\n */\n joins?: AggregateJoin[];\n select: AggregateSelectExpr[];\n where?: WhereClause;\n /** A row predicate built from expression nodes, ANDed with `where`. */\n whereExpr?: AggregateOperand;\n groupBy?: string[];\n having?: WhereClause;\n orderBy?: string | string[];\n limit?: number;\n offset?: number;\n}\n\nexport interface AggregateBuildResult {\n sql: string;\n values: any[];\n}\n\nconst EXPRESSION_AGGREGATES = new Set(['count', 'sum', 'avg', 'min', 'max']);\nconst VALID_DIRECTIONS = new Set(['ASC', 'DESC']);\nconst VALID_BUCKET_UNITS = new Set<AggregateTimeBucketUnit>([\n 'minute',\n 'hour',\n 'day',\n 'week',\n 'month',\n 'quarter',\n 'year',\n]);\n\nfunction aggregateIdentifierParts(identifier: string) {\n if (isLegacyNumericSqlToken(identifier)) {\n return identifier.split('.').map((name) => ({ name, exact: false }));\n }\n return identifierParts(identifier);\n}\n\nfunction validateSqlIdentifier(identifier: string): string {\n aggregateIdentifierParts(identifier);\n return identifier;\n}\n\nfunction renderAggregateIdentifier(\n identifier: string,\n adapterType: SqlAdapterType | undefined,\n options: IdentifierOptions,\n): string {\n return isLegacyNumericSqlToken(identifier)\n ? identifier\n : renderIdentifier(identifier, adapterType, options);\n}\n\nfunction normalizeAdapter(adapterType?: SqlAdapterType): SqlAdapterType {\n return adapterType ?? 'sqlite';\n}\n\nfunction placeholder(index: number): string {\n return `$${index}`;\n}\n\nexport function bucketExpr(\n adapterType: SqlAdapterType | undefined,\n unit: AggregateTimeBucketUnit,\n column: string,\n options: IdentifierOptions = {},\n): string {\n if (!VALID_BUCKET_UNITS.has(unit)) {\n throw new Error(`Invalid aggregate bucket unit: ${unit}`);\n }\n\n const col = renderAggregateIdentifier(column, adapterType, options);\n const adapter = normalizeAdapter(adapterType);\n\n if (adapter === 'postgres' || adapter === 'duckdb' || adapter === 'json') {\n return `date_trunc('${unit}', ${col})`;\n }\n\n switch (unit) {\n case 'minute':\n return `strftime('%Y-%m-%d %H:%M:00', ${col})`;\n case 'hour':\n return `strftime('%Y-%m-%d %H:00:00', ${col})`;\n case 'day':\n return `strftime('%Y-%m-%d 00:00:00', ${col})`;\n case 'week':\n return `strftime('%Y-%m-%d 00:00:00', date(${col}, printf('-%d days', (CAST(strftime('%w', ${col}) AS INTEGER) + 6) % 7)))`;\n case 'month':\n return `strftime('%Y-%m-01 00:00:00', ${col})`;\n case 'quarter':\n return `strftime('%Y-%m-%d 00:00:00', date(strftime('%Y-', ${col}) || printf('%02d', ((CAST(strftime('%m', ${col}) AS INTEGER) - 1) / 3) * 3 + 1) || '-01'))`;\n case 'year':\n return `strftime('%Y-01-01 00:00:00', ${col})`;\n }\n}\n\n/** What a select expression, join and predicate share while one query is built. */\ninterface BuildState {\n ctx: ExpressionContext;\n /** Names never use the numeric-literal compatibility channel for operands. */\n renderName: (name: string) => string;\n /** Table names and aliases a qualified column may name; undefined without joins. */\n scope: Set<string> | undefined;\n options: IdentifierOptions;\n}\n\nfunction checkColumn(state: BuildState, column: string): string {\n const { scope } = state;\n const parts = aggregateIdentifierParts(column);\n if (scope && parts.length > 1) {\n if (parts.length !== 2 || !scope.has(parts[0].name)) {\n throw new Error(\n `Aggregate column ${column} must be qualified by the from table or a join alias`,\n );\n }\n }\n return column;\n}\n\nfunction validateColumn(state: BuildState, column: string): string {\n checkColumn(state, validateSqlIdentifier(column));\n return state.ctx.identifier(column);\n}\n\nfunction renderExpression(state: BuildState, node: AggregateOperand): string {\n return renderAggregateExpression(node, state.ctx);\n}\n\nfunction aggregateExpression(\n expr: Extract<AggregateSelectExpr, { fn: AggregateFunction }>,\n state: BuildState,\n): string {\n const normalizedFn = String(expr.fn).toLowerCase();\n const functionName = String(expr.fn);\n if (!/^[a-zA-Z0-9_.]+$/.test(functionName))\n throw new Error(`Invalid SQL identifier: ${functionName}`);\n const fn = functionName.toUpperCase();\n if (expr.column !== undefined && expr.expr !== undefined) {\n throw new Error(`Aggregate ${expr.fn} takes a column or an expr, not both`);\n }\n // `fn` is free-form for plain columns (existing behaviour), but an expression\n // or filter can feed it bound values, so it must be a real aggregate there.\n if (\n (expr.expr !== undefined || expr.filter !== undefined) &&\n !EXPRESSION_AGGREGATES.has(normalizedFn)\n ) {\n throw new Error(\n `Aggregate ${expr.fn} cannot take an expr or filter; use count, sum, avg, min or max`,\n );\n }\n const hasArgument = Boolean(expr.column) || expr.expr !== undefined;\n // Rendered first so a filter's parameters are numbered before the argument's.\n const filter =\n expr.filter !== undefined\n ? renderExpression(state, expr.filter)\n : undefined;\n\n if (normalizedFn === 'count' && !hasArgument) {\n if (expr.distinct) {\n throw new Error(`Aggregate ${expr.fn} with distinct requires a column`);\n }\n return filter ? `COUNT(CASE WHEN ${filter} THEN 1 END)` : 'COUNT(*)';\n }\n if (!hasArgument) {\n throw new Error(`Aggregate ${expr.fn} requires a column`);\n }\n const argument =\n expr.expr !== undefined\n ? renderExpression(state, expr.expr)\n : validateColumn(state, expr.column as string);\n const distinct = expr.distinct ? 'DISTINCT ' : '';\n // CASE WHEN rather than FILTER (WHERE ...): it means the same on every\n // dialect and every SQLite version.\n const inner = filter ? `CASE WHEN ${filter} THEN ${argument} END` : argument;\n return `${fn}(${distinct}${inner})`;\n}\n\nfunction selectExpression(\n expr: AggregateSelectExpr,\n adapterType: SqlAdapterType | undefined,\n state: BuildState,\n): {\n expression: string;\n alias: string;\n groupingCandidate: boolean;\n computed: boolean;\n} {\n if (\n ['fn' in expr, 'expr' in expr && !('fn' in expr), 'bucket' in expr].filter(\n Boolean,\n ).length > 1\n ) {\n throw new Error('Aggregate select item mixes fn, bucket and expr');\n }\n if ('fn' in expr) {\n const expression = aggregateExpression(expr, state);\n const alias = validateSqlIdentifier(expr.as);\n return { expression, alias, groupingCandidate: false, computed: false };\n }\n if ('expr' in expr) {\n const expression = renderExpression(state, expr.expr);\n const alias = validateSqlIdentifier(expr.as);\n return { expression, alias, groupingCandidate: true, computed: true };\n }\n if ('column' in expr && !('bucket' in expr)) {\n const column = validateColumn(state, expr.column);\n // A qualified column (`wo.title`) is named by its column part, not the dotted path.\n const alias = validateSqlIdentifier(\n expr.as ??\n (() => {\n const part = aggregateIdentifierParts(expr.column).at(-1);\n if (!part) throw new Error(`Invalid SQL identifier: ${expr.column}`);\n return part.exact ? quoteLiteralIdentifier(part.name) : part.name;\n })(),\n );\n return {\n expression: column,\n alias,\n groupingCandidate: true,\n computed: false,\n };\n }\n const column = (expr as { column: string }).column;\n validateColumn(state, column);\n const bucket = (expr as { bucket: AggregateTimeBucketUnit }).bucket;\n const expression = bucketExpr(adapterType, bucket, column, state.options);\n const alias = validateSqlIdentifier((expr as { as: string }).as);\n return { expression, alias, groupingCandidate: true, computed: false };\n}\n\nfunction expandHavingKey(\n key: string,\n expressionByAlias: Map<string, string>,\n identifier: (name: string) => string,\n): string {\n // A key the caller already wrapped in raw() is used verbatim: raw() means\n // \"this exact SQL\", so it deliberately bypasses select-alias expansion.\n if (unwrapRawKey(key).isRaw) return key;\n\n const parsed = parseConditionKey(key);\n const expression =\n expressionByAlias.get(parsed.field) ?? identifier(parsed.field);\n\n // The caller's key is validated above (as an alias or a plain identifier);\n // what comes out is a select expression such as `SUM(total) >`, which only\n // buildWhere's raw channel accepts.\n return raw(`${expression} ${parsed.operator}`);\n}\n\nfunction expandHaving(\n having: WhereClause,\n expressionByAlias: Map<string, string>,\n identifier: (name: string) => string,\n): WhereClause {\n const expandCondition = (condition: Record<string, any>) =>\n Object.fromEntries(\n Object.entries(condition).map(([key, value]) => [\n expandHavingKey(key, expressionByAlias, identifier),\n value,\n ]),\n );\n if (Array.isArray(having)) {\n return having.map((andGroup: Record<string, any>[]) =>\n andGroup.map((condition: Record<string, any>) =>\n expandCondition(condition),\n ),\n );\n }\n\n return expandCondition(having);\n}\n\nfunction buildHaving(\n having: AggregateSpec['having'],\n expressionByAlias: Map<string, string>,\n startIndex: number,\n adapterType: SqlAdapterType | undefined,\n identifier: (name: string) => string,\n): AggregateBuildResult {\n if (!having) return { sql: '', values: [] };\n const expanded = expandHaving(having, expressionByAlias, identifier);\n const built = buildWhere(expanded, startIndex, adapterType);\n\n return {\n sql: built.sql ? built.sql.replace(/^WHERE/, 'HAVING') : '',\n values: built.values,\n };\n}\n\nfunction buildOrderBy(\n orderBy: string | string[] | undefined,\n state: BuildState,\n aliases: ReadonlySet<string>,\n): string {\n if (!orderBy) return '';\n const items = Array.isArray(orderBy) ? orderBy : [orderBy];\n const parts = items.map((item) => {\n // A quoted component may contain spaces; the optional second token is the\n // direction. As before this builder ignores any tokens after that direction.\n const match = /^((?:[^\\s\"]|\"(?:[^\"]|\"\")*\")+)(?:\\s+(\\S+))?/.exec(\n item.trim(),\n );\n const field = match?.[1] ?? item.trim();\n const direction = match?.[2] ?? 'ASC';\n const normalizedDirection = direction.toUpperCase();\n if (!VALID_DIRECTIONS.has(normalizedDirection)) {\n throw new Error(`Invalid aggregate order direction: ${direction}`);\n }\n const orderExpr = aliases.has(field)\n ? state.renderName(field)\n : validateColumn(state, field);\n return `${orderExpr} ${normalizedDirection}`;\n });\n return `ORDER BY ${parts.join(', ')}`;\n}\n\nconst VALID_JOIN_TYPES = new Set(['inner', 'left']);\nconst JOIN_ALIAS = /^[A-Za-z_][A-Za-z0-9_]*$/;\n\nfunction buildScope(\n fromAlias: string | undefined,\n joins: AggregateJoin[],\n from: string,\n): Set<string> | undefined {\n if (joins.length === 0 && fromAlias === undefined) return undefined;\n const scope = new Set<string>();\n const claim = (name: string, what: string) => {\n // A non-string could pass the pattern once and render differently later.\n if (typeof name !== 'string' || !JOIN_ALIAS.test(name)) {\n throw new Error(`Invalid aggregate ${what}: ${name}`);\n }\n if (scope.has(name)) {\n throw new Error(`Duplicate aggregate table name or alias: ${name}`);\n }\n scope.add(name);\n };\n if (fromAlias !== undefined) {\n claim(fromAlias, 'from alias');\n } else {\n if (from.includes('.')) {\n throw new Error(\n 'AggregateSpec.fromAlias is required when joining a schema-qualified from table',\n );\n }\n claim(from, 'from table');\n }\n for (const join of joins) {\n claim(join.alias, 'join alias');\n }\n return scope;\n}\n\nfunction joinSql(state: BuildState, joins: AggregateJoin[]): string[] {\n return joins.map((join) => {\n const type = join.type ?? 'inner';\n if (!VALID_JOIN_TYPES.has(type)) {\n throw new Error(`Invalid aggregate join type: ${type}`);\n }\n if (join.on === undefined) {\n throw new Error(`Aggregate join ${join.alias} requires an on condition`);\n }\n const table = state.renderName(join.table);\n const alias = join.alias;\n if (typeof alias !== 'string' || !JOIN_ALIAS.test(alias)) {\n throw new Error(`Invalid aggregate join alias: ${String(alias)}`);\n }\n const on = renderExpression(state, join.on);\n return `${type === 'left' ? 'LEFT' : 'INNER'} JOIN ${table} AS ${state.renderName(alias)} ON ${on}`;\n });\n}\n\nexport function buildAggregate(\n spec: AggregateSpec,\n startIndex = 1,\n adapterType?: SqlAdapterType,\n options: IdentifierOptions = {},\n): AggregateBuildResult {\n const from = validateSqlIdentifier(spec.from);\n if (spec.select.length === 0) {\n throw new Error(\n 'AggregateSpec.select must contain at least one expression',\n );\n }\n if (spec.joins !== undefined && !Array.isArray(spec.joins)) {\n throw new Error('AggregateSpec.joins must be an array');\n }\n\n // Every bound value is numbered in the order it is built (select, joins,\n // where, whereExpr, having, paging) and listed in that order in `values`.\n const values: any[] = [];\n const ctx: ExpressionContext = {\n adapterType,\n nextIndex: startIndex,\n values,\n identifier: (name) => renderAggregateIdentifier(name, adapterType, options),\n };\n // Read once: the validated string is the one rendered.\n const fromAlias = spec.fromAlias;\n const joins: AggregateJoin[] = (spec.joins ?? []).map((join) => ({\n table: join.table,\n alias: join.alias,\n type: join.type,\n on: join.on,\n }));\n const state: BuildState = {\n ctx,\n renderName: (name) => renderIdentifier(name, adapterType, options),\n scope: buildScope(fromAlias, joins, from),\n options,\n };\n ctx.onColumn = (column) => {\n checkColumn(state, column);\n };\n\n const expressionByAlias = new Map<string, string>();\n const ordinalByAlias = new Map<string, number>();\n const groupingAliases: string[] = [];\n const selectSql = spec.select.map((expr, position) => {\n const selected = selectExpression(expr, adapterType, state);\n if (expressionByAlias.has(selected.alias)) {\n throw new Error(`Duplicate aggregate select alias: ${selected.alias}`);\n }\n expressionByAlias.set(selected.alias, selected.expression);\n // A computed key is grouped by its position in the select list, so a bound\n // parameter in it is not repeated in the GROUP BY.\n if (selected.computed) ordinalByAlias.set(selected.alias, position + 1);\n if (selected.groupingCandidate) {\n groupingAliases.push(selected.alias);\n }\n return `${selected.expression} AS ${state.renderName(selected.alias)}`;\n });\n\n const joinParts = joinSql(state, joins);\n\n const where = spec.where\n ? buildWhere(spec.where, ctx.nextIndex, adapterType, options)\n : { sql: '', values: [] };\n values.push(...where.values);\n ctx.nextIndex += where.values.length;\n\n let whereSql = where.sql;\n if (spec.whereExpr !== undefined) {\n const predicate = renderExpression(state, spec.whereExpr);\n // `where` may hold OR groups; parenthesise it so whereExpr constrains all of them.\n whereSql = whereSql\n ? `WHERE (${whereSql.replace(/^WHERE /, '')}) AND ${predicate}`\n : `WHERE ${predicate}`;\n }\n\n const groupByItems = spec.groupBy ?? groupingAliases;\n const groupBySql =\n groupByItems.length > 0\n ? `GROUP BY ${groupByItems\n .map((item) =>\n ordinalByAlias.has(item)\n ? String(ordinalByAlias.get(item))\n : expressionByAlias.has(item)\n ? expressionByAlias.get(item)\n : validateColumn(state, item),\n )\n .join(', ')}`\n : '';\n\n const having = buildHaving(\n spec.having,\n expressionByAlias,\n ctx.nextIndex,\n adapterType,\n ctx.identifier,\n );\n values.push(...having.values);\n ctx.nextIndex += having.values.length;\n\n const orderBySql = buildOrderBy(\n spec.orderBy,\n state,\n new Set(expressionByAlias.keys()),\n );\n\n const pagingSql: string[] = [];\n if (spec.limit !== undefined) {\n pagingSql.push(`LIMIT ${placeholder(ctx.nextIndex++)}`);\n values.push(spec.limit);\n } else if (\n spec.offset !== undefined &&\n normalizeAdapter(adapterType) === 'sqlite'\n ) {\n pagingSql.push('LIMIT -1');\n }\n if (spec.offset !== undefined) {\n pagingSql.push(`OFFSET ${placeholder(ctx.nextIndex++)}`);\n values.push(spec.offset);\n }\n\n const fromSql =\n spec.fromAlias !== undefined\n ? `${state.renderName(from)} AS ${state.renderName(fromAlias as string)}`\n : state.renderName(from);\n const sql = [\n `SELECT ${selectSql.join(', ')}`,\n `FROM ${fromSql}`,\n ...joinParts,\n whereSql,\n groupBySql,\n having.sql,\n orderBySql,\n pagingSql.join(' '),\n ]\n .filter(Boolean)\n .join(' ');\n\n return { sql, values };\n}\n","import { quoteLiteralIdentifier } from './alter-utils.js';\n\n/**\n * DuckDB-specific schema transformation utilities\n *\n * DuckDB has a known limitation (issue #12684) where ON CONFLICT clauses\n * fail with UNIQUE INDEX but work with inline UNIQUE constraints.\n *\n * This module provides utilities to transform SMRT-generated schemas\n * (which use separate CREATE UNIQUE INDEX statements) into DuckDB-compatible\n * schemas (which use inline UNIQUE constraints).\n */\n\n/**\n * Index definition extracted from CREATE INDEX statement\n */\ninterface ParsedIndex {\n name: string;\n columns: string[];\n unique: boolean;\n sql: string;\n}\n\n/**\n * Parses a CREATE INDEX statement to extract index details\n *\n * @param indexSQL - CREATE INDEX statement\n * @returns Parsed index definition or null if parsing fails\n *\n * @example\n * ```typescript\n * const index = parseIndexStatement(\n * 'CREATE UNIQUE INDEX ds_slug_context_idx ON ds (slug, context)'\n * );\n * // Returns: {\n * // name: 'ds_slug_context_idx',\n * // columns: ['slug', 'context'],\n * // unique: true,\n * // sql: '...'\n * // }\n * ```\n */\nexport function parseIndexStatement(indexSQL: string): ParsedIndex | null {\n const trimmed = indexSQL.trim();\n\n // Match: CREATE [UNIQUE] INDEX [IF NOT EXISTS] name ON table (columns)\n // Support both quoted and unquoted identifiers: table, \"table\", columns, \"columns\"\n const match = trimmed.match(\n /CREATE\\s+(UNIQUE\\s+)?INDEX\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(\\w+)\\s+ON\\s+(?:\"?\\w+\"?)\\s*\\(([^)]+)\\)/i,\n );\n\n if (!match) {\n return null;\n }\n\n const [, uniqueKeyword, name, columnsStr] = match;\n\n // Remove quotes from column names\n const columns = columnsStr\n .split(',')\n .map((col) => col.trim().replace(/^\"|\"$/g, ''));\n\n return {\n name,\n columns,\n unique: Boolean(uniqueKeyword),\n sql: trimmed,\n };\n}\n\n/**\n * Converts UNIQUE INDEX statements to inline UNIQUE constraints for DuckDB compatibility\n *\n * DuckDB's ON CONFLICT clause requires inline UNIQUE constraints, not separate indexes.\n * This function transforms SMRT-generated schemas to work with DuckDB's limitations.\n *\n * @param ddl - CREATE TABLE DDL statement\n * @param indexes - Array of CREATE INDEX statements (optional)\n * @returns Transformed DDL with inline UNIQUE constraints and filtered index list\n *\n * @example\n * ```typescript\n * const ddl = `\n * CREATE TABLE ds (\n * id TEXT PRIMARY KEY,\n * slug TEXT NOT NULL,\n * context TEXT NOT NULL\n * )\n * `;\n * const indexes = [\n * 'CREATE UNIQUE INDEX ds_slug_context_idx ON ds (slug, context)'\n * ];\n *\n * const result = convertUniqueIndexesToInlineConstraints(ddl, indexes);\n * // result.ddl:\n * // CREATE TABLE ds (\n * // id TEXT PRIMARY KEY,\n * // slug TEXT NOT NULL,\n * // context TEXT NOT NULL,\n * // UNIQUE(slug, context)\n * // )\n * // result.indexes: [] (UNIQUE index removed, non-UNIQUE indexes preserved)\n * ```\n */\nexport function convertUniqueIndexesToInlineConstraints(\n ddl: string,\n indexes?: string[],\n): {\n ddl: string;\n indexes: string[];\n} {\n if (!indexes || indexes.length === 0) {\n return { ddl, indexes: [] };\n }\n\n // Parse all indexes\n const parsedIndexes = indexes\n .map(parseIndexStatement)\n .filter((idx): idx is ParsedIndex => idx !== null);\n\n // Separate UNIQUE indexes from regular indexes\n const uniqueIndexes = parsedIndexes.filter((idx) => idx.unique);\n const regularIndexes = parsedIndexes.filter((idx) => !idx.unique);\n\n // If no UNIQUE indexes, return unchanged\n if (uniqueIndexes.length === 0) {\n return { ddl, indexes };\n }\n\n // Find the closing parenthesis of the CREATE TABLE statement\n const lines = ddl.split('\\n');\n let closingParenIndex = -1;\n\n for (let i = lines.length - 1; i >= 0; i--) {\n const trimmed = lines[i].trim();\n if (trimmed === ')' || trimmed.startsWith(');')) {\n closingParenIndex = i;\n break;\n }\n }\n\n if (closingParenIndex === -1) {\n // Can't find closing paren - return unchanged\n console.warn(\n '[duckdb-schema-utils] Could not find closing parenthesis in CREATE TABLE statement',\n );\n return { ddl, indexes };\n }\n\n // Build inline UNIQUE constraints with quoted column names\n const uniqueConstraints = uniqueIndexes.map((idx) => {\n const columns = idx.columns.map(quoteLiteralIdentifier).join(', ');\n return ` UNIQUE(${columns})`;\n });\n\n // Insert UNIQUE constraints before closing parenthesis\n const modifiedLines = [...lines];\n const closingLine = modifiedLines[closingParenIndex].trim();\n\n // Add comma to previous line if it doesn't have one\n if (closingParenIndex > 0) {\n const prevLine = modifiedLines[closingParenIndex - 1].trim();\n if (!prevLine.endsWith(',')) {\n modifiedLines[closingParenIndex - 1] = modifiedLines[\n closingParenIndex - 1\n ].replace(/\\s*$/, ',');\n }\n }\n\n // Insert UNIQUE constraints\n const constraintLines = uniqueConstraints.map((constraint, idx) => {\n // Add comma after all but the last constraint\n return idx < uniqueConstraints.length - 1 ? `${constraint},` : constraint;\n });\n\n modifiedLines.splice(closingParenIndex, 0, ...constraintLines);\n\n const transformedDDL = modifiedLines.join('\\n');\n\n // Return regular (non-UNIQUE) indexes only\n const remainingIndexes = regularIndexes.map((idx) => idx.sql);\n\n return {\n ddl: transformedDDL,\n indexes: remainingIndexes,\n };\n}\n\n/**\n * Checks if a schema definition contains UNIQUE indexes that need conversion\n *\n * @param indexes - Array of CREATE INDEX statements\n * @returns True if any UNIQUE indexes are present\n */\nexport function hasUniqueIndexes(indexes?: string[]): boolean {\n if (!indexes || indexes.length === 0) {\n return false;\n }\n\n return indexes.some((indexSQL) => {\n const parsed = parseIndexStatement(indexSQL);\n return parsed?.unique === true;\n });\n}\n","import { DatabaseError } from '@happyvertical/utils';\n\n/**\n * Error thrown when `transaction()` is called on a transaction-scoped interface\n * belonging to an adapter whose engine has no savepoints.\n *\n * DuckDB — and therefore the JSON adapter built on it — does not implement\n * `SAVEPOINT`, so there is no way to re-enter the current transaction. Adapters\n * that can re-enter (PostgreSQL, SQLite) do so under a savepoint and never\n * throw this.\n *\n * The alternative would be to open a second, independent transaction, which is\n * what these adapters used to do; on a shared connection that silently\n * destroyed the enclosing transaction's uncommitted work.\n *\n * @example Ensuring a helper works on every adapter\n * ```typescript\n * // Take the transaction as a parameter rather than opening a nested one.\n * async function recordClick(db: DatabaseInterface, id: string) {\n * await db.update('links', { id }, { clicks: 1 });\n * }\n * await db.transaction(async (tx) => recordClick(tx, id));\n * ```\n */\nexport class NestedTransactionError extends DatabaseError {\n constructor(message: string, context?: Record<string, unknown>) {\n super(message, context);\n this.name = 'NestedTransactionError';\n }\n}\n\n/**\n * WHERE clause input for database queries\n *\n * Supports two formats:\n * 1. Object format (AND-only): `{ status: 'active', 'price >': 100 }`\n * - All conditions are AND-joined\n *\n * 2. 2D array format (OR/AND compound logic): `[[cond1, cond2], [cond3, cond4]]`\n * - Inner arrays are AND-joined: `(cond1 AND cond2)`\n * - Outer array is OR-joined: `(cond1 AND cond2) OR (cond3 AND cond4)`\n *\n * @example Object format (backward compatible)\n * ```typescript\n * // WHERE status = 'active' AND name contains the exact text '100% cotton'\n * const where = {\n * status: 'active',\n * 'name contains': '100% cotton',\n * };\n * ```\n *\n * @example 2D array format for OR/AND compound logic\n * ```typescript\n * // WHERE (status = 'active' AND price > 100) OR (status = 'pending' AND priority = 'high')\n * const where = [\n * [{ status: 'active' }, { 'price >': 100 }],\n * [{ status: 'pending' }, { priority: 'high' }]\n * ];\n * ```\n */\nexport type WhereClause = Record<string, any> | Record<string, any>[][];\n\n/**\n * Common database connection options\n */\nexport interface DatabaseCacheOptions {\n /**\n * Stable, caller-supplied cache identity. When omitted, adapters derive an\n * identity from their effective connection configuration.\n */\n dbid?: string;\n\n /**\n * Whether this request may reuse and retain a shared adapter.\n * Set to `false` for a distinct connection that is never inserted into the\n * shared cache. Existing cached connections are left untouched.\n *\n * @default true for adapters that support caching\n */\n cache?: boolean;\n\n /**\n * Evict and close the matching cached adapter before serving this request.\n * Eviction waits for both resource closure and any in-flight initializer.\n * The replacement is cached unless `cache` is also `false`.\n *\n * @default false\n */\n clearCache?: boolean;\n}\n\nexport interface DatabaseOptions extends DatabaseCacheOptions {\n /**\n * Database connection URL\n */\n url?: string;\n\n /**\n * Authentication token for the database connection\n */\n authToken?: string;\n\n /**\n * How long a queued transaction waits for the connection, in milliseconds.\n *\n * Applies to the single-connection adapters — SQLite (both the LibSQL and\n * native paths), DuckDB, JSON and PGlite. Those drive one connection, so transactions\n * run one at a time and an overlapping `transaction()` waits its turn.\n * PostgreSQL pools and ignores this.\n *\n * The clock starts when the call queues, not when the connection frees, so\n * this bounds the total wait rather than any single transaction: raise it for\n * workloads with long transactions *or* with sustained bursts on one\n * connection. Must be positive and finite.\n *\n * Read once, when the connection is created. Adapters that cache connections\n * hand a later `getDatabase()` for the same database the existing one, which\n * keeps the timeout the first caller asked for.\n *\n * @default 30000\n */\n transactionQueueTimeout?: number;\n}\n\n/**\n * DuckDB-specific connection options\n */\nexport interface DuckDBOptions extends DatabaseOptions {\n /**\n * Database type identifier\n */\n type?: 'duckdb';\n\n /**\n * Path to directory containing JSON files to auto-register as tables\n * @default './data'\n */\n dataDir?: string;\n\n /**\n * Automatically register JSON files in dataDir as queryable tables\n * @default true\n */\n autoRegisterJSON?: boolean;\n\n /**\n * Strategy for writing data back to JSON files\n * - 'immediate': Write changes to JSON files immediately\n * - 'manual': Require explicit export calls\n * - 'none': Read-only mode, no writes to JSON files\n * @default 'none'\n */\n writeStrategy?: 'immediate' | 'manual' | 'none';\n\n /**\n * Whether to use a persistent DuckDB file for caching/indexes\n * If true, uses url or defaults to ':memory:'\n * @default false\n */\n persistent?: boolean;\n\n /**\n * Accepted for uniform configuration. DuckDB creates a fresh adapter on\n * every call, so this option does not change its behavior.\n */\n cache?: boolean;\n\n /**\n * Accepted for uniform configuration. DuckDB has no shared cache to evict,\n * so this option does not change its behavior.\n */\n clearCache?: boolean;\n\n /**\n * Explicit schema definitions for tables\n * When provided, these schemas will be used for table creation\n */\n schemas?: SchemasOption;\n}\n\n/**\n * A JSON data file that parsed but whose records could not be loaded into the\n * table — e.g. a renamed or dropped column, a NOT NULL / PRIMARY KEY violation,\n * or a file whose fields match no column on the table.\n *\n * The JSON adapter keeps the table (empty) and continues loading every other\n * table, logging the failure to stderr. This record makes the same failure\n * observable to calling code so a table that silently stays empty can be\n * detected. See issue #1139.\n */\nexport interface JSONTableLoadError {\n /** Name of the table whose data file failed to load */\n table: string;\n /** Path to the JSON data file that could not be loaded */\n filePath: string;\n /**\n * The underlying failure. Typically a `DatabaseError` whose `context`\n * carries the engine-level cause (e.g. the DuckDB constraint message).\n */\n error: unknown;\n}\n\n/**\n * JSON database adapter options (DuckDB-backed)\n *\n * Uses DuckDB's in-memory engine to query JSON files directly.\n * No WAL files or persistent database files are created.\n */\nexport interface JSONOptions extends DatabaseOptions {\n /**\n * Database type identifier\n */\n type: 'json';\n\n /**\n * Path to directory containing JSON files (required)\n * JSON files in this directory will be loaded as queryable tables\n */\n url: string;\n\n /**\n * Automatically load all JSON files in dataDir as tables\n * @default true\n */\n autoRegister?: boolean;\n\n /**\n * Strategy for writing changes back to JSON files\n * - 'immediate': Auto-save after every insert/update (default)\n * - 'manual': Require explicit exportTable() calls\n * - 'none': Read-only mode, throws error on writes\n * @default 'immediate'\n */\n writeStrategy?: 'immediate' | 'manual' | 'none';\n\n /**\n * How long a queued transaction waits for the connection, in milliseconds.\n *\n * Applies to the single-connection adapters — SQLite (both the LibSQL and\n * native paths), DuckDB, JSON and PGlite. Those drive one connection, so transactions\n * run one at a time and an overlapping `transaction()` waits its turn.\n * PostgreSQL pools and ignores this.\n *\n * The clock starts when the call queues, not when the connection frees, so\n * this bounds the total wait rather than any single transaction: raise it for\n * workloads with long transactions *or* with sustained bursts on one\n * connection. Must be positive and finite.\n *\n * Read once, when the connection is created. Adapters that cache connections\n * hand a later `getDatabase()` for the same database the existing one, which\n * keeps the timeout the first caller asked for.\n *\n * @default 30000\n */\n transactionQueueTimeout?: number;\n\n /**\n * Explicit schema definitions for tables\n *\n * When provided, these schemas will be used instead of auto-detection.\n * This allows frameworks to provide explicit schemas via dependency injection.\n *\n * @example\n * ```typescript\n * const db = await getDatabase({\n * type: 'json',\n * url: './data',\n * schemas: {\n * users: {\n * tableName: 'users',\n * ddl: 'CREATE TABLE users (id TEXT PRIMARY KEY, name TEXT)',\n * indexes: ['CREATE INDEX idx_users_name ON users(name)']\n * }\n * }\n * });\n * ```\n */\n schemas?: SchemasOption;\n\n /**\n * Unique identifier for in-memory DuckDB instances to enable connection sharing\n * When multiple getDatabase() calls use the same dbid, they receive\n * the same database connection instance.\n *\n * Auto-generated if not provided, enabling connection sharing by default.\n * This solves the issue where multiple collections create separate in-memory\n * databases that can't see each other's tables.\n */\n dbid?: string;\n\n /**\n * Eagerly load all JSON files as tables at connection time\n *\n * When true (default), creates tables with inferred schemas for all JSON files\n * in the data directory, even those without explicit schemas or .schema.sql files.\n * This enables cross-table queries (JOINs, NOT EXISTS subqueries) before\n * syncSchema() is called.\n *\n * Note: Inferred schemas don't include UNIQUE constraints. UPSERT operations\n * require syncSchema() to be called first to establish proper constraints.\n * When syncSchema() is called, tables with inferred schemas are dropped and\n * recreated with the proper schema.\n *\n * @default true\n */\n eagerLoadTables?: boolean;\n\n /**\n * Evict and close the existing database connection before creating a fresh one\n *\n * The new adapter is cached unless `cache` is also false. Eviction is awaited.\n * When automatic file registration is enabled, JSON adapters detect changed,\n * added, or removed `.json` and companion `.schema.sql` files on a later\n * acquisition. Use this option when a caller needs an unconditional reload\n * even if those sources are unchanged. Existing references point to the\n * closed adapter after replacement.\n *\n * @default false\n *\n * @example\n * // Initial connection - cached\n * const db1 = await getDatabase({ type: 'json', url: './data' });\n *\n * // Force an unconditional replacement...\n *\n * // Force reload from disk\n * const db2 = await getDatabase({\n * type: 'json',\n * url: './data',\n * clearCache: true\n * });\n */\n clearCache?: boolean;\n\n /**\n * Called when a JSON data file parses but its records cannot be loaded into a\n * table that was created for it — from a provided schema, a `.schema.sql`\n * file, or deferred `syncSchema()` / `execute()` DDL — leaving that table\n * present but empty (renamed/dropped column, NOT NULL / PRIMARY KEY violation,\n * or a file whose fields match no column). Every other table still loads.\n *\n * This targets the *silent* failure: a present-but-empty table a query cannot\n * tell apart from a legitimately empty one. A file with no schema at all is\n * loaded by DuckDB's own inference; if that fails the table is simply not\n * created, which already surfaces as an error when you query it, so it is not\n * reported here.\n *\n * Fires for both connection-time and deferred (`syncSchema()` / `execute()`)\n * loads. Without it, such a failure is only visible as a `console.error` on\n * stderr. The same failures are also retrievable after the fact via the\n * adapter's `getTableLoadErrors()` method.\n *\n * Registered once, on the `getDatabase()` call that creates the connection.\n * The JSON adapter caches connections per URL, so a later `getDatabase()` for\n * the same directory returns the existing connection and does *not* re-wire a\n * different `onTableLoadError` — read `getTableLoadErrors()` on the returned\n * adapter instead, which reflects the shared connection's failures.\n *\n * A callback that throws is caught and ignored so it cannot break loading of\n * the remaining tables. See issue #1139.\n */\n onTableLoadError?: (info: JSONTableLoadError) => void;\n}\n\n/**\n * Result of a database operation that modifies data\n */\nexport interface QueryResult {\n /**\n * Type of operation performed (e.g., \"insert\", \"update\", \"delete\")\n */\n operation: string;\n\n /**\n * Number of rows affected by the operation\n */\n affected: number;\n}\n\n/**\n * Options for upsert operations.\n */\nexport interface UpsertOptions {\n /**\n * Preserve database-native NULL-distinct conflict behavior.\n *\n * By default, upsert treats NULL values in conflict columns as matching\n * existing NULL values. Set this to true to opt out and use the underlying\n * database's native ON CONFLICT behavior where NULLs are distinct.\n */\n nullsDistinct?: boolean;\n}\n\n/**\n * Schema definition that can be provided to database adapters\n *\n * Allows frameworks like SMRT to provide explicit schemas instead of\n * relying on auto-detection or circular dependencies.\n *\n * This is a simpler, DDL-based alternative to SchemaDefinition which is\n * used for structured JSON manifests.\n */\nexport interface SchemaProvider {\n /**\n * Table name in snake_case plural form\n */\n tableName: string;\n\n /**\n * DDL statement(s) to create the table\n * Can be a single CREATE TABLE statement or multiple statements\n */\n ddl: string;\n\n /**\n * Index creation statements (optional)\n * Each string should be a complete CREATE INDEX statement\n */\n indexes?: string[];\n\n /**\n * Trigger creation statements (optional, adapter-specific support)\n * Each string should be a complete CREATE TRIGGER statement\n */\n triggers?: string[];\n\n /**\n * Schema version for migration tracking (optional)\n */\n version?: string;\n\n /**\n * Field metadata (optional, for advanced use cases)\n * Can be used by frameworks for runtime type information and validation\n */\n fields?: Map<string, any>;\n}\n\n/**\n * Schema definitions for getDatabase(), either eagerly built or lazy.\n *\n * Callers can pass schemas as a lazy function so that building the schema\n * map (potentially 200+ objects from ObjectRegistry) is deferred until an\n * adapter actually needs it. Adapters that manage tables via migrations\n * (Postgres, SQLite) never call the function, making the cost zero.\n *\n * @example Lazy — only resolved by JSON/DuckDB adapters\n * ```typescript\n * await getDatabase({\n * type: 'postgres',\n * url: '...',\n * schemas: () => ObjectRegistry.getAllSchemas(), // never called\n * });\n * ```\n *\n * @example Eager — built upfront (fine for JSON/DuckDB)\n * ```typescript\n * await getDatabase({\n * type: 'json',\n * url: './data',\n * schemas: { users: { tableName: 'users', ddl: '...' } },\n * });\n * ```\n */\nexport type SchemasOption =\n | Record<string, SchemaProvider>\n | (() => Record<string, SchemaProvider>);\n\n/**\n * Resolves a SchemasOption to its concrete value.\n *\n * Adapters that need schemas (JSON, DuckDB) call this to unwrap the\n * lazy function. Adapters that don't (Postgres, SQLite) simply ignore\n * the `schemas` option without calling this.\n */\nexport function resolveSchemas(\n schemas: SchemasOption | undefined,\n): Record<string, SchemaProvider> | undefined {\n if (!schemas) return undefined;\n if (typeof schemas === 'function') return schemas();\n return schemas;\n}\n\n/**\n * Schema manifest structure for JSON-based schema management\n */\nexport interface SchemaManifest {\n version: string;\n timestamp: number;\n packageName: string;\n schemas: Record<string, SchemaDefinition>;\n dependencies: string[];\n}\n\n/**\n * Schema definition for individual tables\n */\nexport interface SchemaDefinition {\n tableName: string;\n columns: Record<string, ColumnDefinition>;\n indexes: IndexDefinition[];\n triggers: TriggerDefinition[];\n foreignKeys: ForeignKeyDefinition[];\n dependencies: string[];\n version: string;\n packageName: string;\n baseClass?: string;\n}\n\n/**\n * Column definition structure\n */\nexport interface ColumnDefinition {\n type: string;\n primaryKey?: boolean;\n unique?: boolean;\n notNull?: boolean;\n defaultValue?: any;\n check?: string;\n foreignKey?: {\n table: string;\n column: string;\n onDelete?: string;\n onUpdate?: string;\n };\n description?: string;\n}\n\n/**\n * Column definition with name for ALTER TABLE operations\n */\nexport interface ColumnDefinitionWithName extends ColumnDefinition {\n name: string;\n}\n\n/**\n * Index definition structure\n */\nexport interface IndexDefinition {\n name: string;\n /** Adapter addIndex requires plain names; shared builders/manifests also accept trusted SQL terms. */\n columns: string[];\n unique?: boolean;\n where?: string;\n description?: string;\n}\n\n/**\n * Trigger definition structure\n */\nexport interface TriggerDefinition {\n name: string;\n when: string;\n event: string;\n table: string;\n condition?: string;\n body: string;\n description?: string;\n}\n\n/**\n * Foreign key constraint definition\n */\nexport interface ForeignKeyDefinition {\n column: string;\n referencesTable: string;\n referencesColumn: string;\n onDelete?: string;\n onUpdate?: string;\n}\n\n/**\n * Options for schema initialization and management\n */\nexport interface SchemaInitializationOptions {\n /** Schema manifest containing table definitions */\n manifest?: SchemaManifest;\n /** Raw SQL DDL schema string (legacy support) */\n schema?: string;\n /** Schema overrides for extending base schemas */\n overrides?: Record<string, SchemaDefinition>;\n /** Force recreation of tables */\n force?: boolean;\n /** Enable debug logging */\n debug?: boolean;\n}\n\n/**\n * Table schema information returned by getTableSchema()\n */\nexport interface TableSchemaInfo {\n /** Table name */\n tableName: string;\n /** Columns in the table */\n columns: Record<string, ColumnDefinition>;\n /** Indexes on the table */\n indexes: IndexDefinition[];\n /** Foreign key constraints */\n foreignKeys: ForeignKeyDefinition[];\n}\n\n/**\n * Options for vector similarity search\n */\nexport interface VectorSearchOptions {\n /** Maximum number of results to return */\n limit?: number;\n /** Distance metric for similarity comparison @default 'cosine' */\n metric?: 'cosine' | 'l2' | 'ip';\n /**\n * Additional SQL WHERE clause.\n * Use $2, $3, etc. for parameter placeholders ($1 is reserved for the query vector).\n * @example `category = $2`\n */\n where?: string;\n /** Parameters for the WHERE clause, bound to $2, $3, etc. */\n params?: any[];\n}\n\n/**\n * Result of a vector similarity search\n */\nexport interface VectorSearchResult {\n /** Row primary key */\n id: string;\n /**\n * Distance from query vector (lower = more similar).\n * Range varies by metric: cosine [0, 2], L2 [0, Infinity), ip (-Infinity, Infinity).\n */\n distance: number;\n /** Additional columns from the row */\n [key: string]: any;\n}\n\n/**\n * Options for creating a vector index\n */\nexport interface VectorIndexOptions {\n /** Number of dimensions (informational only, dimensions are set via ensureColumn) */\n dimensions?: number;\n /** Distance metric @default 'cosine' */\n metric?: 'cosine' | 'l2' | 'ip';\n /** Index type @default 'hnsw' */\n type?: 'hnsw' | 'ivfflat';\n}\n\n/**\n * Vector operations capability for database adapters\n *\n * Provides native vector similarity search, storage, and indexing.\n * Implemented by PostgreSQL via pgvector and optionally by SQLite via\n * sqlite-vector.\n */\nexport interface VectorCapabilities {\n /**\n * Search for similar vectors\n *\n * @param table - Table containing vector column\n * @param column - Name of the vector column\n * @param embedding - Query vector\n * @param options - Search options\n * @returns Ranked results by similarity\n */\n search(\n table: string,\n column: string,\n embedding: number[],\n options?: VectorSearchOptions,\n ): Promise<VectorSearchResult[]>;\n\n /**\n * Ensure a vector column exists on a table\n *\n * @param table - Table name\n * @param column - Column name\n * @param dimensions - Number of vector dimensions\n */\n ensureColumn(\n table: string,\n column: string,\n dimensions: number,\n ): Promise<void>;\n\n /**\n * Ensure a vector index exists on a column\n *\n * @param table - Table name\n * @param column - Column name\n * @param options - Index options\n */\n ensureIndex(\n table: string,\n column: string,\n options?: VectorIndexOptions,\n ): Promise<void>;\n\n /**\n * Store or update a vector in a specific row\n *\n * @param table - Table name\n * @param where - Conditions to identify the row\n * @param column - Vector column name\n * @param embedding - Vector data\n */\n upsertVector(\n table: string,\n where: Record<string, any>,\n column: string,\n embedding: number[],\n ): Promise<void>;\n}\n\n/**\n * SQLite notification delivered by optional notification capabilities.\n */\nexport interface DatabaseNotification {\n id: number;\n channel: string;\n payload: any;\n createdAt?: number | string | Date | null;\n}\n\n/**\n * Options for notification listeners.\n */\nexport interface NotificationListenOptions {\n /**\n * Fallback poll interval in milliseconds when the native watcher does not\n * receive an update signal.\n */\n fallbackPollMs?: number | null;\n}\n\n/**\n * Options for waiting on the next database update.\n */\nexport interface NotificationWaitOptions {\n /**\n * Maximum time to wait in milliseconds. When omitted, waits indefinitely.\n */\n timeoutMs?: number;\n\n /**\n * Optional abort signal to cancel the wait.\n */\n signal?: AbortSignal;\n}\n\n/**\n * Options for pruning persisted notification rows.\n */\nexport interface NotificationPruneOptions {\n /** Delete notifications older than this many seconds. */\n olderThanS?: number | null;\n /** Keep at most this many most-recent notifications. */\n maxKeep?: number | null;\n}\n\n/**\n * Optional notification/pub-sub capabilities for database adapters.\n */\nexport interface NotificationCapabilities {\n notify(channel: string, payload: any): Promise<number>;\n listen(\n channel: string,\n options?: NotificationListenOptions,\n ): AsyncIterable<DatabaseNotification>;\n waitForUpdate(options?: NotificationWaitOptions): Promise<boolean>;\n prune(options?: NotificationPruneOptions): Promise<number>;\n}\n\n/**\n * Options for SQLite native notification support.\n */\nexport interface SqliteNotificationCapabilityOptions {\n watcherBackend?: 'polling' | 'kernel' | 'shm';\n maxReaders?: number;\n}\n\n/**\n * Options for SQLite native vector support.\n */\nexport interface SqliteVectorCapabilityOptions {\n preload?: boolean;\n quantization?: 'turbo4' | 'turbo3' | 'turbo2' | 'uint8' | 'int8' | '1bit';\n maxMemory?: string;\n}\n\n/**\n * Optional SQLite-only native capabilities.\n */\nexport interface SqliteCapabilitiesOptions {\n notifications?: boolean | SqliteNotificationCapabilityOptions;\n vector?: boolean | SqliteVectorCapabilityOptions;\n}\n\n/**\n * Common interface for database adapters\n * Provides a unified API for different database backends\n */\nexport interface DatabaseInterface {\n /**\n * Database location identifier\n * For file-based databases: file path\n * For directory-based databases (JSON/DuckDB with JSON): directory path\n * For in-memory databases: ':memory:'\n * For remote databases: connection URL\n */\n url: string;\n\n /**\n * Underlying database client instance\n */\n client: any;\n\n /**\n * Inserts one or more records into a table\n *\n * @param table - Table name\n * @param data - Single record or array of records to insert\n * @returns Promise resolving to operation result\n */\n insert: (\n table: string,\n data: Record<string, any> | Record<string, any>[],\n ) => Promise<QueryResult>;\n\n /**\n * Retrieves a single record matching the where criteria\n *\n * @param table - Table name\n * @param where - Criteria to match records (object for AND-only, 2D array for OR/AND)\n * @returns Promise resolving to matching record or null if not found\n */\n get: (\n table: string,\n where: WhereClause,\n ) => Promise<Record<string, any> | null>;\n\n /**\n * Retrieves multiple records matching the where criteria\n *\n * @param table - Table name\n * @param where - Criteria to match records (object for AND-only, 2D array for OR/AND)\n * @returns Promise resolving to array of matching records\n */\n list: (table: string, where: WhereClause) => Promise<Record<string, any>[]>;\n\n /**\n * Updates records matching the where criteria\n *\n * @param table - Table name\n * @param where - Criteria to match records to update (object for AND-only, 2D array for OR/AND)\n * @param data - New data to set\n * @returns Promise resolving to operation result\n */\n update: (\n table: string,\n where: WhereClause,\n data: Record<string, any>,\n ) => Promise<QueryResult>;\n\n /**\n * Inserts a record or updates it if it already exists (UPSERT)\n * Uses database-specific ON CONFLICT / ON DUPLICATE KEY syntax\n *\n * @param table - Table name\n * @param conflictColumns - Columns that define the uniqueness constraint\n * @param data - Data to insert or update\n * @returns Promise resolving to operation result\n *\n * @example\n * ```typescript\n * // Upsert a user by email\n * await db.upsert('users', ['email'], {\n * email: 'user@example.com',\n * name: 'John Doe',\n * updated_at: new Date().toISOString()\n * });\n *\n * // Upsert with composite key\n * await db.upsert('settings', ['user_id', 'key'], {\n * user_id: '123',\n * key: 'theme',\n * value: 'dark'\n * });\n * ```\n */\n upsert: (\n table: string,\n conflictColumns: string[],\n data: Record<string, any>,\n options?: UpsertOptions,\n ) => Promise<QueryResult>;\n\n /**\n * Gets a record matching the where criteria or inserts it if not found\n *\n * @param table - Table name\n * @param where - Criteria to match existing record (object for AND-only, 2D array for OR/AND)\n * @param data - Data to insert if no record found\n * @returns Promise resolving to the record (either retrieved or newly inserted)\n */\n getOrInsert: (\n table: string,\n where: WhereClause,\n data: Record<string, any>,\n ) => Promise<Record<string, any>>;\n\n /**\n * Deletes records from a table matching the where criteria\n *\n * @param table - Table name\n * @param where - Criteria to match records for deletion (object for AND-only, 2D array for OR/AND)\n * @returns Promise resolving to operation result with count of deleted rows\n *\n * @example\n * ```typescript\n * // Delete by ID\n * await db.delete('products', { id: 'prod-123' });\n *\n * // Delete by criteria\n * await db.delete('orders', { status: 'cancelled' });\n *\n * // Delete with multiple conditions\n * await db.delete('sessions', {\n * user_id: 'user-123',\n * expired: true\n * });\n * ```\n */\n delete: (table: string, where: WhereClause) => Promise<QueryResult>;\n\n /**\n * Counts records in a table matching the where criteria\n *\n * @param table - Table name\n * @param where - Criteria to match records (optional, counts all if omitted; object for AND-only, 2D array for OR/AND)\n * @returns Promise resolving to count of matching records\n *\n * @example\n * ```typescript\n * // Count all records\n * const total = await db.count('products');\n *\n * // Count with single condition\n * const activeCount = await db.count('products', { active: true });\n *\n * // Count with multiple conditions\n * const filteredCount = await db.count('orders', {\n * status: 'pending',\n * priority: 'high'\n * });\n * ```\n */\n count: (table: string, where?: WhereClause) => Promise<number>;\n\n /**\n * Creates a table-specific interface for simplified table operations\n *\n * @param table - Table name\n * @returns TableInterface for the specified table\n */\n table: (table: string) => TableInterface;\n\n /**\n * Checks if a table exists in the database\n *\n * @param table - Table name\n * @returns Promise resolving to boolean indicating existence\n */\n tableExists: (table: string) => Promise<boolean>;\n\n /**\n * Whether this adapter requires schema existence checks at runtime.\n *\n * Set to `true` on adapters where tables may not exist yet and need\n * to be verified before use (e.g. JSON/DuckDB with auto-created tables).\n *\n * When absent or `false`, frameworks skip `tableExists()` calls during\n * collection initialization — tables are assumed to exist because\n * schema is managed by migrations (e.g. `smrt db:migrate`).\n *\n * - Postgres adapter: not set (migration-managed)\n * - SQLite adapter: not set (migration-managed)\n * - JSON/DuckDB adapter: `true` (tables may be auto-created)\n */\n requiresSchemaCheck?: boolean;\n\n /**\n * Executes a SQL query using template literals and returns multiple rows\n *\n * @param strings - Template strings\n * @param vars - Variables to interpolate into the query\n * @returns Promise resolving to array of result records\n */\n many: (\n strings: TemplateStringsArray,\n ...vars: any[]\n ) => Promise<Record<string, any>[]>;\n\n /**\n * Executes a SQL query using template literals and returns a single row\n *\n * @param strings - Template strings\n * @param vars - Variables to interpolate into the query\n * @returns Promise resolving to a single result record or null\n */\n single: (\n strings: TemplateStringsArray,\n ...vars: any[]\n ) => Promise<Record<string, any> | null>;\n\n /**\n * Executes a SQL query using template literals and returns a single value\n *\n * @param strings - Template strings\n * @param vars - Variables to interpolate into the query\n * @returns Promise resolving to a single value (first column of first row)\n */\n pluck: (strings: TemplateStringsArray, ...vars: any[]) => Promise<any>;\n\n /**\n * Executes a SQL query using template literals without returning results\n *\n * @param strings - Template strings\n * @param vars - Variables to interpolate into the query\n * @returns Promise that resolves when the query completes\n */\n execute: (strings: TemplateStringsArray, ...vars: any[]) => Promise<void>;\n\n /**\n * Alias for many() - Executes a SQL query and returns multiple rows\n */\n oo: (\n strings: TemplateStringsArray,\n ...vars: any[]\n ) => Promise<Record<string, any>[]>;\n\n /**\n * Alias for single() - Executes a SQL query and returns a single row\n */\n oO: (\n strings: TemplateStringsArray,\n ...vars: any[]\n ) => Promise<Record<string, any> | null>;\n\n /**\n * Alias for pluck() - Executes a SQL query and returns a single value\n */\n ox: (strings: TemplateStringsArray, ...vars: any[]) => Promise<any>;\n\n /**\n * Alias for execute() - Executes a SQL query without returning results\n */\n xx: (strings: TemplateStringsArray, ...vars: any[]) => Promise<void>;\n\n /**\n * Executes a raw SQL query with parameterized values\n *\n * Raw queries use the adapter's native placeholder syntax.\n * Parameters may be passed as rest arguments or as one values array.\n * For adapter-specific array parameter caveats, see the package docs.\n *\n * @param str - SQL query string\n * @param vars - Variables to use as parameters\n * @returns Promise resolving to query result with rows and count\n */\n query: (\n str: string,\n ...vars: any[]\n ) => Promise<{ rows: Record<string, any>[]; rowCount: number }>;\n\n /**\n * Synchronizes database schema with provided SQL DDL\n * Creates tables if they don't exist and adds missing columns\n *\n * @param schema - SQL schema definition with CREATE TABLE statements\n * @returns Promise that resolves when schema is synchronized\n */\n syncSchema?: (schema: string) => Promise<void>;\n\n /**\n * Initialize database schemas from JSON manifest\n * Supports dependency resolution and schema overrides\n *\n * @param options - Schema initialization options\n * @returns Promise that resolves when schemas are initialized\n */\n initializeSchemas?: (options: SchemaInitializationOptions) => Promise<void>;\n\n /**\n * Executes a callback within a database transaction\n * Automatically commits on success or rolls back on error\n *\n * Calling `transaction()` again on the `tx` handed to a callback is\n * adapter-specific — do not assume one behaviour across adapters:\n *\n * - **SQLite** (both the libsql and native-capabilities paths) — the nested\n * scope re-enters the transaction already in progress under a `SAVEPOINT`.\n * It reads the enclosing transaction's uncommitted rows, and if it throws,\n * only its own work is rolled back; the enclosing transaction stays usable.\n * - **DuckDB and JSON** — the engine has no `SAVEPOINT`, so nesting throws\n * {@link NestedTransactionError} without touching the connection. The\n * enclosing transaction is unaffected and can continue.\n * - **PostgreSQL** — the nested scope re-enters the enclosing transaction\n * under a `SAVEPOINT` on the same pooled connection, like SQLite. It used\n * to check out a second connection and begin an independent transaction,\n * which could not see the enclosing transaction's uncommitted rows and\n * could deadlock against it undetectably; that was fixed in #1108.\n *\n * Code that must run on every adapter should take the transaction as a\n * parameter rather than opening a nested one.\n *\n * **Transactions are serialized per connection on the single-connection\n * adapters** — SQLite (both paths), DuckDB, JSON and PGlite drive one\n * connection, and a connection can only be in one transaction at a time, so a concurrent\n * `transaction()` waits for the one in progress rather than corrupting it. A\n * queued call that waits longer than `transactionQueueTimeout` (30s by\n * default) rejects rather than stalling indefinitely. Re-entrant calls do not\n * queue — they take the savepoint or refusal path described above.\n * PostgreSQL pools, so top-level transactions run concurrently. Nested scopes\n * on one PostgreSQL transaction use a scope-local queue: concurrently started\n * siblings serialize, while each child gets its own queue for further nesting.\n *\n * @param callback - Function to execute within transaction\n * @returns Promise resolving to callback result\n * @throws {NestedTransactionError} When nesting on an adapter without\n * savepoint support\n *\n * @example Portable across all adapters\n * ```typescript\n * async function recordClick(db: DatabaseInterface, id: string) {\n * await db.update('links', { id }, { clicks: 1 });\n * }\n *\n * await db.transaction(async (tx) => {\n * await tx.query('SELECT * FROM links WHERE id = $1 FOR UPDATE', id);\n * await recordClick(tx, id); // reuses tx; never opens its own\n * });\n * ```\n */\n transaction?: <T>(\n callback: (tx: DatabaseInterface) => Promise<T>,\n ) => Promise<T>;\n\n /**\n * Begins a new transaction and returns a handle for manual control\n *\n * Unlike transaction(), this gives you explicit control over commit/rollback.\n * Ideal for test isolation where you want to rollback after each test.\n *\n * On the single-connection adapters — SQLite (both paths), DuckDB and JSON —\n * the handle owns the connection until {@link TransactionHandle.commit} or\n * {@link TransactionHandle.rollback} is called, so every other transaction on\n * that connection waits in the meantime. **A handle that is never ended holds\n * the connection for the life of the process**, and later transactions then\n * fail with the queue-timeout error instead of proceeding. End the handle in\n * a `finally`, and in per-test setup guard the teardown, because an\n * assertion that throws between `beginTransaction()` and the teardown would\n * otherwise strand it.\n *\n * @returns Promise resolving to a TransactionHandle\n *\n * @example Test isolation pattern\n * ```typescript\n * let tx: TransactionHandle | undefined;\n *\n * beforeEach(async () => {\n * tx = await db.beginTransaction();\n * });\n *\n * afterEach(async () => {\n * // Guarded: if beforeEach threw, there is no handle to end, and an\n * // unguarded rollback would mask that failure with its own.\n * await tx?.rollback(); // Discard all test changes\n * tx = undefined;\n * });\n *\n * it('creates user', async () => {\n * await tx.insert('users', { id: '1', name: 'Test' });\n * const user = await tx.get('users', { id: '1' });\n * expect(user).toBeDefined();\n * // Changes rolled back in afterEach\n * });\n * ```\n */\n beginTransaction?: () => Promise<TransactionHandle>;\n\n /**\n * Acquire a pinned single-connection session.\n *\n * Returns a {@link SessionHandle} whose queries all run on one underlying\n * connection, enabling session-scoped state (e.g. PostgreSQL session advisory\n * locks) that the pooled top-level {@link query} cannot hold reliably. The\n * caller must {@link SessionHandle.release} it.\n *\n * Only meaningful for engines with session-scoped state, so it is currently\n * implemented for PostgreSQL only; check for the method before calling\n * (`if (db.acquireSession)`). Single-connection engines (SQLite, DuckDB) have\n * no session-scoped locks to hold, so they leave it undefined.\n *\n * @returns Promise resolving to a SessionHandle\n *\n * @example Hold a Postgres session advisory lock\n * ```typescript\n * const session = await db.acquireSession();\n * try {\n * await session.query('SELECT pg_advisory_lock($1)', 42);\n * // ... lock is held for the life of this session ...\n * } finally {\n * await session.release(); // frees the lock and drops the connection\n * }\n * ```\n */\n acquireSession?: () => Promise<SessionHandle>;\n\n /**\n * Retrieves the schema information for a table\n *\n * @param table - Table name\n * @returns Promise resolving to table schema info or null if table doesn't exist\n */\n getTableSchema?: (table: string) => Promise<TableSchemaInfo | null>;\n\n /**\n * Vector operations for native similarity search\n *\n * When available, enables database-level vector operations (e.g., pgvector).\n * Consumers should check for this capability rather than checking the database type.\n */\n vector?: VectorCapabilities;\n\n /**\n * Optional notification/pub-sub operations.\n */\n notifications?: NotificationCapabilities;\n\n /**\n * Close the database adapter and release native resources when supported.\n */\n close?: () => Promise<void>;\n\n /**\n * ALTER TABLE operations for schema evolution\n */\n alterTable?: {\n /**\n * Adds a new column to an existing table\n *\n * @param table - Table name\n * @param column - Column definition with name\n * @returns Promise that resolves when column is added\n */\n addColumn: (\n table: string,\n column: ColumnDefinitionWithName,\n ) => Promise<void>;\n\n /**\n * Adds a new index to an existing table\n *\n * @param table - Table name\n * @param index - Index definition\n * @returns Promise that resolves when index is created\n */\n addIndex: (table: string, index: IndexDefinition) => Promise<void>;\n };\n}\n\n/**\n * Transaction handle for manual transaction control\n *\n * Extends DatabaseInterface with commit() and rollback() methods.\n * Use beginTransaction() to obtain a handle, then explicitly\n * commit or rollback when done.\n *\n * @example Test isolation with rollback\n * ```typescript\n * const tx = await db.beginTransaction();\n * try {\n * // All operations happen in the transaction\n * await tx.insert('users', { id: '1', name: 'Test' });\n * const user = await tx.get('users', { id: '1' });\n *\n * // Rollback discards all changes (useful for test isolation)\n * await tx.rollback();\n * } catch (error) {\n * await tx.rollback();\n * throw error;\n * }\n * ```\n *\n * @example Manual commit\n * ```typescript\n * const tx = await db.beginTransaction();\n * try {\n * await tx.insert('orders', { id: '1', total: 100 });\n * await tx.insert('order_items', { order_id: '1', product: 'Widget' });\n * await tx.commit(); // Persist changes\n * } catch (error) {\n * await tx.rollback();\n * throw error;\n * }\n * ```\n */\nexport interface TransactionHandle extends DatabaseInterface {\n /**\n * Commits the transaction, persisting all changes\n *\n * After commit, the transaction handle should not be used.\n */\n commit: () => Promise<void>;\n\n /**\n * Rolls back the transaction, discarding all changes\n *\n * After rollback, the transaction handle should not be used.\n * This is the key method for test isolation - rollback after each test.\n */\n rollback: () => Promise<void>;\n\n /**\n * Whether the transaction is still active (not committed or rolled back)\n */\n isActive: () => boolean;\n}\n\n/**\n * Pinned single-connection session handle.\n *\n * Obtained via {@link DatabaseInterface.acquireSession}. Unlike the pooled\n * top-level `query` (which may run each statement on a different connection),\n * every call on a session handle runs on the *same* underlying connection for\n * the handle's lifetime. This is required for session-scoped state such as\n * PostgreSQL session advisory locks (`pg_advisory_lock`), which must be\n * acquired, observed, and released on one connection — and which release\n * automatically if the connection drops (e.g. the process dies).\n *\n * A session holds one connection out of the pool (default max 20) for its\n * entire lifetime, so it is meant to be held one-per-process, not per-operation.\n * Always {@link SessionHandle.release} the handle when done, and release it\n * *before* calling `db.client.end()` — a pinned connection keeps `pool.end()`\n * from resolving.\n */\nexport interface SessionHandle {\n /**\n * Execute a raw query on this session's pinned connection.\n * Same placeholder/return contract as {@link DatabaseInterface.query}.\n * Throws if the session has been released or its connection was lost.\n */\n query: (\n sql: string,\n ...vars: any[]\n ) => Promise<{ rows: Record<string, any>[]; rowCount: number }>;\n\n /**\n * Whether the session is still usable — not released and its connection has\n * not errored/dropped. A long-lived lock holder can poll this without\n * issuing a query.\n */\n isActive: () => boolean;\n\n /**\n * Release the session. Idempotent. After release the handle must not be used.\n * Best-effort frees session-scoped locks, then drops the underlying\n * connection (it is NOT returned to the pool) so the database releases any\n * remaining session state — returning it to the pool would leak that state\n * onto a later, unrelated checkout.\n */\n release: () => Promise<void>;\n}\n\n/**\n * Simplified interface for table-specific operations\n */\nexport interface TableInterface {\n /**\n * Inserts one or more records into the table\n *\n * @param data - Single record or array of records to insert\n * @returns Promise resolving to operation result\n */\n insert: (\n data: Record<string, any> | Record<string, any>[],\n ) => Promise<QueryResult>;\n\n /**\n * Retrieves a single record from the table matching the where criteria\n *\n * @param where - Criteria to match records (object for AND-only, 2D array for OR/AND)\n * @returns Promise resolving to matching record or null if not found\n */\n get: (where: WhereClause) => Promise<Record<string, any> | null>;\n\n /**\n * Retrieves multiple records from the table matching the where criteria\n *\n * @param where - Criteria to match records (object for AND-only, 2D array for OR/AND)\n * @returns Promise resolving to array of matching records\n */\n list: (where: WhereClause) => Promise<Record<string, any>[]>;\n}\n","/**\n * Browser-safe entry for the driver-independent query helpers.\n *\n * Everything here is pure SQL-fragment construction or operates on an\n * already-open `DatabaseInterface`. Nothing on this import graph reaches `pg`,\n * the libsql or DuckDB adapters, or any `node:` built-in, so browser-bundled\n * packages can import it instead of the package root. The root entry\n * re-exports all of it.\n *\n * @example\n * ```typescript\n * import { buildWhere, validateColumnName } from '@happyvertical/sql/query';\n * ```\n *\n * @packageDocumentation\n */\n\nimport type { DatabaseInterface } from './shared/types.js';\n\n/**\n * Checks if a table exists in the database\n *\n * @param db - Database interface to use\n * @param tableName - Name of the table to check\n * @returns Promise resolving to boolean indicating if the table exists\n */\nexport async function tableExists(db: DatabaseInterface, tableName: string) {\n return db.tableExists(tableName);\n}\n\n/**\n * Escapes and formats a value for use in SQL queries\n *\n * @param value - Value to escape\n * @returns String representation of the value safe for SQL use\n */\nexport function escapeSqlValue(value: any): string {\n if (value === null) {\n return 'NULL';\n }\n if (value instanceof Date) {\n return `'${value.toISOString()}'`;\n }\n if (typeof value === 'number') {\n return value.toString();\n }\n if (typeof value === 'boolean') {\n return value ? '1' : '0';\n }\n // Escape single quotes and wrap in quotes\n return `'${String(value).replace(/'/g, \"''\")}'`;\n}\n\n/**\n * Validates a column name for use in SQL queries\n *\n * @param column - Column name to validate\n * @returns The validated column name\n * @throws Error if the column name contains invalid characters\n */\nexport function validateColumnName(column: string): string {\n // Reject non-strings before the regex. `test` coerces via `toString`, so an\n // object whose `toString` differs between this read and a later interpolation\n // read would pass validation and then reach SQL as a different identifier.\n // Only allow alphanumeric characters, underscores, and dots (for table.column notation)\n if (typeof column !== 'string' || !/^[a-zA-Z0-9_.]+$/.test(column)) {\n throw new Error(`Invalid column name: ${column}`);\n }\n return column;\n}\n\n/**\n * Synchronizes a SQL schema definition with a database\n * Creates tables if they don't exist and adds missing columns to existing tables\n *\n * @param options - Object containing database and schema\n * @param options.db - Database interface to use\n * @param options.schema - SQL schema definition\n * @throws Error if db or schema are missing or if the database doesn't support syncSchema\n */\nexport async function syncSchema(options: {\n db: DatabaseInterface;\n schema: string;\n}) {\n const { db, schema } = options;\n if (!db || !schema) {\n throw new Error('db and schema are required');\n }\n\n // Delegate to the database adapter's syncSchema implementation\n if (db.syncSchema) {\n await db.syncSchema(schema);\n } else {\n throw new Error('Database adapter does not support schema synchronization');\n }\n}\n\nexport {\n type AggregateBuildResult,\n type AggregateFunction,\n type AggregateSelectExpr,\n type AggregateSpec,\n type AggregateTimeBucketUnit,\n bucketExpr,\n buildAggregate,\n} from './aggregate.js';\nexport type {\n AggregateArithmeticOp,\n AggregateComparisonOp,\n AggregateExpression,\n AggregateJoin,\n AggregateLiteral,\n AggregateOperand,\n ExpressionErrorCode,\n ExpressionResultType,\n PortableExpression,\n RenderExpressionOptions,\n RenderExpressionResult,\n TypedDateLiteral,\n} from './aggregate-expression.js';\nexport {\n ExpressionError,\n renderExpression,\n} from './aggregate-expression.js';\nexport type { SchemaInitializationResult } from './schema-manager.js';\nexport { DatabaseSchemaManager } from './schema-manager.js';\nexport type { IdentifierOptions } from './shared/alter-utils.js';\nexport { convertUniqueIndexesToInlineConstraints } from './shared/duckdb-schema-utils.js';\nexport * from './shared/types.js';\nexport type { RawSqlKey, SqlAdapterType } from './shared/utils.js';\nexport { buildWhere, formatDbError, raw } from './shared/utils.js';\n"],"mappings":";;;AAkIA,IAAM,YAAY;;AAElB,IAAM,YAAY;AAElB,IAAM,aAAoD;CACxD,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;AACP;AACA,IAAM,aAAoD;CACxD,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,IAAI;CACJ,KAAK;AACP;AA0BA,SAAS,SAAS,OAAkD;CAClE,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEA,SAAS,QAAQ,OAAgB,OAA4B;CAC3D,MAAM,EAAE,QAAQ;CAChB,IAAI,SAAS,KAAK,KAAK,UAAU,OAAO,OAAO,UAAU,OAAO,KAAK;CACrE,IAAI,UAAU,MAAM,OAAO;CAC3B,IAAI,OAAO,UAAU,WAAW,OAAO,QAAQ,SAAS;CACxD,IAAI,OAAO,UAAU,UAAU;EAC7B,IAAI,CAAC,OAAO,SAAS,KAAK,GACxB,MAAM,IAAI,gBACR,sBACA,6CACF;EAIF,OAAO,OAAO,KAAK;CACrB;CACA,IAAI,iBAAiB,MAAM;EACzB,IAAI,OAAO,MAAM,MAAM,QAAQ,CAAC,GAC9B,MAAM,IAAI,gBACR,sBACA,0CACF;EAEF,IAAI,IAAI,SAAS,OACf,KACE,iBACA,kEACF;EACF,MAAM,cAAc,IAAI,IAAI;EAC5B,IAAI,OAAO,KAAK,MAAM,YAAY,CAAC;EAGnC,IAAI,IAAI,gBAAgB,YAAY,IAAI,gBAAgB,QACtD,OAAO,QAAQ,YAAY;EAE7B,IAAI,IAAI,gBAAgB,YACtB,OAAO,QAAQ,YAAY;EAE7B,OAAO;CACT;CACA,IAAI,OAAO,UAAU,UAAU;EAC7B,IAAI,IAAI,QAAQ,MAAM,SAAS,IAAI,GACjC,KAAK,sBAAsB,kCAAkC;EAC/D,IAAI,IAAI,SAAS,OACf,OAAO,YAAY,OAAO,IAAI,gBAAgB,UAAU;EAC1D,MAAM,cAAc,IAAI,IAAI;EAC5B,IAAI,OAAO,KAAK,KAAK;EACrB,OAAO;CACT;CACA,MAAM,IAAI,gBACR,sBACA,8EACF;AACF;AAEA,SAAS,eACP,aACA,OACA,SACQ;CACR,IAAI,gBAAgB,YAElB,OAAO,4BAA4B,MAAM,KAAK,QAAQ;CAExD,IAAI,gBAAgB,YAAY,gBAAgB,QAC9C,OAAO,SAAS,MAAM,YAAY,QAAQ;CAI5C,OAAO,eAAe,MAAM,gBAAgB,QAAQ;AACtD;AAEA,SAAS,uBACP,MACA,OACA,OACQ;CACR,IAAI,QAAQ,WACV,MAAM,IAAI,gBACR,oBACA,8CAA8C,WAChD;CAEF,MAAM,IAAI,aAAa,MAAM,IAAI,aAAa,KAAK;CACnD,IAAI,MAAM,IAAI,YAAY,WACxB,MAAM,IAAI,gBACR,oBACA,sCAAsC,UAAU,OAClD;CAEF,IAAI,CAAC,SAAS,IAAI,GAChB,MAAM,IAAI,gBACR,sBACA,6CACF;CAEF,MAAM,EAAE,QAAQ;CAChB,IACE,IAAI,QACH,OAAO,KAAK,OAAO,YAAY,OAAO,OAAO,iBAAiB,KAAK,EAAE,GAEtE,cAAc,IAAI;CAEpB,IAAI,SAAS,MAAM;EACjB,IAAI,WAAW,KAAK,GAAa;EAEjC,OADe,IAAI,WAAW,KAAK,GAC5B;CACT;CACA,IAAI,WAAW,QAAQ,EAAE,QAAQ,OAC/B,OAAO,QAAQ,KAAK,OAAO,KAAK;CAGlC,MAAM,KAAK,KAAK;CAChB,MAAM,SAAS,UAAmB,cAAc,OAAO,OAAO,QAAQ,CAAC;CAEvE,IAAI,OAAO,OAAO,YAAY,OAAO,OAAO,YAAY,EAAE,GAAG;EAC3D,MAAM,aAAa;EACnB,MAAM,OAAO,MAAM,KAAK,IAAI;EAC5B,MAAM,QAAQ,MAAM,KAAK,KAAK;EAC9B,IAAI,eAAe,OAAO;GAGxB,MAAM,WAAW,KAAK,KAAK,mBAAmB,MAAM;GAGpD,IAAI,IAAI,gBAAgB,YACtB,OAAO,QAAQ,SAAS;GAE1B,IAAI,IAAI,gBAAgB,YAAY,IAAI,gBAAgB,QACtD,OAAO,QAAQ,SAAS;GAE1B,OAAO;EACT;EACA,OAAO,IAAI,KAAK,GAAG,WAAW,YAAY,GAAG,MAAM;CACrD;CACA,IAAI,OAAO,kBAAkB;EAC3B,IAAI,IAAI,SAAS,OAAO;GACtB,gBAAgB,KAAK,OAAO,KAAK;GACjC,gBAAgB,KAAK,SAAS,KAAK;EACrC;EACA,OAAO,eACL,IAAI,aACJ,gBAAgB,KAAK,OAAO,MAAM,KAAK,KAAK,GAAG,GAAG,GAClD,gBAAgB,KAAK,SAAS,MAAM,KAAK,OAAO,GAAG,GAAG,CACxD;CACF;CACA,IAAI,OAAO,OAAO,YAAY,OAAO,OAAO,YAAY,EAAE,GAAG;EAC3D,MAAM,aAAa;EACnB,MAAM,WAAW,SACf,SAAS,IAAI,KAAK,WAAW,QAAQ,KAAK,UAAU;EACtD,KAAK,eAAe,QAAQ,eAAe,SAAS,QAAQ,KAAK,KAAK,GACpE,OAAO,IAAI,MAAM,KAAK,IAAI,EAAE,MAAM,eAAe,OAAO,SAAS,WAAW;EAE9E,KAAK,eAAe,QAAQ,eAAe,SAAS,QAAQ,KAAK,IAAI,GACnE,OAAO,IAAI,MAAM,KAAK,KAAK,EAAE,MAAM,eAAe,OAAO,SAAS,WAAW;EAE/E,OAAO,IAAI,MAAM,KAAK,IAAI,EAAE,GAAG,WAAW,YAAY,GAAG,MAAM,KAAK,KAAK,EAAE;CAC7E;CACA,IAAI,OAAO,SAAS,OAAO,MAAM;EAC/B,MAAM,WAAW,KAAK;EACtB,IAAI,CAAC,MAAM,QAAQ,QAAQ,KAAK,SAAS,WAAW,GAClD,MAAM,IAAI,gBACR,sBACA,wBAAwB,GAAG,+BAC7B;EAEF,OAAO,IAAI,SAAS,IAAI,KAAK,CAAC,CAAC,KAAK,OAAO,QAAQ,UAAU,MAAM,EAAE;CACvE;CACA,IAAI,OAAO,OACT,OAAO,QAAQ,MAAM,KAAK,OAAO,EAAE;CAErC,IAAI,OAAO,YAAY,OAAO,aAC5B,OAAO,IAAI,MAAM,KAAK,OAAO,EAAE,MAAM,OAAO,WAAW,SAAS,WAAW;CAE7E,IAAI,OAAO,YAAY;EACrB,MAAM,WAAW,KAAK;EACtB,IAAI,CAAC,MAAM,QAAQ,QAAQ,KAAK,SAAS,WAAW,GAClD,MAAM,IAAI,gBACR,sBACA,6DACF;EAEF,OAAO,YAAY,SAAS,IAAI,KAAK,CAAC,CAAC,KAAK,IAAI,EAAE;CACpD;CACA,IAAI,OAAO,UAAU;EACnB,IACE,IAAI,SAAS,SACb,CAAC;GAAC;GAAU;GAAQ;GAAW;EAAM,CAAC,CAAC,SACrC,WAAW,KAAK,SAAS,GAAG,CAC9B,GAEA,KACE,iBACA,oGACF;EAEF,MAAM,OACJ,IAAI,gBAAgB,YAAY,IAAI,gBAAgB,SAChD,YACA;EACN,OAAO,QAAQ,MAAM,KAAK,OAAO,EAAE,MAAM,KAAK;CAChD;CACA,MAAM,WAAW,eAAe,MAAM,OAAO,KAAK;CAClD,IAAI,aAAa,KAAA,GAAW,OAAO;CACnC,MAAM,IAAI,gBACR,sBACA,8CAA8C,OAAO,EAAE,GACzD;AACF;;;;;;AAOA,SAAgB,0BACd,MACA,KACQ;CACR,IAAI,MAAM,cAAc,MAAM,EAAE,IAAI,GAAG,CAAC;CAGxC,IAAI,WAAW,MAAM,GAAG,MAAM,UAAU,SAAS,IAAI,KAAK,QAAQ,MAAM;EACtE,IAAI,IAAI,gBAAgB,YAAY,MAAM,gBAAgB,GAAG;OACxD,IAAI,IAAI,gBAAgB,YAAY,IAAI,gBAAgB,QAC3D,MAAM,QAAQ,IAAI;EACpB,IAAI,WAAW,IAAI,WAAW,KAAK,IAAI;EACvC,IAAI,IAAI,UAAU,cAChB,KAAK,oBAAoB,0CAA0C;CACvE;CACA,OAAO;AACT;;AAgBA,IAAa,kBAAb,cAAqC,MAAM;CAEvB;CADlB,YACE,MACA,SACA;EACA,MAAM,OAAO;EAHG,KAAA,OAAA;EAIhB,KAAK,OAAO;CACd;AACF;AAEA,SAAS,KAAK,MAA2B,SAAwB;CAC/D,MAAM,IAAI,gBAAgB,MAAM,OAAO;AACzC;AAIA,IAAM,eAAe;AACrB,SAAS,cACP,MACA,OACA,OACQ;CACR,MAAM,MAAM,uBAAuB,MAAM,OAAO,KAAK;CACrD,MAAM,IAAI,WAAW,MAAM,IAAI,WAAW,KAAK,IAAI;CACnD,IAAI,MAAM,IAAI,UAAU,cACtB,KACE,oBACA,0BAA0B,aAAa,8BACzC;CAEF,OAAO;AACT;AAEA,SAAS,YAAY,OAAe,WAAW,OAAe;CAC5D,IAAI,UACF,OAAO,MAAM,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC,QAAQ,MAAM,IAAI,EAAE;CAChE,OAAO,IAAI,MAAM,QAAQ,MAAM,IAAI,EAAE;AACvC;AAEA,SAAS,UAAU,OAAgC,OAA4B;CAC7E,MAAM,EAAE,MAAM,QAAQ;CACtB,IACG,SAAS,UAAU,SAAS,cAC7B,OAAO,QAAQ,YACf,OAAO,KAAK,KAAK,CAAC,CAAC,MAAM,QAAQ,QAAQ,UAAU,QAAQ,KAAK,GAEhE,KAAK,sBAAsB,iCAAiC;CAG9D,MAAM,QAAQ,2BAA2B,KAAK,GAAG;CACjD,IAAI,CAAC,SAAS,OAAO,MAAM,EAAE,IAAI,GAC/B,KAAK,sBAAsB,2BAA2B;CACxD,MAAM,OAAO,OAAO,MAAM,EAAE;CAC5B,MAAM,QAAQ,OAAO,MAAM,EAAE;CAC7B,MAAM,MAAM,OAAO,MAAM,EAAE;CAE3B,MAAM,OAAO;EAAC;EADD,OAAO,MAAM,MAAM,OAAO,QAAQ,KAAK,OAAO,QAAQ,KAC1C,KAAK;EAAI;EAAI;EAAI;EAAI;EAAI;EAAI;EAAI;EAAI;EAAI;EAAI;CAAE;CACxE,IAAI,QAAQ,KAAK,QAAQ,MAAM,MAAM,KAAK,MAAM,KAAK,QAAQ,IAC3D,KAAK,sBAAsB,2BAA2B;CAExD,IAAI,YAAY;CAChB,IAAI,SAAS;MACP,CAAC,sBAAsB,KAAK,GAAG,GACjC,KAAK,sBAAsB,0BAA0B;CAAA,OAClD;EACL,IACE,CAAC,yGAAyG,KACxG,GACF,GAEA,KACE,sBACA,0DACF;EAEF,MAAM,OAAO,IAAI,KAAK,GAAG;EACzB,IAAI,CAAC,OAAO,SAAS,KAAK,QAAQ,CAAC,GACjC,KAAK,sBAAsB,sBAAsB;EACnD,YAAY,KAAK,YAAY;EAC7B,IAAI,CAAC,UAAU,KAAK,SAAS,KAAK,UAAU,WAAW,MAAM,GAC3D,KAAK,sBAAsB,mCAAmC;CAClE;CACA,MAAM,EAAE,QAAQ;CAChB,IAAI;CACJ,IAAI,IAAI,SAAS,OACf,MAAM,YAAY,WAAW,IAAI,gBAAgB,UAAU;MACxD;EACH,MAAM,IAAI,IAAI;EACd,IAAI,OAAO,KAAK,SAAS;CAC3B;CACA,IACE,IAAI,gBAAgB,cACpB,IAAI,gBAAgB,YACpB,IAAI,gBAAgB,QACpB;EAGA,IAAI,SAAS,YAAY;GACvB,MAAM,MAAM,UAAU,MAAM,GAAG,EAAE,CAAC,CAAC,QAAQ,KAAK,GAAG;GACnD,IAAI,IAAI,SAAS,OACf,MAAM,YAAY,KAAK,IAAI,gBAAgB,UAAU;QAClD,IAAI,OAAO,IAAI,OAAO,SAAS,KAAK;EAC3C;EACA,OAAO,QAAQ,IAAI,MAAM,SAAS,SAAS,SAAS,YAAY;CAClE;CACA,OAAO;AACT;AAEA,SAAS,WACP,MACA,KACA,QAAQ,GACR,SAAS,EAAE,OAAO,EAAE,GACE;CACtB,IAAI,QAAQ,aAAa,EAAE,OAAO,QAAQ,WACxC,KACE,oBACA,mDACF;CACF,IAAI,CAAC,SAAS,IAAI,GAAG,OAAO;CAC5B,IAAI,SAAS,MAAM,OAAO,IAAI,aAAa,KAAK,GAAa,KAAK;CAClE,IAAI,EAAE,QAAQ,SAAS,WAAW,MAAM;EACtC,MAAM,QAAQ,KAAK;EACnB,IAAI,UAAU,MAAM,OAAO;EAC3B,IAAI,iBAAiB,MAAM,OAAO;EAClC,IAAI,SAAS,KAAK,MAAM,MAAM,SAAS,UAAU,MAAM,SAAS,aAC9D,OAAO,MAAM;EACf,IAAI,OAAO,UAAU,UAAU,OAAO;EACtC,IAAI,OAAO,UAAU,WAAW,OAAO;EACvC,IAAI,OAAO,UAAU,UAAU,OAAO;CACxC;CACA,MAAM,KAAK,KAAK;CAChB,IACE,OAAO,OAAO,aACb,OAAO,OAAO,YAAY,EAAE,KAAK,OAAO,OAAO,YAAY,EAAE,IAE9D,OAAO,OAAO,OAAO,YAAY,EAAE,IAAI,WAAW;CAEpD,IAAI;EAAC;EAAO;EAAM;EAAO;EAAU;CAAW,CAAC,CAAC,SAAS,EAAY,GACnE,OAAO;CACT,IACE;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF,CAAC,CAAC,SAAS,EAAY,GAEvB,OAAO;CACT,IACE;EAAC;EAAU;EAAS;EAAS;EAAQ;EAAa;CAAQ,CAAC,CAAC,SAC1D,EACF,GAEA,OAAO;CACT,IAAI,OAAO,WAAW,OAAO;CAC7B,MAAM,SAAS,UAAqB;EAClC,MAAM,QAAQ,MACX,KAAK,MAAM,WAAW,GAAG,KAAK,QAAQ,GAAG,MAAM,CAAC,CAAC,CACjD,QAAQ,MAAM,MAAM,MAAM;EAC7B,OAAO,CAAC,MAAM,SACV,SACA,MAAM,OAAO,MAAM,MAAM,MAAM,EAAE,IAC/B,MAAM,KACN;CACR;CACA,IAAI,OAAO,MAAM,OAAO,MAAM,CAAC,KAAK,MAAM,KAAK,IAAI,CAAC;CACpD,IAAI,OAAO,UAAU,MAAM,QAAQ,KAAK,QAAQ,GAC9C,OAAO,MAAM,CACX,GAAG,KAAK,SAAS,KAAK,MAAO,SAAS,CAAC,IAAI,EAAE,OAAO,KAAA,CAAU,GAC9D,KAAK,IACP,CAAC;CACH,IAAI,OAAO,cAAc,MAAM,QAAQ,KAAK,QAAQ,GAClD,OAAO,MAAM,KAAK,QAAQ;CAC5B,OAAO;AACT;AAEA,SAAS,gBAAgB,MAAe,OAA0B;CAChE,MAAM,OAAO,WAAW,MAAM,MAAM,GAAG;CACvC,IAAI,SAAS,UAAU,SAAS,cAAc,SAAS,QACrD,KACE,iBACA,+HACF;AAEJ;;AAGA,SAAS,WACP,MACA,KACA,KACA,KACQ;CACR,IACE,SAAS,IAAI,KACb,EAAE,QAAQ,SACV,WAAW,QACX,KAAK,UAAU;MAGb,OAAO,KAAK,UAAU,YACtB,CAAC,OAAO,UAAU,KAAK,KAAK,KAC5B,KAAK,QAAQ,OACb,KAAK,QAAQ,KAEb,KAAK,sBAAsB,gCAAgC,IAAI,IAAI,KAAK;CAAA;CAG5E,OAAO,aAAa,IAAI,WAAW,IAAI,OAAO,IAAI,kBAAkB,IAAI,UAAU,IAAI,yBAAyB,IAAI;AACrH;AAEA,SAAS,eACP,MACA,OACA,OACoB;CACpB,MAAM,EAAE,OAAO;CACf,MAAM,KAAK,MAAM,IAAI,gBAAgB;CACrC,MAAM,OACJ,MAAM,IAAI,gBAAgB,YAAY,MAAM,IAAI,gBAAgB;CAClE,MAAM,WAAW,QACf,KACI,QAAQ,IAAI,yBACZ,OACE,QAAQ,IAAI,eACZ;CACR,MAAM,UAAU,MAAgB,SAC9B,cAAc,KAAK,KAAK,MAAM,GAAG,EAAE,SAAS,CAAC,CAAC,KAAK,MAAM,EAAE,kBAAkB,KAAK;CACpF,IAAI,OAAO,UAAU,OAAO,MAAM;EAChC,MAAM,WACJ,OAAO,OAAO,CAAC;GAAE,MAAM,KAAK;GAAW,MAAM,KAAK;EAAK,CAAC,IAAI,KAAK;EACnE,IAAI,CAAC,MAAM,QAAQ,QAAQ,KAAK,SAAS,WAAW,GAClD,KAAK,sBAAsB,6CAA6C;EAM1E,MAAM,aAAa,SALP,SAAS,KAAK,MAAM;GAC9B,IAAI,CAAC,SAAS,CAAC,GACb,KAAK,sBAAsB,gCAAgC;GAC7D,OAAO,QAAQ,MAAM,EAAE,IAAI,EAAE,QAAQ,MAAM,EAAE,IAAI;EACnD,CAC4B,CAAA,CAAI,KAAK,GAAG,EAAE,QAAQ,MAAM,KAAK,IAAI,EAAE;EACnE,OAAO,WAAW,MAAM,MAAM,GAAG,MAAM,WACnC,QAAQ,UAAU,IAClB;CACN;CACA,IAAI,OAAO,WAAW,OAAO,cAAc,OAAO,UAAU;EAC1D,IACE,CAAC,MAAM,QAAQ,KAAK,QAAQ,KAC5B,KAAK,SAAS,UAAU,OAAO,WAAW,IAAI,IAE9C,KACE,sBACA,GAAG,GAAG,qBAAqB,OAAO,WAAW,IAAI,EAAE,UACrD;EACF,MAAM,OAAO,KAAK,SAAS,IAAI,KAAK;EACpC,IAAI,OAAO,UAAU,OAAO,IAAI,KAAK,KAAK,MAAM,EAAE;EAGlD,OAAO,QAAQ,OAAO,MAAM,GAD1B,CAAC,MAAM,CAAC,OAAQ,OAAO,UAAU,QAAQ,QAAS,GAAG,YAAY,EACjC,GAAG,KAAK,KAAK,IAAI,EAAE,EAAE,CAAC;CAC1D;CACA,IAAI,OAAO,OAAO;EAChB,MAAM,OAAO,MAAM,KAAK,IAAI,GAC1B,QAAQ,MAAM,KAAK,KAAK;EAG1B,MAAM,WAAW,KAAK,KAAK,mBAAmB,MAAM;EAKpD,OAAO,QACL,IAAI,KAAK,gBAAgB,SAAS,YAJlC,CAAC,MAAM,CAAC,OAAO,eAAe,UAAU,MAAM,IAAI,QAAQ,SAAS,GAIhB,QAFnD,CAAC,MAAM,CAAC,OAAO,eAAe,UAAU,OAAO,IAAI,SAAS,SAAS,GAEJ,UAAU,MAAM,EACnF;CACF;CACA,IAAI,OAAO,SAAS;EAClB,MAAM,QAAQ,MAAM,KAAK,KAAK,GAC5B,YAAY,MAAM,KAAK,MAAM;EAC/B,MAAM,SAAS,WAAW,KAAK,QAAQ,WAAW,KAAK,EAAE;EACzD,IAAI,IACF,OAAO,mBAAmB,MAAM,iBAAiB,OAAO;EAC1D,IAAI,MAAM,OAAO,cAAc,MAAM,gBAAgB,OAAO;EAE5D,MAAM,SAAS,UAAU,OAAO,IAAI,MAAM,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,SAAS,IAAI,EAAE,QAAQ,OAAO,IAAI,IAAI,CAAC,CAAC,KAAK,GAAG,EAAE;EAC3H,OAAO,eAAe,OAAO,oBAAoB,MAAM,YAAY,OAAO,SAAS,OAAO,cAAc,MAAM,KAAK,OAAO;CAC5H;CACA,IAAI,OAAO,aAAa;EACtB,MAAM,QAAQ,MAAM,KAAK,KAAK,GAC5B,QAAQ,MAAM,KAAK,KAAK,GACxB,SAAS,MAAM,KAAK,MAAM;EAC5B,OAAO,UAAU,MAAM,KAAK,WAAW,KAAK,OAAO,OAAO,GAAG,UAAU,EAAE,MAAM,WAAW,KAAK,QAAQ,QAAQ,GAAG,UAAU,EAAE;CAChI;CACA,IAAI,OAAO,eAAe;EACxB,IAAI,MAAM,IAAI,SAAS,OAAO;GAC5B,gBAAgB,KAAK,OAAO,KAAK;GACjC,gBAAgB,KAAK,SAAS,KAAK;EACrC;EACA,MAAM,QAAQ,MAAM,KAAK,KAAK,GAC5B,UAAU,MAAM,KAAK,OAAO;EAC9B,IAAI,MAAM,MACR,OAAO,cAAc,MAAM,mBAAmB,QAAQ,gBAAgB,KAAK,qBAAqB,SAAS;EAC3G,OAAO,mBAAmB,MAAM,sBAAsB,QAAQ;CAChE;CACA,IAAI,OAAO,WAAW;EACpB,IAAI,MAAM,IAAI,SAAS,OAAO,gBAAgB,KAAK,OAAO,KAAK;EAC/D,MAAM,QAAQ,MAAM,KAAK,KAAK,GAC5B,UAAU,MAAM,KAAK,IAAI;EAC3B,MAAM,OAAO,WAAW,KAAK,MAAM,SAAS,QAAS,KAAM;EAC3D,MAAM,QACJ,MAAM,OACF,SAAS,MAAM,eAAe,KAAK,MACnC,QAAQ,MAAM,UAAU,KAAK;EAGnC,MAAM,SAAS,QACb,MAAM,OAAO,SAAS,IAAI,cAAc,IAAI,IAAI;EAClD,OAAO,cAAc,MAAM,WAAW,MAAM,YAAY,EAAE,OAAO,MAAM,YAAY,EAAE,QAAQ,MAAM;CACrG;CACA,IAAI,OAAO,UAAU,OAAO,WAAW,OAAO,OAAO;EACnD,IAAI,MAAM,IAAI,SAAS,OAAO,gBAAgB,KAAK,OAAO,KAAK;EAC/D,MAAM,QAAQ,MAAM,KAAK,KAAK;EAC9B,IAAI,MAAM,MACR,OAAO,gBAAgB,GAAG,YAAY,EAAE,aAAa,MAAM;EAC7D,OAAO,kBAAkB,OAAO,SAAS,OAAO,OAAO,UAAU,OAAO,KAAK,KAAK,MAAM;CAC1F;CACA,IAAI,OAAO,WAAW,OAAO,SAAS;EAGpC,IAAI,QAAQ,MAAM,KAAK,KAAK;EAC5B,IAAI,IACF,OAAO,aAAa,MAAM,KAAK,OAAO,UAAU,+BAA+B,6BAA6B,MAAM,OAAO,UAAU,+BAA+B,6BAA6B;EACjM,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK;GAC3B,MAAM,QAAQ,OAAO,aAAa,KAAK,CAAC,GACtC,QAAQ,OAAO,aAAa,KAAK,CAAC;GACpC,QAAQ,WAAW,QAAQ,KAAK,mBAAiB,GAAG,IAAI,YAAY,OAAO,UAAU,QAAQ,OAAO,EAAE,EAAE,IAAI,YAAY,OAAO,UAAU,QAAQ,OAAO,EAAE,EAAE;EAC9J;EACA,OAAO;CACT;CACA,KAAK,OAAO,WAAW,OAAO,WAAW,CAAC,MAAM,CAAC,MAC/C,OAAO,eAAe,MAAM,KAAK,KAAK,GAAG,EAAE;CAC7C,IACE,OAAO,SACP,OAAO,WACP,OAAO,UACP,OAAO,UACP,OAAO,UAEP,OAAO;EAAC;EAAO;EAAS;CAAM,CAAC,CAAC,SAAS,EAAE,IACvC,QAAQ,GAAG,GAAG,YAAY,EAAE,GAAG,MAAM,KAAK,KAAK,EAAE,EAAE,IACnD,GAAG,GAAG,YAAY,EAAE,GAAG,MAAM,KAAK,KAAK,EAAE;AAEjD;;AAkBA,SAAgB,mBACd,MACA,SACwB;CACxB,IACE,CAAC;EAAC;EAAU;EAAY;EAAU;CAAM,CAAC,CAAC,SAAS,QAAQ,OAAO,KAClE,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,SAAS,QAAQ,IAAI,GAEvC,KAAK,sBAAsB,oCAAoC;CACjE,MAAM,0BAAU,IAAI,IAGlB;CACF,MAAM,WAAW,SAAiB;EAChC,IAAI,OAAO,SAAS,YAAY,CAAC,KAAK,UAAU,KAAK,SAAS,IAAI,GAChE,KAAK,sBAAsB,2BAA2B;EACxD,IAAI,SAAS,QAAQ,IAAI,IAAI;EAC7B,IAAI,CAAC,QAAQ;GACX,MAAM,QAAQ,QAAQ,gBAAgB,IAAI,KAAK;GAC/C,SACE,OAAO,UAAU,WAAW;IAAE,MAAM;IAAO,MAAM;GAAU,IAAI;GACjE,IACE,CAAC,UACD,OAAO,OAAO,SAAS,YACvB,CAAC,OAAO,KAAK,UACb,OAAO,KAAK,SAAS,IAAI,KACzB,OAAO,KAAK,MAAM,GAAG,CAAC,CAAC,MAAM,MAAM,CAAC,CAAC,GAErC,KAAK,sBAAsB,oCAAoC;GACjE,QAAQ,IAAI,MAAM,MAAM;EAC1B;EACA,OAAO;CACT;CACA,MAAM,MAAyB;EAC7B,aAAa,QAAQ;EACrB,WAAW;EACX,QAAQ,CAAC;EACT,MAAM,QAAQ;EACd,aAAa,SACX,QAAQ,IAAI,CAAC,CAAC,KAAK,MAAM,GAAG,CAAC,CAAC,IAAI,sBAAsB,CAAC,CAAC,KAAK,GAAG;EACpE,aAAa,SAAS,QAAQ,IAAI,CAAC,CAAC;CACtC;CACA,MAAM,MAAM,0BAA0B,MAAM,GAAG;CAG/C,MAAM,YAAY;EAAE,QAAQ;EAAM,UAAU;EAAM,QAAQ;CAAK;CAC/D,KAAK,MAAM,WAAW;EAAC;EAAU;EAAY;CAAQ,GACnD,IAAI;EACF,0BAA0B,MAAM;GAC9B,GAAG;GACH,aAAa;GACb,MAAM;GACN,WAAW;GACX,QAAQ,CAAC;GACT,WAAW;GACX,SAAS;EACX,CAAC;CACH,SAAS,OAAO;EACd,IAAI,iBAAiB,mBAAmB,MAAM,SAAS,iBACrD,UAAU,WAAW;OAClB,MAAM;CACb;CAEF,IAAI,QAAQ,SAAS,SAAS,CAAC,OAAO,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,GACnE,KACE,iBACA,iEACF;CACF,OAAO;EACL;EACA,QAAQ,IAAI;EACZ,YAAY,WAAW,MAAM,GAAG;EAChC;CACF;AACF;AAIA,SAAS,eAAe,OAAe,IAA8B;CACnE,MAAM,QAAQ,QAAQ,MAAM;CAC5B,OAAO,cAAc,MAAM,0BAA0B,MAAM,6BAA6B,MAAM,QAAQ,MAAM,GAAG,OAAO,UAAU,MAAM,IAAI,GAAG,MAAM,QAAQ,MAAM,GAAG,OAAO,UAAU,MAAM,IAAI,UAAU,MAAM;AACjN;AACA,SAAS,gBAAgB,OAAuB;CAC9C,MAAM,QAAQ,MAAc,UAC1B,0BAA0B,KAAK,QAAQ,MAAM,0BAA0B,MAAM;CAC/E,OAAO,IAAI,KAAK,QAAQ,CAAC,EAAE,aAAa,KAAK,SAAS,CAAC,EAAE,aAAa,KAAK,OAAO,CAAC,EAAE;AACvF;AAEA,IAAM,kBAA4C;CAChD,MAAM,CAAC,YAAY,MAAM;CACzB,IAAI;EAAC;EAAa;EAAQ;CAAM;CAChC,OAAO,CAAC,SAAS,QAAQ;CACzB,KAAK,CAAC,OAAO;CACb,OAAO,CAAC,OAAO;CACf,MAAM,CAAC,OAAO;CACd,OAAO,CAAC,OAAO;CACf,OAAO,CAAC,OAAO;CACf,MAAM,CAAC,OAAO;CACd,QAAQ,CAAC,OAAO;CAChB,MAAM,CAAC,OAAO;CACd,OAAO,CAAC,OAAO;CACf,KAAK,CAAC,OAAO;CACb,OAAO,CAAC,UAAU;CAClB,UAAU,CAAC,UAAU;CACrB,QAAQ,CAAC,UAAU;CACnB,KAAK,CAAC,QAAQ,OAAO;CACrB,WAAW;EAAC;EAAS;EAAS;CAAQ;CACtC,aAAa,CAAC,SAAS,SAAS;CAChC,SAAS,CAAC,SAAS,MAAM;AAC3B;AACA,SAAS,cAAc,MAAqC;CAC1D,IAAI;CACJ,IAAI,EAAE,QAAQ,OAAO,SAAS,SAAS,OAAO,CAAC,KAAK,IAAI,CAAC,OAAO;MAC3D;EACH,MAAM,KAAK,KAAK;EAChB,IAAI,OAAO,OAAO,UAChB,KAAK,sBAAsB,iCAAiC;EAC9D,IAAI,OAAO,OAAO,iBAAiB,EAAE,GACnC,SAAS,CAAC,MAAM,GAAG,gBAAgB,GAAG;OACnC,IAAI,OAAO,OAAO,YAAY,EAAE,KAAK,OAAO,OAAO,YAAY,EAAE,GACpE,SAAS;GAAC;GAAM;GAAQ;EAAO;OAC5B,IAAI,OAAO,kBAAkB,SAAS;GAAC;GAAM;GAAS;EAAS;OAC/D,IAAI;GAAC;GAAO;GAAM;EAAU,CAAC,CAAC,SAAS,EAAE,GAC5C,SAAS,CAAC,MAAM,UAAU;OACvB,IAAI;GAAC;GAAO;GAAU;GAAa;EAAQ,CAAC,CAAC,SAAS,EAAE,GAC3D,SAAS,CAAC,MAAM,SAAS;OAEzB,KACE,sBACA,8CAA8C,IAChD;CACJ;CACA,IACE,OAAO,MAAM,QAAQ,CAAC,OAAO,OAAO,MAAM,GAAG,CAAC,KAC9C,OAAO,KAAK,IAAI,CAAC,CAAC,MAAM,QAAQ,CAAC,OAAO,SAAS,GAAG,CAAC,GAErD,KAAK,sBAAsB,0CAA0C;CACvE,IAAI,KAAK,OAAO,UAAU,MAAM,QAAQ,KAAK,QAAQ;OAC9C,MAAM,KAAK,KAAK,UACnB,IACE,CAAC,SAAS,CAAC,KACX,OAAO,KAAK,CAAC,CAAC,CAAC,WAAW,KAC1B,CAAC,OAAO,OAAO,GAAG,MAAM,KACxB,CAAC,OAAO,OAAO,GAAG,MAAM,GAExB,KAAK,sBAAsB,qCAAqC;CAAA;AAExE;AAEA,SAAS,gBACP,MACA,KACA,KACQ;CACR,KACG,IAAI,gBAAgB,cACnB,IAAI,gBAAgB,YACpB,IAAI,gBAAgB,WACtB,WAAW,MAAM,GAAG,MAAM,QAE1B,OAAO,QAAQ,IAAI;CACrB,OAAO;AACT;;;AC12BA,IAAM,wCAAwB,IAAI,IAAI;CAAC;CAAS;CAAO;CAAO;CAAO;AAAK,CAAC;AAC3E,IAAM,mCAAmB,IAAI,IAAI,CAAC,OAAO,MAAM,CAAC;AAChD,IAAM,qCAAqB,IAAI,IAA6B;CAC1D;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,SAAS,yBAAyB,YAAoB;CACpD,IAAI,wBAAwB,UAAU,GACpC,OAAO,WAAW,MAAM,GAAG,CAAC,CAAC,KAAK,UAAU;EAAE;EAAM,OAAO;CAAM,EAAE;CAErE,OAAO,gBAAgB,UAAU;AACnC;AAEA,SAAS,sBAAsB,YAA4B;CACzD,yBAAyB,UAAU;CACnC,OAAO;AACT;AAEA,SAAS,0BACP,YACA,aACA,SACQ;CACR,OAAO,wBAAwB,UAAU,IACrC,aACA,iBAAiB,YAAY,aAAa,OAAO;AACvD;AAEA,SAAS,iBAAiB,aAA8C;CACtE,OAAO,eAAe;AACxB;AAEA,SAAS,YAAY,OAAuB;CAC1C,OAAO,IAAI;AACb;AAEA,SAAgB,WACd,aACA,MACA,QACA,UAA6B,CAAC,GACtB;CACR,IAAI,CAAC,mBAAmB,IAAI,IAAI,GAC9B,MAAM,IAAI,MAAM,kCAAkC,MAAM;CAG1D,MAAM,MAAM,0BAA0B,QAAQ,aAAa,OAAO;CAClE,MAAM,UAAU,iBAAiB,WAAW;CAE5C,IAAI,YAAY,cAAc,YAAY,YAAY,YAAY,QAChE,OAAO,eAAe,KAAK,KAAK,IAAI;CAGtC,QAAQ,MAAR;EACE,KAAK,UACH,OAAO,iCAAiC,IAAI;EAC9C,KAAK,QACH,OAAO,iCAAiC,IAAI;EAC9C,KAAK,OACH,OAAO,iCAAiC,IAAI;EAC9C,KAAK,QACH,OAAO,sCAAsC,IAAI,4CAA4C,IAAI;EACnG,KAAK,SACH,OAAO,iCAAiC,IAAI;EAC9C,KAAK,WACH,OAAO,sDAAsD,IAAI,4CAA4C,IAAI;EACnH,KAAK,QACH,OAAO,iCAAiC,IAAI;CAChD;AACF;AAYA,SAAS,YAAY,OAAmB,QAAwB;CAC9D,MAAM,EAAE,UAAU;CAClB,MAAM,QAAQ,yBAAyB,MAAM;CAC7C,IAAI,SAAS,MAAM,SAAS;MACtB,MAAM,WAAW,KAAK,CAAC,MAAM,IAAI,MAAM,EAAE,CAAC,IAAI,GAChD,MAAM,IAAI,MACR,oBAAoB,OAAO,qDAC7B;CAAA;CAGJ,OAAO;AACT;AAEA,SAAS,eAAe,OAAmB,QAAwB;CACjE,YAAY,OAAO,sBAAsB,MAAM,CAAC;CAChD,OAAO,MAAM,IAAI,WAAW,MAAM;AACpC;AAEA,SAAS,iBAAiB,OAAmB,MAAgC;CAC3E,OAAO,0BAA0B,MAAM,MAAM,GAAG;AAClD;AAEA,SAAS,oBACP,MACA,OACQ;CACR,MAAM,eAAe,OAAO,KAAK,EAAE,CAAC,CAAC,YAAY;CACjD,MAAM,eAAe,OAAO,KAAK,EAAE;CACnC,IAAI,CAAC,mBAAmB,KAAK,YAAY,GACvC,MAAM,IAAI,MAAM,2BAA2B,cAAc;CAC3D,MAAM,KAAK,aAAa,YAAY;CACpC,IAAI,KAAK,WAAW,KAAA,KAAa,KAAK,SAAS,KAAA,GAC7C,MAAM,IAAI,MAAM,aAAa,KAAK,GAAG,qCAAqC;CAI5E,KACG,KAAK,SAAS,KAAA,KAAa,KAAK,WAAW,KAAA,MAC5C,CAAC,sBAAsB,IAAI,YAAY,GAEvC,MAAM,IAAI,MACR,aAAa,KAAK,GAAG,gEACvB;CAEF,MAAM,cAAc,QAAQ,KAAK,MAAM,KAAK,KAAK,SAAS,KAAA;CAE1D,MAAM,SACJ,KAAK,WAAW,KAAA,IACZ,iBAAiB,OAAO,KAAK,MAAM,IACnC,KAAA;CAEN,IAAI,iBAAiB,WAAW,CAAC,aAAa;EAC5C,IAAI,KAAK,UACP,MAAM,IAAI,MAAM,aAAa,KAAK,GAAG,iCAAiC;EAExE,OAAO,SAAS,mBAAmB,OAAO,gBAAgB;CAC5D;CACA,IAAI,CAAC,aACH,MAAM,IAAI,MAAM,aAAa,KAAK,GAAG,mBAAmB;CAE1D,MAAM,WACJ,KAAK,SAAS,KAAA,IACV,iBAAiB,OAAO,KAAK,IAAI,IACjC,eAAe,OAAO,KAAK,MAAgB;CAKjD,OAAO,GAAG,GAAG,GAJI,KAAK,WAAW,cAAc,KAGjC,SAAS,aAAa,OAAO,QAAQ,SAAS,QAAQ,SACnC;AACnC;AAEA,SAAS,iBACP,MACA,aACA,OAMA;CACA,IACE;EAAC,QAAQ;EAAM,UAAU,QAAQ,EAAE,QAAQ;EAAO,YAAY;CAAI,CAAC,CAAC,OAClE,OACF,CAAC,CAAC,SAAS,GAEX,MAAM,IAAI,MAAM,iDAAiD;CAEnE,IAAI,QAAQ,MAGV,OAAO;EAAE,YAFU,oBAAoB,MAAM,KAEpC;EAAY,OADP,sBAAsB,KAAK,EACpB;EAAO,mBAAmB;EAAO,UAAU;CAAM;CAExE,IAAI,UAAU,MAGZ,OAAO;EAAE,YAFU,iBAAiB,OAAO,KAAK,IAEvC;EAAY,OADP,sBAAsB,KAAK,EACpB;EAAO,mBAAmB;EAAM,UAAU;CAAK;CAEtE,IAAI,YAAY,QAAQ,EAAE,YAAY,OAWpC,OAAO;EACL,YAXa,eAAe,OAAO,KAAK,MAW5B;EACZ,OAVY,sBACZ,KAAK,aACI;GACL,MAAM,OAAO,yBAAyB,KAAK,MAAM,CAAC,CAAC,GAAG,EAAE;GACxD,IAAI,CAAC,MAAM,MAAM,IAAI,MAAM,2BAA2B,KAAK,QAAQ;GACnE,OAAO,KAAK,QAAQ,uBAAuB,KAAK,IAAI,IAAI,KAAK;EAC/D,EAAA,CAAG,CAIL;EACA,mBAAmB;EACnB,UAAU;CACZ;CAEF,MAAM,SAAU,KAA4B;CAC5C,eAAe,OAAO,MAAM;CAC5B,MAAM,SAAU,KAA6C;CAG7D,OAAO;EAAE,YAFU,WAAW,aAAa,QAAQ,QAAQ,MAAM,OAExD;EAAY,OADP,sBAAuB,KAAwB,EACxC;EAAO,mBAAmB;EAAM,UAAU;CAAM;AACvE;AAEA,SAAS,gBACP,KACA,mBACA,YACQ;CAGR,IAAI,aAAa,GAAG,CAAC,CAAC,OAAO,OAAO;CAEpC,MAAM,SAAS,kBAAkB,GAAG;CAOpC,OAAO,IAAI,GALT,kBAAkB,IAAI,OAAO,KAAK,KAAK,WAAW,OAAO,KAAK,EAKvC,GAAG,OAAO,UAAU;AAC/C;AAEA,SAAS,aACP,QACA,mBACA,YACa;CACb,MAAM,mBAAmB,cACvB,OAAO,YACL,OAAO,QAAQ,SAAS,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CAC9C,gBAAgB,KAAK,mBAAmB,UAAU,GAClD,KACF,CAAC,CACH;CACF,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,KAAK,aACjB,SAAS,KAAK,cACZ,gBAAgB,SAAS,CAC3B,CACF;CAGF,OAAO,gBAAgB,MAAM;AAC/B;AAEA,SAAS,YACP,QACA,mBACA,YACA,aACA,YACsB;CACtB,IAAI,CAAC,QAAQ,OAAO;EAAE,KAAK;EAAI,QAAQ,CAAC;CAAE;CAE1C,MAAM,QAAQ,WADG,aAAa,QAAQ,mBAAmB,UAChC,GAAU,YAAY,WAAW;CAE1D,OAAO;EACL,KAAK,MAAM,MAAM,MAAM,IAAI,QAAQ,UAAU,QAAQ,IAAI;EACzD,QAAQ,MAAM;CAChB;AACF;AAEA,SAAS,aACP,SACA,OACA,SACQ;CACR,IAAI,CAAC,SAAS,OAAO;CAmBrB,OAAO,aAlBO,MAAM,QAAQ,OAAO,IAAI,UAAU,CAAC,OAAO,EAAA,CACrC,KAAK,SAAS;EAGhC,MAAM,QAAQ,6CAA6C,KACzD,KAAK,KAAK,CACZ;EACA,MAAM,QAAQ,QAAQ,MAAM,KAAK,KAAK;EACtC,MAAM,YAAY,QAAQ,MAAM;EAChC,MAAM,sBAAsB,UAAU,YAAY;EAClD,IAAI,CAAC,iBAAiB,IAAI,mBAAmB,GAC3C,MAAM,IAAI,MAAM,sCAAsC,WAAW;EAKnE,OAAO,GAHW,QAAQ,IAAI,KAAK,IAC/B,MAAM,WAAW,KAAK,IACtB,eAAe,OAAO,KAAK,EACX,GAAG;CACzB,CACmB,CAAA,CAAM,KAAK,IAAI;AACpC;AAEA,IAAM,mCAAmB,IAAI,IAAI,CAAC,SAAS,MAAM,CAAC;AAClD,IAAM,aAAa;AAEnB,SAAS,WACP,WACA,OACA,MACyB;CACzB,IAAI,MAAM,WAAW,KAAK,cAAc,KAAA,GAAW,OAAO,KAAA;CAC1D,MAAM,wBAAQ,IAAI,IAAY;CAC9B,MAAM,SAAS,MAAc,SAAiB;EAE5C,IAAI,OAAO,SAAS,YAAY,CAAC,WAAW,KAAK,IAAI,GACnD,MAAM,IAAI,MAAM,qBAAqB,KAAK,IAAI,MAAM;EAEtD,IAAI,MAAM,IAAI,IAAI,GAChB,MAAM,IAAI,MAAM,4CAA4C,MAAM;EAEpE,MAAM,IAAI,IAAI;CAChB;CACA,IAAI,cAAc,KAAA,GAChB,MAAM,WAAW,YAAY;MACxB;EACL,IAAI,KAAK,SAAS,GAAG,GACnB,MAAM,IAAI,MACR,gFACF;EAEF,MAAM,MAAM,YAAY;CAC1B;CACA,KAAK,MAAM,QAAQ,OACjB,MAAM,KAAK,OAAO,YAAY;CAEhC,OAAO;AACT;AAEA,SAAS,QAAQ,OAAmB,OAAkC;CACpE,OAAO,MAAM,KAAK,SAAS;EACzB,MAAM,OAAO,KAAK,QAAQ;EAC1B,IAAI,CAAC,iBAAiB,IAAI,IAAI,GAC5B,MAAM,IAAI,MAAM,gCAAgC,MAAM;EAExD,IAAI,KAAK,OAAO,KAAA,GACd,MAAM,IAAI,MAAM,kBAAkB,KAAK,MAAM,0BAA0B;EAEzE,MAAM,QAAQ,MAAM,WAAW,KAAK,KAAK;EACzC,MAAM,QAAQ,KAAK;EACnB,IAAI,OAAO,UAAU,YAAY,CAAC,WAAW,KAAK,KAAK,GACrD,MAAM,IAAI,MAAM,iCAAiC,OAAO,KAAK,GAAG;EAElE,MAAM,KAAK,iBAAiB,OAAO,KAAK,EAAE;EAC1C,OAAO,GAAG,SAAS,SAAS,SAAS,QAAQ,QAAQ,MAAM,MAAM,MAAM,WAAW,KAAK,EAAE,MAAM;CACjG,CAAC;AACH;AAEA,SAAgB,eACd,MACA,aAAa,GACb,aACA,UAA6B,CAAC,GACR;CACtB,MAAM,OAAO,sBAAsB,KAAK,IAAI;CAC5C,IAAI,KAAK,OAAO,WAAW,GACzB,MAAM,IAAI,MACR,2DACF;CAEF,IAAI,KAAK,UAAU,KAAA,KAAa,CAAC,MAAM,QAAQ,KAAK,KAAK,GACvD,MAAM,IAAI,MAAM,sCAAsC;CAKxD,MAAM,SAAgB,CAAC;CACvB,MAAM,MAAyB;EAC7B;EACA,WAAW;EACX;EACA,aAAa,SAAS,0BAA0B,MAAM,aAAa,OAAO;CAC5E;CAEA,MAAM,YAAY,KAAK;CACvB,MAAM,SAA0B,KAAK,SAAS,CAAC,EAAA,CAAG,KAAK,UAAU;EAC/D,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,MAAM,KAAK;EACX,IAAI,KAAK;CACX,EAAE;CACF,MAAM,QAAoB;EACxB;EACA,aAAa,SAAS,iBAAiB,MAAM,aAAa,OAAO;EACjE,OAAO,WAAW,WAAW,OAAO,IAAI;EACxC;CACF;CACA,IAAI,YAAY,WAAW;EACzB,YAAY,OAAO,MAAM;CAC3B;CAEA,MAAM,oCAAoB,IAAI,IAAoB;CAClD,MAAM,iCAAiB,IAAI,IAAoB;CAC/C,MAAM,kBAA4B,CAAC;CACnC,MAAM,YAAY,KAAK,OAAO,KAAK,MAAM,aAAa;EACpD,MAAM,WAAW,iBAAiB,MAAM,aAAa,KAAK;EAC1D,IAAI,kBAAkB,IAAI,SAAS,KAAK,GACtC,MAAM,IAAI,MAAM,qCAAqC,SAAS,OAAO;EAEvE,kBAAkB,IAAI,SAAS,OAAO,SAAS,UAAU;EAGzD,IAAI,SAAS,UAAU,eAAe,IAAI,SAAS,OAAO,WAAW,CAAC;EACtE,IAAI,SAAS,mBACX,gBAAgB,KAAK,SAAS,KAAK;EAErC,OAAO,GAAG,SAAS,WAAW,MAAM,MAAM,WAAW,SAAS,KAAK;CACrE,CAAC;CAED,MAAM,YAAY,QAAQ,OAAO,KAAK;CAEtC,MAAM,QAAQ,KAAK,QACf,WAAW,KAAK,OAAO,IAAI,WAAW,aAAa,OAAO,IAC1D;EAAE,KAAK;EAAI,QAAQ,CAAC;CAAE;CAC1B,OAAO,KAAK,GAAG,MAAM,MAAM;CAC3B,IAAI,aAAa,MAAM,OAAO;CAE9B,IAAI,WAAW,MAAM;CACrB,IAAI,KAAK,cAAc,KAAA,GAAW;EAChC,MAAM,YAAY,iBAAiB,OAAO,KAAK,SAAS;EAExD,WAAW,WACP,UAAU,SAAS,QAAQ,WAAW,EAAE,EAAE,QAAQ,cAClD,SAAS;CACf;CAEA,MAAM,eAAe,KAAK,WAAW;CACrC,MAAM,aACJ,aAAa,SAAS,IAClB,YAAY,aACT,KAAK,SACJ,eAAe,IAAI,IAAI,IACnB,OAAO,eAAe,IAAI,IAAI,CAAC,IAC/B,kBAAkB,IAAI,IAAI,IACxB,kBAAkB,IAAI,IAAI,IAC1B,eAAe,OAAO,IAAI,CAClC,CAAC,CACA,KAAK,IAAI,MACZ;CAEN,MAAM,SAAS,YACb,KAAK,QACL,mBACA,IAAI,WACJ,aACA,IAAI,UACN;CACA,OAAO,KAAK,GAAG,OAAO,MAAM;CAC5B,IAAI,aAAa,OAAO,OAAO;CAE/B,MAAM,aAAa,aACjB,KAAK,SACL,OACA,IAAI,IAAI,kBAAkB,KAAK,CAAC,CAClC;CAEA,MAAM,YAAsB,CAAC;CAC7B,IAAI,KAAK,UAAU,KAAA,GAAW;EAC5B,UAAU,KAAK,SAAS,YAAY,IAAI,WAAW,GAAG;EACtD,OAAO,KAAK,KAAK,KAAK;CACxB,OAAO,IACL,KAAK,WAAW,KAAA,KAChB,iBAAiB,WAAW,MAAM,UAElC,UAAU,KAAK,UAAU;CAE3B,IAAI,KAAK,WAAW,KAAA,GAAW;EAC7B,UAAU,KAAK,UAAU,YAAY,IAAI,WAAW,GAAG;EACvD,OAAO,KAAK,KAAK,MAAM;CACzB;CAEA,MAAM,UACJ,KAAK,cAAc,KAAA,IACf,GAAG,MAAM,WAAW,IAAI,EAAE,MAAM,MAAM,WAAW,SAAmB,MACpE,MAAM,WAAW,IAAI;CAc3B,OAAO;EAAE,KAbG;GACV,UAAU,UAAU,KAAK,IAAI;GAC7B,QAAQ;GACR,GAAG;GACH;GACA;GACA,OAAO;GACP;GACA,UAAU,KAAK,GAAG;EACpB,CAAC,CACE,OAAO,OAAO,CAAC,CACf,KAAK,GAEC;EAAK;CAAO;AACvB;;;;;;;;;;;;;;;;;;;;;;AC3hBA,SAAgB,oBAAoB,UAAsC;CACxE,MAAM,UAAU,SAAS,KAAK;CAI9B,MAAM,QAAQ,QAAQ,MACpB,+FACF;CAEA,IAAI,CAAC,OACH,OAAO;CAGT,MAAM,GAAG,eAAe,MAAM,cAAc;CAO5C,OAAO;EACL;EACA,SANc,WACb,MAAM,GAAG,CAAC,CACV,KAAK,QAAQ,IAAI,KAAK,CAAC,CAAC,QAAQ,UAAU,EAAE,CAI7C;EACA,QAAQ,QAAQ,aAAa;EAC7B,KAAK;CACP;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,wCACd,KACA,SAIA;CACA,IAAI,CAAC,WAAW,QAAQ,WAAW,GACjC,OAAO;EAAE;EAAK,SAAS,CAAC;CAAE;CAI5B,MAAM,gBAAgB,QACnB,IAAI,mBAAmB,CAAC,CACxB,QAAQ,QAA4B,QAAQ,IAAI;CAGnD,MAAM,gBAAgB,cAAc,QAAQ,QAAQ,IAAI,MAAM;CAC9D,MAAM,iBAAiB,cAAc,QAAQ,QAAQ,CAAC,IAAI,MAAM;CAGhE,IAAI,cAAc,WAAW,GAC3B,OAAO;EAAE;EAAK;CAAQ;CAIxB,MAAM,QAAQ,IAAI,MAAM,IAAI;CAC5B,IAAI,oBAAoB;CAExB,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;EAC1C,MAAM,UAAU,MAAM,EAAE,CAAC,KAAK;EAC9B,IAAI,YAAY,OAAO,QAAQ,WAAW,IAAI,GAAG;GAC/C,oBAAoB;GACpB;EACF;CACF;CAEA,IAAI,sBAAsB,IAAI;EAE5B,QAAQ,KACN,oFACF;EACA,OAAO;GAAE;GAAK;EAAQ;CACxB;CAGA,MAAM,oBAAoB,cAAc,KAAK,QAAQ;EAEnD,OAAO,YADS,IAAI,QAAQ,IAAI,sBAAsB,CAAC,CAAC,KAAK,IAC1C,EAAQ;CAC7B,CAAC;CAGD,MAAM,gBAAgB,CAAC,GAAG,KAAK;CACX,cAAc,kBAAkB,CAAC,KAAK;CAG1D,IAAI,oBAAoB;MAElB,CADa,cAAc,oBAAoB,EAAE,CAAC,KACjD,CAAA,CAAS,SAAS,GAAG,GACxB,cAAc,oBAAoB,KAAK,cACrC,oBAAoB,EACrB,CAAC,QAAQ,QAAQ,GAAG;CAAA;CAKzB,MAAM,kBAAkB,kBAAkB,KAAK,YAAY,QAAQ;EAEjE,OAAO,MAAM,kBAAkB,SAAS,IAAI,GAAG,WAAW,KAAK;CACjE,CAAC;CAED,cAAc,OAAO,mBAAmB,GAAG,GAAG,eAAe;CAO7D,OAAO;EACL,KANqB,cAAc,KAAK,IAMnC;EACL,SAJuB,eAAe,KAAK,QAAQ,IAAI,GAI9C;CACX;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AClKA,IAAa,yBAAb,cAA4C,cAAc;CACxD,YAAY,SAAiB,SAAmC;EAC9D,MAAM,SAAS,OAAO;EACtB,KAAK,OAAO;CACd;AACF;;;;;;;;AA8bA,SAAgB,eACd,SAC4C;CAC5C,IAAI,CAAC,SAAS,OAAO,KAAA;CACrB,IAAI,OAAO,YAAY,YAAY,OAAO,QAAQ;CAClD,OAAO;AACT;;;;;;;;;;ACvcA,eAAsB,YAAY,IAAuB,WAAmB;CAC1E,OAAO,GAAG,YAAY,SAAS;AACjC;;;;;;;AAQA,SAAgB,eAAe,OAAoB;CACjD,IAAI,UAAU,MACZ,OAAO;CAET,IAAI,iBAAiB,MACnB,OAAO,IAAI,MAAM,YAAY,EAAE;CAEjC,IAAI,OAAO,UAAU,UACnB,OAAO,MAAM,SAAS;CAExB,IAAI,OAAO,UAAU,WACnB,OAAO,QAAQ,MAAM;CAGvB,OAAO,IAAI,OAAO,KAAK,CAAC,CAAC,QAAQ,MAAM,IAAI,EAAE;AAC/C;;;;;;;;AASA,SAAgB,mBAAmB,QAAwB;CAKzD,IAAI,OAAO,WAAW,YAAY,CAAC,mBAAmB,KAAK,MAAM,GAC/D,MAAM,IAAI,MAAM,wBAAwB,QAAQ;CAElD,OAAO;AACT;;;;;;;;;;AAWA,eAAsB,WAAW,SAG9B;CACD,MAAM,EAAE,IAAI,WAAW;CACvB,IAAI,CAAC,MAAM,CAAC,QACV,MAAM,IAAI,MAAM,4BAA4B;CAI9C,IAAI,GAAG,YACL,MAAM,GAAG,WAAW,MAAM;MAE1B,MAAM,IAAI,MAAM,0DAA0D;AAE9E"}
@@ -1 +0,0 @@
1
- {"version":3,"file":"schema-manager-psLzQ2yh.js","names":[],"sources":["../../src/shared/alter-utils.ts","../../src/shared/utils.ts","../../src/schema-manager.ts"],"sourcesContent":["/**\n * Shared utilities for ALTER TABLE operations\n *\n * Provides database-agnostic utilities for generating ALTER TABLE statements,\n * handling column definitions, and creating indexes.\n */\n\nimport type { ColumnDefinitionWithName, IndexDefinition } from './types.js';\n\n/**\n * Database dialect type for SQL generation\n */\nexport type DatabaseDialect = 'sqlite' | 'postgres' | 'duckdb';\n\n/**\n * Generates an ALTER TABLE ADD COLUMN statement\n *\n * @param table - Table name\n * @param column - Column definition with name\n * @param dialect - Database dialect\n * @returns SQL statement string\n *\n * @example\n * ```typescript\n * const sql = generateAddColumnStatement('users', {\n * name: 'email',\n * type: 'TEXT',\n * unique: true,\n * notNull: false\n * }, 'sqlite');\n * // Returns: \"ALTER TABLE users ADD COLUMN email TEXT UNIQUE\"\n * ```\n */\nexport function generateAddColumnStatement(\n table: string,\n column: ColumnDefinitionWithName,\n dialect: DatabaseDialect,\n): string {\n const parts: string[] = [\n renderSchemaIdentifier(column.name, dialect, { quoteIdentifiers: true }),\n column.type,\n ];\n\n // Primary key\n if (column.primaryKey) {\n parts.push('PRIMARY KEY');\n }\n\n // NOT NULL constraint\n if (column.notNull) {\n parts.push('NOT NULL');\n }\n\n // UNIQUE constraint\n if (column.unique) {\n parts.push('UNIQUE');\n }\n\n // DEFAULT clause\n if (column.defaultValue !== undefined) {\n const defaultClause = generateDefaultClause(\n column.type,\n column.defaultValue,\n );\n parts.push(`DEFAULT ${defaultClause}`);\n }\n\n // CHECK constraint\n if (column.check) {\n parts.push(`CHECK (${column.check})`);\n }\n\n // Foreign key (inline for some databases)\n if (column.foreignKey) {\n const fk = column.foreignKey;\n const fkParts = [\n `REFERENCES ${renderSchemaIdentifier(fk.table, dialect, { quoteIdentifiers: true })}(${renderIdentifierList(fk.column, dialect, { quoteIdentifiers: true })})`,\n ];\n\n if (fk.onDelete) {\n fkParts.push(`ON DELETE ${fk.onDelete}`);\n }\n\n if (fk.onUpdate) {\n fkParts.push(`ON UPDATE ${fk.onUpdate}`);\n }\n\n parts.push(fkParts.join(' '));\n }\n\n const columnDef = parts.join(' ');\n return `ALTER TABLE ${renderSchemaIdentifier(table, dialect, { quoteIdentifiers: true })} ADD COLUMN ${columnDef}`;\n}\n\n/**\n * Generates a DEFAULT clause for a column definition\n *\n * Handles proper formatting and escaping of default values based on column type.\n *\n * @param columnType - SQL column type (TEXT, INTEGER, BOOLEAN, etc.)\n * @param defaultValue - Default value to format\n * @returns Formatted default value string\n *\n * @example\n * ```typescript\n * generateDefaultClause('TEXT', 'hello'); // Returns: \"'hello'\"\n * generateDefaultClause('INTEGER', 42); // Returns: \"42\"\n * generateDefaultClause('BOOLEAN', true); // Returns: \"true\"\n * generateDefaultClause('TEXT', null); // Returns: \"NULL\"\n * ```\n */\nexport function generateDefaultClause(\n columnType: string,\n defaultValue: any,\n): string {\n if (defaultValue === null) {\n return 'NULL';\n }\n\n const typeUpper = columnType.toUpperCase();\n\n // String types - need quotes\n if (\n typeUpper.includes('TEXT') ||\n typeUpper.includes('CHAR') ||\n typeUpper.includes('VARCHAR') ||\n typeUpper.includes('STRING')\n ) {\n // Handle empty strings\n if (defaultValue === '') {\n return \"''\";\n }\n // Escape single quotes\n const escaped = String(defaultValue).replace(/'/g, \"''\");\n return `'${escaped}'`;\n }\n\n // Boolean types\n if (typeUpper.includes('BOOL')) {\n return defaultValue ? 'true' : 'false';\n }\n\n // Numeric types - no quotes\n if (\n typeUpper.includes('INT') ||\n typeUpper.includes('REAL') ||\n typeUpper.includes('FLOAT') ||\n typeUpper.includes('DOUBLE') ||\n typeUpper.includes('NUMERIC') ||\n typeUpper.includes('DECIMAL')\n ) {\n return String(defaultValue);\n }\n\n // JSON types\n if (typeUpper.includes('JSON')) {\n if (typeof defaultValue === 'string') {\n return `'${defaultValue.replace(/'/g, \"''\")}'`;\n }\n return `'${JSON.stringify(defaultValue).replace(/'/g, \"''\")}'`;\n }\n\n // Date/timestamp types\n if (\n typeUpper.includes('DATE') ||\n typeUpper.includes('TIME') ||\n typeUpper.includes('TIMESTAMP')\n ) {\n if (defaultValue instanceof Date) {\n return `'${defaultValue.toISOString()}'`;\n }\n return `'${String(defaultValue).replace(/'/g, \"''\")}'`;\n }\n\n // Default: treat as string\n if (typeof defaultValue === 'string') {\n return `'${defaultValue.replace(/'/g, \"''\")}'`;\n }\n\n return String(defaultValue);\n}\n\n/**\n * Generates a CREATE INDEX statement\n *\n * @param table - Table name\n * @param index - Index definition\n * @returns SQL CREATE INDEX statement\n *\n * @example\n * ```typescript\n * const sql = generateCreateIndexStatement('users', {\n * name: 'idx_users_email',\n * columns: ['email'],\n * unique: true\n * });\n * // Returns: \"CREATE UNIQUE INDEX idx_users_email ON users (email)\"\n * ```\n */\nexport function generateCreateIndexStatement(\n table: string,\n index: IndexDefinition,\n dialect?: DatabaseDialect,\n): string {\n const parts: string[] = ['CREATE'];\n\n // UNIQUE modifier\n if (index.unique) {\n parts.push('UNIQUE');\n }\n\n parts.push('INDEX');\n\n // Index name\n parts.push(\n renderSchemaIdentifier(index.name, dialect, { quoteIdentifiers: true }),\n );\n\n // ON table\n parts.push(\n `ON ${renderSchemaIdentifier(table, dialect, { quoteIdentifiers: true })}`,\n );\n\n // Column list\n const columns = index.columns\n .map((column) =>\n renderIndexTerm(column, dialect, { quoteIdentifiers: true }),\n )\n .join(', ');\n parts.push(`(${columns})`);\n\n // WHERE clause (partial index)\n if (index.where) {\n parts.push(`WHERE ${index.where}`);\n }\n\n return parts.join(' ');\n}\n\n/**\n * Validates a table name to prevent SQL injection\n *\n * The argument must be a primitive string. `RegExp.prototype.test` coerces its\n * argument with `toString`, so an object whose `toString` returns a valid name\n * on the call the validator makes and a different one on the call the caller's\n * `${table}` interpolation makes would pass here and then reach SQL. Rejecting\n * non-strings up front closes that gap: the value validated is the value\n * interpolated, because a primitive string cannot observe how many times it is\n * read.\n *\n * @param tableName - Table name to validate\n * @throws Error if the value is not a string or contains invalid characters\n */\nexport function validateTableName(tableName: string): void {\n if (\n typeof tableName !== 'string' ||\n !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableName)\n ) {\n throw new Error(\n `Invalid table name: ${tableName}. Table names must be a string that starts with a letter or underscore and contains only alphanumeric characters and underscores.`,\n );\n }\n}\n\n/**\n * Validates a column name to prevent SQL injection\n *\n * Rejects non-strings for the same reason as {@link validateTableName}: a value\n * whose `toString` differs between the validation read and the interpolation\n * read would otherwise slip a different identifier into SQL than the one\n * checked here.\n *\n * @param columnName - Column name to validate\n * @throws Error if the value is not a string or contains invalid characters\n */\nexport function validateColumnName(columnName: string): void {\n if (typeof columnName !== 'string' || !isColumnIdentifier(columnName)) {\n throw new Error(\n `Invalid column name: ${columnName}. Column names must be a plain identifier starting with a letter or underscore, or an explicitly double-quoted identifier.`,\n );\n }\n}\n\n/** Branch-base plain-name contract for adapter addIndex (not raw SQL terms). */\nexport function validatePlainColumnName(columnName: string): void {\n if (\n typeof columnName !== 'string' ||\n !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(columnName)\n ) {\n throw new Error(\n `Invalid column name: ${columnName}. Column names must be a string that starts with a letter or underscore and contains only alphanumeric characters and underscores.`,\n );\n }\n}\n\n/**\n * Validates every identifier in a column list to prevent SQL injection\n *\n * Column names reaching the CRUD methods come from `Object.keys(data)` and the\n * caller's `conflictColumns`, both of which are interpolated into SQL. The\n * accepted shape has no character that can end an identifier. Adapters may\n * render a validated name bare, or quote it under an adapter-specific contract.\n * PostgreSQL upsert uses {@link quotePostgresColumnName}, which canonicalizes\n * the name before quoting so its established unquoted case-folding semantics\n * do not change.\n *\n * @param columnNames - Column names to validate\n * @throws Error if any column name contains invalid characters\n */\nexport function validateColumnNames(columnNames: string[]): void {\n for (const columnName of columnNames) {\n validateColumnName(columnName);\n }\n}\n\n/**\n * Quotes a validated column name using PostgreSQL's historic case semantics.\n *\n * PostgreSQL folds every unquoted identifier to lowercase. The CRUD API has\n * always accepted mixed-case inputs while rendering them unquoted, so quoting\n * the caller's spelling directly would silently change which physical column\n * is addressed. Validate the existing plain-identifier contract first, then\n * lowercase before quoting: `mixedCase` still addresses `mixedcase`, while a\n * reserved word such as `end` is no longer parsed as SQL syntax.\n *\n * Explicit double-delimited input preserves its physical spelling.\n *\n * @param columnName - Plain or explicitly delimited column name for PostgreSQL\n * @returns A double-quoted identifier, folding only undelimited input\n * @throws Error if the column name is outside the CRUD identifier contract\n */\nexport function quotePostgresColumnName(columnName: string): string {\n validateColumnName(columnName);\n return renderIdentifier(columnName, 'postgres', { quoteIdentifiers: true });\n}\n\n/**\n * Escapes an identifier for interpolation inside double quotes\n *\n * For the positions that already quote the identifier — the DuckDB and JSON\n * upsert statements, which quote to match their schema generator — quoting is\n * what makes the identifier safe, so the only thing that has to be handled is\n * a quote character inside the name. Doubling it is the SQL escape.\n *\n * This is deliberately more permissive than {@link validateColumnName}: those\n * adapters accept column names that are not plain identifiers (`Full Name`,\n * `user-id`, `2024_total`), which matters most for the JSON adapter, whose\n * columns come straight from the keys of whatever JSON it was pointed at.\n * Rejecting them would break working code to fix an injection that quoting\n * already prevents.\n *\n * @param identifier - Identifier to place inside SQL identifier quotes\n * @param quote - Identifier delimiter (double quote, or SQLite backtick)\n * @returns The identifier with embedded delimiter characters doubled\n * @throws Error if the identifier is empty or contains a NUL byte\n */\nexport function escapeQuotedIdentifier(\n identifier: string,\n quote: '\"' | '`' = '\"',\n): string {\n // Coerce to a primitive string first. The escape's safety rests on\n // `replaceAll`/`includes` being the real `String` methods, but a crafted\n // object could supply its own that return unescaped SQL while its `toString`\n // reads as a benign name elsewhere. Coercing once runs its `toString` here\n // and pins an immutable primitive for the length check and the escape, so the\n // value escaped is the value returned.\n const value = String(identifier);\n if (value.length === 0 || value.includes('\\0')) {\n throw new Error(\n `Invalid column name: ${JSON.stringify(value)}. Column names must be non-empty and must not contain a NUL byte.`,\n );\n }\n return value.replaceAll(quote, quote + quote);\n}\n\n/**\n * Escapes a value for interpolation inside a single-quoted SQL string literal\n *\n * The DuckDB-backed adapters read JSON through `read_json_auto('<path>')`, and\n * a file path is not something an identifier validator can check — paths\n * legitimately contain spaces, dots and, on Linux and macOS, quotes. Doubling\n * the quote is the SQL escape, and it is what keeps a file named `x'.json`\n * from ending the literal and starting a statement.\n *\n * @param value - Value to place inside single quotes\n * @returns The value with embedded single quotes doubled\n * @throws Error if the value contains a NUL byte\n */\nexport function escapeStringLiteral(value: string): string {\n // Coerce to a primitive string first, for the same reason as\n // {@link escapeQuotedIdentifier}: the escape must run on an immutable\n // primitive, not on an object that could supply its own `replaceAll`.\n const text = String(value);\n if (text.includes('\\0')) {\n throw new Error(\n `Invalid SQL string literal: ${JSON.stringify(text)}. Values must not contain a NUL byte.`,\n );\n }\n return text.replaceAll(\"'\", \"''\");\n}\n\n/**\n * Validates an index name to prevent SQL injection\n *\n * @param indexName - Index name to validate\n * @throws Error if index name contains invalid characters\n */\nexport function validateIndexName(indexName: string): void {\n if (\n typeof indexName !== 'string' ||\n !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(indexName)\n ) {\n throw new Error(\n `Invalid index name: ${indexName}. Index names must be a string that starts with a letter or underscore and contains only alphanumeric characters and underscores.`,\n );\n }\n}\n\n/** Numeric SQL tokens accepted by the original WHERE/aggregate character grammar.\n * This is a bounded compatibility exception, never a general expression channel.\n */\nexport function isLegacyNumericSqlToken(value: string): boolean {\n return (\n typeof value === 'string' &&\n /^(?:0[xX][0-9a-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|(?:[0-9][0-9_]*(?:\\.[0-9_]*)?|\\.[0-9][0-9_]*)(?:[eE][0-9][0-9_]*)?)$/.test(\n value,\n )\n );\n}\n\n/** Additive policy for standalone builders; adapters always request quote-all. */\nexport interface IdentifierOptions {\n quoteIdentifiers?: boolean;\n}\n\n/** Parse identifiers, never SQL. Dots outside double quotes delimit qualifiers. */\nexport function identifierParts(\n identifier: string,\n): Array<{ name: string; exact: boolean }> {\n if (\n typeof identifier !== 'string' ||\n !identifier ||\n identifier.includes('\\0')\n ) {\n throw new Error(`Invalid SQL identifier: ${identifier}`);\n }\n const parts: Array<{ name: string; exact: boolean }> = [];\n let position = 0;\n while (position < identifier.length) {\n const rest = identifier.slice(position);\n const match = rest.startsWith('\"')\n ? /^\"((?:[^\"]|\"\")+)\"(?=\\.|$)/.exec(rest)\n : /^([A-Za-z0-9_]+)(?=\\.|$)/.exec(rest);\n if (!match) throw new Error(`Invalid SQL identifier: ${identifier}`);\n const exact = rest.startsWith('\"');\n parts.push({\n name: exact ? match[1].replaceAll('\"\"', '\"') : match[1],\n exact,\n });\n position += match[0].length;\n if (position < identifier.length) {\n position += 1;\n if (position === identifier.length)\n throw new Error(`Invalid SQL identifier: ${identifier}`);\n }\n }\n return parts;\n}\n\nfunction isColumnIdentifier(identifier: string): boolean {\n try {\n const parts = identifierParts(identifier);\n return (\n parts.length === 1 &&\n (parts[0].exact || /^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier))\n );\n } catch {\n return false;\n }\n}\n\n/** Quote a physical name without interpreting delimiters or dots. */\nexport function quoteLiteralIdentifier(identifier: string): string {\n return quotePhysicalIdentifier(identifier, '\"');\n}\n\n/** SQLite identifiers must not fall back to double-quoted string literals. */\nexport function quoteSqliteLiteralIdentifier(identifier: string): string {\n return quotePhysicalIdentifier(identifier, '`');\n}\n\nfunction quotePhysicalIdentifier(identifier: string, quote: '\"' | '`'): string {\n if (typeof identifier !== 'string')\n throw new Error(`Invalid SQL identifier: ${identifier}`);\n return `${quote}${escapeQuotedIdentifier(identifier, quote)}${quote}`;\n}\n\n/** SQLite CRUD column (one validated identifier). */\nexport function quoteSqliteColumnName(column: string): string {\n validateColumnName(column);\n return renderIdentifier(column, 'sqlite', { quoteIdentifiers: true });\n}\n\n/** DuckDB/JSON CRUD column, or an already-resolved literal physical name. */\nexport function quoteDuckDBColumnName(column: string, literal = false): string {\n if (literal) return quoteLiteralIdentifier(column);\n validateColumnName(column);\n return renderIdentifier(column, 'duckdb', { quoteIdentifiers: true });\n}\n\n/** Shared rendering for qualified WHERE/aggregate identifiers. */\nexport function renderIdentifier(\n identifier: string,\n dialect?: 'sqlite' | 'postgres' | 'duckdb' | 'json',\n options: IdentifierOptions = {},\n): string {\n return identifierParts(identifier)\n .map(({ name, exact }) => {\n if (\n !options.quoteIdentifiers &&\n !exact &&\n !IDENTIFIER_KEYWORDS.has(name.toLowerCase())\n )\n return name;\n const physical =\n dialect === 'postgres' && !exact ? name.toLowerCase() : name;\n return dialect === 'sqlite'\n ? quoteSqliteLiteralIdentifier(physical)\n : quoteLiteralIdentifier(physical);\n })\n .join('.');\n}\n\n/** Previously raw index terms may be expressions or ordered SQL, not just names. */\nexport function renderIndexTerm(\n term: string,\n dialect?: DatabaseDialect,\n options: IdentifierOptions = {},\n): string {\n // Classify syntax before rendering: do not hide errors thrown by the renderer.\n const component = '(?:[A-Za-z_][A-Za-z0-9_]*|\"(?:[^\"]|\"\")+\")';\n const plain = new RegExp(`^${component}(?:\\\\.${component})*$`);\n return typeof term === 'string' && plain.test(term)\n ? renderIdentifier(term, dialect, options)\n : term;\n}\n\n/** DDL names historically accepted SQLite's alternate identifier delimiters.\n * Normalize names only here; strict CRUD/WHERE keep their existing input syntax.\n */\nexport function renderSchemaIdentifier(\n identifier: string,\n dialect?: DatabaseDialect,\n options: IdentifierOptions = {},\n): string {\n if (typeof identifier !== 'string')\n throw new Error(`Invalid SQL identifier: ${identifier}`);\n const parts: string[] = [];\n let position = 0;\n while (position < identifier.length) {\n const match =\n /^(?:([A-Za-z0-9_]+)|\"((?:[^\"]|\"\")+)\"|`((?:[^`]|``)+)`|\\[([^\\]]+)\\]|'((?:[^']|'')+)')(?=\\.|$)/.exec(\n identifier.slice(position),\n );\n if (!match) throw new Error(`Invalid SQL identifier: ${identifier}`);\n if (match[1] !== undefined) parts.push(match[1]);\n else {\n const name =\n match[2] !== undefined\n ? match[2].replaceAll('\"\"', '\"')\n : match[3] !== undefined\n ? match[3].replaceAll('``', '`')\n : match[4] !== undefined\n ? match[4]\n : match[5].replaceAll(\"''\", \"'\");\n parts.push(quoteLiteralIdentifier(name));\n }\n position += match[0].length;\n if (position < identifier.length) {\n position += 1;\n if (position === identifier.length)\n throw new Error(`Invalid SQL identifier: ${identifier}`);\n }\n }\n return renderIdentifier(parts.join('.'), dialect, options);\n}\n\n/** FK lists contain identifiers, with commas outside explicit quotes only. */\nexport function renderIdentifierList(\n list: string,\n dialect?: DatabaseDialect,\n options: IdentifierOptions = {},\n): string {\n if (typeof list !== 'string')\n throw new Error(`Invalid SQL identifier list: ${list}`);\n const parts: string[] = [];\n let closingQuote: string | undefined;\n let start = 0;\n for (let index = 0; index < list.length; index += 1) {\n const char = list[index];\n if (closingQuote) {\n if (char === closingQuote) {\n if (closingQuote !== ']' && list[index + 1] === closingQuote)\n index += 1;\n else closingQuote = undefined;\n }\n } else if (char === '\"' || char === \"'\" || char === '`' || char === '[') {\n closingQuote = char === '[' ? ']' : char;\n } else if (char === ',') {\n parts.push(list.slice(start, index));\n start = index + 1;\n }\n }\n parts.push(list.slice(start));\n return parts\n .map((part) => {\n const name = part.trim();\n const offset = part.indexOf(name);\n return (\n part.slice(0, offset) +\n renderSchemaIdentifier(name, dialect, options) +\n part.slice(offset + name.length)\n );\n })\n .join(',');\n}\n\n// SQLite official 147-keyword list (sqlite.org/lang_keywords.html), plus reserved\n// pg_get_keywords() (PGlite 0.5.8) and duckdb_keywords() (DuckDB 1.4.3).\nconst IDENTIFIER_KEYWORDS = new Set(\n 'abort action add after all alter always analyse analyze and any array as asc asymmetric attach autoincrement before begin between both by cascade case cast check collate column commit conflict constraint create cross current current_catalog current_date current_role current_time current_timestamp current_user database default deferrable deferred delete desc describe detach distinct do drop each else end escape except exclude exclusive exists explain fail false fetch filter first following for foreign from full generated glob grant group groups having if ignore immediate in index indexed initially inner insert instead intersect into is isnull join key lambda last lateral leading left like limit localtime localtimestamp match materialized natural no not nothing notnull null nulls of offset on only or order others outer over partition pivot pivot_longer pivot_wider placing plan pragma preceding primary qualify query raise range recursive references regexp reindex release rename replace restrict returning right rollback row rows savepoint select session_user set show some summarize symmetric system_user table temp temporary then ties to trailing transaction trigger true unbounded union unique unpivot update user using vacuum values variadic view virtual when where window with without'.split(\n ' ',\n ),\n);\n","/**\n * Shared SQL utilities that work in both browser and Node.js environments\n */\n\nimport { DatabaseError } from '@happyvertical/utils';\nimport {\n type IdentifierOptions,\n isLegacyNumericSqlToken,\n renderIdentifier,\n} from './alter-utils.js';\nimport type { WhereClause } from './types.js';\n\n/**\n * Formats a database error to include its useful non-secret details.\n *\n * Database drivers often include additional properties beyond just `message`:\n * - PostgreSQL: code, detail, hint, severity\n * - DuckDB: may include additional context\n * - SQLite/LibSQL: may include errno, code\n *\n * This function extracts an allowlist of driver properties and redacts\n * credential-shaped text. When parameter values are available, prefer\n * {@link wrapDatabaseError}; it also redacts values echoed by the driver.\n *\n * @param error - The caught error object\n * @returns Formatted error string with all available error details\n */\nexport function formatDbError(error: unknown): string {\n return formatDbErrorWithSecrets(error, []);\n}\n\ntype DriverError = {\n name?: string;\n message?: string;\n code?: string;\n detail?: string;\n hint?: string;\n severity?: string;\n errno?: number;\n connectionInvalidated?: boolean;\n};\n\nconst DRIVER_ERROR_FIELDS = [\n 'code',\n 'detail',\n 'hint',\n 'severity',\n 'errno',\n 'connectionInvalidated',\n] as const;\n\nconst SENSITIVE_CONTEXT_KEY =\n /^(?:args?|parameters?|params?|queries|query|sql|values?)$/i;\nconst CREDENTIAL_KEY_PART =\n /^(?:credential|credentials|passphrase|password|pwd|secret|token)$/i;\nconst CREDENTIAL_KEY_QUALIFIER =\n /^(?:access|api|auth|client|private|refresh|service|signing)$/i;\nconst DATABASE_USER_KEY =\n /^(?:user(?:name)?|(?:database|db|pg|postgres|postgresql)[._-]?user(?:name)?)$/i;\nconst DATABASE_URL_USERINFO =\n /\\b((?:https?|libsql|postgres|postgresql):\\/\\/)[^\\s/@]+@/giu;\nconst DATABASE_URL =\n /\\b(?:https?|libsql|postgres|postgresql):\\/\\/[^\\s\"'`<>()]+/giu;\nconst CREDENTIAL_ASSIGNMENT =\n /(?<![\\p{L}\\p{N}_-])([\"']?)([\\p{L}\\p{N}_.-]+(?: key)?)\\1(\\s*[:=]\\s*)(?:\"(?:\\\\.|[^\"])*\"|'(?:\\\\.|[^'])*'|[^\\s,;}\\]]+)/giu;\nconst BEARER_CREDENTIAL = /\\bbearer\\s+[^\\s,;]+/giu;\nconst SQL_NUMERIC_LITERAL =\n /(?<![\\p{L}\\p{N}_$])[-+]?(?:\\d(?:_?\\d)*(?:\\.(?:\\d(?:_?\\d)*)?)?|\\.\\d(?:_?\\d)*)(?:e[-+]?\\d(?:_?\\d)*)?(?![\\p{L}\\p{N}_$])/giu;\nconst POSTGRES_KEY_VALUE =\n /(\\bKey\\s*\\([^\\r\\n)]*\\)\\s*=\\s*\\()([\\s\\S]*?)(\\)\\s*(?:already exists|is duplicated)\\b)/giu;\nconst POSTGRES_FAILING_ROW =\n /(\\bFailing row contains\\s*\\()([\\s\\S]*)(\\)(?:\\.|$))/giu;\nconst CAST_INPUT_VALUE =\n /(\\bwith value\\s+)([\\s\\S]*?)(\\s+(?:can't|cannot)\\s+be cast\\b)/giu;\n\nfunction isCredentialKey(key: string): boolean {\n if (DATABASE_USER_KEY.test(key)) return true;\n\n const parts = key\n .replace(/([\\p{Ll}\\p{N}])(\\p{Lu})/gu, '$1 $2')\n .split(/[^\\p{L}\\p{N}]+/u)\n .filter(Boolean);\n if (parts.length === 1 && /^(?:auth|credential|key|pass)$/i.test(parts[0])) {\n return true;\n }\n if (parts.some((part) => CREDENTIAL_KEY_PART.test(part))) return true;\n\n return parts.some(\n (part, index) =>\n /^(?:key|auth)$/i.test(part) &&\n index > 0 &&\n CREDENTIAL_KEY_QUALIFIER.test(parts[index - 1]),\n );\n}\n\nfunction toDriverError(error: unknown): DriverError {\n return error && (typeof error === 'object' || typeof error === 'function')\n ? (error as DriverError)\n : {};\n}\n\nfunction redactUrl(value: string): string {\n try {\n const url = new URL(value);\n if (url.username) url.username = '[redacted]';\n if (url.password) url.password = '[redacted]';\n for (const key of url.searchParams.keys()) {\n if (isCredentialKey(key)) {\n url.searchParams.set(key, '[redacted]');\n }\n }\n if (url.hash) url.hash = '[redacted]';\n return url.toString();\n } catch {\n return value.replace(/\\/\\/[^/@\\s]+@/u, '//[redacted]@');\n }\n}\n\nfunction redactKnownValue(input: string, value: string): string {\n if (!value || !input.includes(value)) return input;\n if (!/^[\\p{L}\\p{N}_-]+$/u.test(value)) {\n return input.split(value).join('[redacted]');\n }\n\n const identifierCharacter = /^[\\p{L}\\p{N}_-]$/u;\n let cursor = 0;\n let redacted = '';\n let match = input.indexOf(value);\n while (match !== -1) {\n const end = match + value.length;\n const before = [...input.slice(Math.max(0, match - 2), match)].at(-1);\n const afterCodePoint = input.codePointAt(end);\n const after =\n afterCodePoint === undefined\n ? undefined\n : String.fromCodePoint(afterCodePoint);\n const bounded =\n (!before || !identifierCharacter.test(before)) &&\n (!after || !identifierCharacter.test(after));\n\n redacted += input.slice(cursor, match);\n redacted += bounded ? '[redacted]' : value;\n cursor = end;\n match = input.indexOf(value, cursor);\n }\n\n return redacted + input.slice(cursor);\n}\n\nfunction redactDatabaseErrorText(\n value: string,\n knownSecrets: readonly string[],\n): string {\n let redacted = value\n .replace(DATABASE_URL_USERINFO, '$1[redacted]@')\n .replace(DATABASE_URL, redactUrl)\n .replace(\n CREDENTIAL_ASSIGNMENT,\n (assignment, quote: string, key: string, delimiter: string) =>\n isCredentialKey(key)\n ? `${quote}${key}${quote}${delimiter}[redacted]`\n : assignment,\n )\n .replace(BEARER_CREDENTIAL, 'Bearer [redacted]')\n .replace(\n POSTGRES_KEY_VALUE,\n (_match, prefix: string, _value: string, suffix: string) =>\n `${prefix}[redacted]${suffix}`,\n )\n .replace(\n POSTGRES_FAILING_ROW,\n (_match, prefix: string, _value: string, suffix: string) =>\n `${prefix}[redacted]${suffix}`,\n )\n .replace(\n CAST_INPUT_VALUE,\n (_match, prefix: string, _value: string, suffix: string) =>\n `${prefix}[redacted]${suffix}`,\n );\n\n for (const secret of [...new Set(knownSecrets)].sort(\n (left, right) => right.length - left.length,\n )) {\n redacted = redactKnownValue(redacted, secret);\n }\n\n return redacted;\n}\n\nfunction collectSensitiveValues(\n value: unknown,\n output: Set<string>,\n seen: Set<object>,\n): void {\n if (typeof value === 'string') {\n if (value) output.add(value);\n return;\n }\n if (\n typeof value === 'number' ||\n typeof value === 'bigint' ||\n typeof value === 'boolean'\n ) {\n output.add(String(value));\n return;\n }\n if (!value || typeof value !== 'object' || seen.has(value)) return;\n seen.add(value);\n\n try {\n if (value instanceof Date) {\n output.add(value.toISOString());\n return;\n }\n\n if (ArrayBuffer.isView(value)) {\n const bytes = new Uint8Array(\n value.buffer,\n value.byteOffset,\n value.byteLength,\n );\n if (bytes.length > 0) {\n const hex = [...bytes]\n .map((byte) => byte.toString(16).padStart(2, '0'))\n .join('');\n output.add([...bytes].join(','));\n output.add(hex);\n output.add(`\\\\x${hex}`);\n output.add(`\\\\x${hex.toUpperCase()}`);\n output.add(\n `<Buffer ${[...bytes]\n .map((byte) => byte.toString(16).padStart(2, '0'))\n .join(' ')}>`,\n );\n if (typeof Buffer !== 'undefined') {\n output.add(Buffer.from(bytes).toString('base64'));\n }\n }\n return;\n }\n } catch {\n return;\n }\n\n try {\n const serialized = JSON.stringify(value);\n if (serialized && serialized !== '{}' && serialized !== '[]') {\n output.add(serialized);\n }\n } catch {\n // Cyclic bind values are still traversed below.\n }\n\n let descriptors: Record<string, PropertyDescriptor>;\n try {\n descriptors = Object.getOwnPropertyDescriptors(value);\n } catch {\n // A proxy trap must not replace the database failure being reported.\n return;\n }\n\n for (const [key, descriptor] of Object.entries(descriptors)) {\n if (key !== 'length' && 'value' in descriptor) {\n collectSensitiveValues(descriptor.value, output, seen);\n }\n }\n}\n\nfunction collectSqlLiterals(sql: string, output: Set<string>): void {\n // Some drivers include the complete statement in their diagnostics. Treat\n // an exact echo as sensitive even when it contains no parseable literals.\n if (sql) output.add(sql);\n\n for (const match of sql.matchAll(/'((?:''|[^'])*)'/gu)) {\n const literal = match[1].replaceAll(\"''\", \"'\");\n if (literal) output.add(literal);\n }\n\n for (const match of sql.matchAll(/\\$\\$([\\s\\S]*?)\\$\\$/gu)) {\n if (match[1]) output.add(match[1]);\n }\n\n for (const match of sql.matchAll(\n /\\$([A-Za-z_][A-Za-z0-9_]*)\\$([\\s\\S]*?)\\$\\1\\$/gu,\n )) {\n if (match[2]) output.add(match[2]);\n }\n\n for (const match of sql.matchAll(SQL_NUMERIC_LITERAL)) {\n output.add(match[0]);\n output.add(match[0].replaceAll('_', ''));\n }\n}\n\nfunction contextSecrets(context: Record<string, unknown>): string[] {\n const output = new Set<string>();\n for (const [key, value] of Object.entries(context)) {\n if (/^(?:args?|parameters?|params?|values?)$/i.test(key)) {\n collectSensitiveValues(value, output, new Set());\n } else if (\n /^(?:queries|query|sql)$/i.test(key) &&\n typeof value === 'string'\n ) {\n collectSqlLiterals(value, output);\n }\n }\n return [...output];\n}\n\nfunction sanitizeContextValue(\n value: unknown,\n knownSecrets: readonly string[],\n seen: WeakSet<object>,\n): unknown {\n if (typeof value === 'string') {\n return redactDatabaseErrorText(value, knownSecrets);\n }\n if (!value || typeof value !== 'object') return value;\n if (seen.has(value)) return '[circular]';\n seen.add(value);\n\n if (Array.isArray(value)) {\n return value.map((entry) =>\n sanitizeContextValue(entry, knownSecrets, seen),\n );\n }\n\n return Object.fromEntries(\n Object.entries(value as Record<string, unknown>).map(([key, entry]) => [\n key,\n isCredentialKey(key)\n ? '[redacted]'\n : sanitizeContextValue(entry, knownSecrets, seen),\n ]),\n );\n}\n\nfunction sanitizeDatabaseErrorContext(\n context: Record<string, unknown>,\n knownSecrets: readonly string[],\n): Record<string, unknown> {\n return Object.fromEntries(\n Object.entries(context).map(([key, value]) => [\n key,\n SENSITIVE_CONTEXT_KEY.test(key) || isCredentialKey(key)\n ? '[redacted]'\n : sanitizeContextValue(value, knownSecrets, new WeakSet()),\n ]),\n );\n}\n\nfunction formatDbErrorWithSecrets(\n error: unknown,\n knownSecrets: readonly string[],\n): string {\n const dbError = toDriverError(error);\n\n const parts: string[] = [];\n\n if (dbError.message) {\n parts.push(redactDatabaseErrorText(dbError.message, knownSecrets));\n }\n if (dbError.code) {\n parts.push(`code=${redactDatabaseErrorText(dbError.code, knownSecrets)}`);\n }\n if (dbError.detail) {\n parts.push(\n `detail=${redactDatabaseErrorText(dbError.detail, knownSecrets)}`,\n );\n }\n if (dbError.hint) {\n parts.push(`hint=${redactDatabaseErrorText(dbError.hint, knownSecrets)}`);\n }\n if (dbError.severity) {\n parts.push(\n `severity=${redactDatabaseErrorText(dbError.severity, knownSecrets)}`,\n );\n }\n if (dbError.errno !== undefined) parts.push(`errno=${dbError.errno}`);\n\n return parts.length > 0\n ? parts.join(', ')\n : redactDatabaseErrorText(String(error), knownSecrets);\n}\n\nfunction safeDatabaseCause(\n error: unknown,\n knownSecrets: readonly string[],\n): Error {\n const dbError = toDriverError(error);\n const message = dbError.message\n ? redactDatabaseErrorText(dbError.message, knownSecrets)\n : formatDbErrorWithSecrets(error, knownSecrets);\n const cause = new Error(message);\n cause.name = dbError.name\n ? redactDatabaseErrorText(dbError.name, knownSecrets)\n : 'DatabaseDriverError';\n\n for (const field of DRIVER_ERROR_FIELDS) {\n const value = dbError[field];\n if (\n typeof value === 'string' ||\n typeof value === 'number' ||\n typeof value === 'boolean'\n ) {\n Object.defineProperty(cause, field, {\n configurable: true,\n enumerable: true,\n value:\n typeof value === 'string'\n ? redactDatabaseErrorText(value, knownSecrets)\n : value,\n writable: true,\n });\n }\n }\n\n return cause;\n}\n\n/**\n * Wraps an engine failure in a serializable, secret-safe DatabaseError.\n *\n * Raw SQL and parameter values are replaced in context. The native `cause` is\n * a sanitized driver-error snapshot rather than the original object so normal\n * Error inspection cannot bypass the same redaction applied to messages and\n * JSON serialization.\n */\nexport function wrapDatabaseError(\n message: string,\n error: unknown,\n context: Record<string, unknown> = {},\n): DatabaseError {\n const knownSecrets = contextSecrets(context);\n const originalError = formatDbErrorWithSecrets(error, knownSecrets);\n return new DatabaseError(\n `${message}: ${originalError}`,\n {\n ...sanitizeDatabaseErrorContext(context, knownSecrets),\n originalError,\n },\n safeDatabaseCause(error, knownSecrets),\n );\n}\n\n/**\n * Resolves the column list for a multi-row INSERT and rejects batches whose\n * records disagree on it.\n *\n * A batch INSERT emits one column list for the whole statement, so it can only\n * come from the first record. That leaves two ways for a later record to be\n * written wrongly, both of them silent:\n *\n * - Its keys are the same but in a different insertion order. Callers that\n * bound values with `Object.values(record)` bound them by position, so the\n * values cross-assigned into each other's columns. Projecting each record\n * through the returned column list — `keys.map((key) => record[key])` — is\n * what makes key order irrelevant, and every caller must do it.\n * - Its key set genuinely differs. An extra key has no column to go to and a\n * missing one has no value, so the record cannot be expressed by this\n * statement at all. Guessing (dropping the extra, writing NULL for the\n * missing) is what makes the failure invisible, so this throws instead.\n *\n * A key whose value is `undefined` counts as absent. Adapters that serialize\n * records first drop such keys before this point while the rest pass them\n * through, so comparing raw key lists would make the same batch throw on some\n * adapters and silently write NULL on others. Only the comparison ignores them;\n * the returned column list is untouched, so each adapter keeps its own\n * single-record handling of `undefined`.\n *\n * @param table - Table being inserted into, for error context\n * @param records - Non-empty batch, as the adapter will bind it\n * @returns Column list taken from the first record\n * @throws DatabaseError if any later record's key set differs from the first's\n */\nexport function resolveInsertColumns(\n table: string,\n records: Record<string, any>[],\n): string[] {\n const definedKeys = (record: Record<string, any>) =>\n new Set(Object.keys(record).filter((key) => record[key] !== undefined));\n\n const keys = Object.keys(records[0]);\n const expected = definedKeys(records[0]);\n\n for (let index = 1; index < records.length; index++) {\n const recordKeys = definedKeys(records[index]);\n const missing = [...expected].filter((key) => !recordKeys.has(key));\n const extra = [...recordKeys].filter((key) => !expected.has(key));\n\n if (missing.length === 0 && extra.length === 0) {\n continue;\n }\n\n const problems = [\n missing.length > 0 ? `missing ${missing.join(', ')}` : '',\n extra.length > 0 ? `unexpected ${extra.join(', ')}` : '',\n ].filter(Boolean);\n\n throw new DatabaseError(\n `Batch insert records must all have the same keys; record ${index} has ${problems.join(\n ' and ',\n )} relative to record 0 (${[...expected].join(', ')})`,\n {\n table,\n recordIndex: index,\n expectedKeys: keys,\n recordKeys: [...recordKeys],\n missing,\n extra,\n hint: 'A batch INSERT writes one column list for every row, taken from the first record, so record 0 defines the columns even when it is the one that looks wrong. A key whose value is undefined counts as absent. Split records with differing keys into separate insert() calls, or fill the gaps explicitly with null.',\n },\n );\n }\n\n return keys;\n}\n\n/**\n * Map of valid SQL operators for use in WHERE clauses\n */\nconst VALID_OPERATORS = {\n '=': '=',\n '>': '>',\n '>=': '>=',\n '<': '<',\n '<=': '<=',\n '!=': '!=',\n like: 'LIKE',\n contains: 'CONTAINS',\n in: 'IN',\n 'not in': 'NOT IN',\n} as const;\n\ndeclare const rawSqlKeyBrand: unique symbol;\n\n/**\n * A WHERE-clause key produced by {@link raw}: SQL text the caller vouches for,\n * exempt from the identifier validation `buildWhere` applies to every other key.\n */\nexport type RawSqlKey = string & { readonly [rawSqlKeyBrand]: true };\n\n/**\n * Marks a condition key as caller-authored SQL text.\n *\n * A fixed, non-secret sentinel rather than a random per-process token. A random\n * token has to travel inside the key, which means it reaches every place a key\n * is echoed — error messages, logs, each adapter's `DatabaseError` context — and\n * one disclosure would let a caller mint raw keys for the life of the process.\n * A registry of minted expressions avoids that but is not referentially\n * transparent: it would make `raw('revenue >')` in one query change what the\n * plain key `'revenue >'` means in every other one.\n *\n * The NUL delimiters cannot appear in an identifier or in SQL a developer would\n * write, so the marker never collides with a legitimate key.\n */\nconst RAW_KEY_PREFIX = '\\u0000hv-sql-raw\\u0000';\n\n/**\n * Marks a WHERE-clause key as SQL expression text rather than an identifier.\n *\n * {@link buildWhere} validates every condition key as a plain identifier. Wrap a\n * key in `raw()` to opt one condition out of that check:\n *\n * ```typescript\n * buildWhere({\n * status: 'paid', // validated as an identifier\n * [raw('SUM(total) >')]: 100, // caller-authored SQL, not validated\n * });\n * ```\n *\n * Never build the argument from end-user input. `raw()` is an assertion that\n * the caller, not the request, authored this SQL.\n *\n * The returned key carries a marker, so it is a distinct string from the bare\n * expression: minting `raw('revenue >')` never changes what the plain key\n * `'revenue >'` means anywhere else.\n *\n * The marker is a fixed sentinel, not a secret. It stops an expression key being\n * used by accident — the shape of the key no longer grants raw access, a call to\n * `raw()` does — but a caller that controls a whole key string verbatim,\n * including the NUL-delimited marker, can still reproduce it. Validate at your\n * own trust boundary; do not rely on this as the only barrier against hostile\n * input.\n *\n * Enforcement is at runtime: `WhereClause` keys are plain `string`, so a\n * computed key widens and TypeScript will not reject an unmarked expression key\n * at the call site.\n *\n * A trailing operator is recognised only if it is one of `=`, `!=`, `>`, `>=`,\n * `<`, `<=`, `like`, `contains`, `in`, `not in`. Any other trailing token is\n * treated as part of the expression and `=` is appended, so\n * `raw('name ILIKE')` silently emits `name ILIKE = $1`, which the database then\n * rejects. Fold an unsupported operator into the expression instead:\n * `raw('LOWER(name) like')`.\n *\n * @param expression - SQL field or expression text, optionally ending in a\n * supported operator (for example `SUM(total) >`)\n * @returns A branded key for use in a {@link WhereClause}\n * @throws If the expression is empty\n */\nexport function raw(expression: string): RawSqlKey {\n // Unwrap first so raw(raw(x)) === raw(x) and a marker can never nest into the\n // emitted SQL.\n const trimmed = unwrapRawKey(expression).key.trim();\n if (!trimmed) {\n throw new Error('raw() requires a non-empty SQL expression');\n }\n return `${RAW_KEY_PREFIX}${trimmed}` as RawSqlKey;\n}\n\n/**\n * Splits the raw marker off a condition key.\n * @internal\n */\nexport function unwrapRawKey(fullKey: string): {\n key: string;\n isRaw: boolean;\n} {\n return fullKey.startsWith(RAW_KEY_PREFIX)\n ? { key: fullKey.slice(RAW_KEY_PREFIX.length), isRaw: true }\n : { key: fullKey, isRaw: false };\n}\n\nexport function parseConditionKey(fullKey: string): {\n field: string;\n operator: string;\n} {\n const trimmed = fullKey.trim();\n const lower = trimmed.toLowerCase();\n const operators = [\n 'not in',\n 'contains',\n 'like',\n 'in',\n '!=',\n '>=',\n '<=',\n '>',\n '<',\n '=',\n ];\n\n for (const operator of operators) {\n if (lower.endsWith(` ${operator}`)) {\n return {\n field: trimmed.slice(0, -(operator.length + 1)).trim(),\n operator,\n };\n }\n }\n\n // Deliberately no `explicitOperator` flag: \"key ends in an operator\" was the\n // condition that used to suppress identifier validation, and that was the\n // vulnerability. Nothing should gate trust on the shape of the key again.\n return { field: trimmed, operator: '=' };\n}\n\n/**\n * SQL adapter type for adapter-specific query generation\n */\nexport type SqlAdapterType = 'sqlite' | 'postgres' | 'duckdb' | 'json';\n\n/**\n * Builds a single condition for a WHERE clause\n * @internal\n */\nconst buildCondition = (\n fullKey: string,\n value: any,\n currIndex: { value: number },\n adapterType?: SqlAdapterType,\n options: IdentifierOptions = {},\n): { sql: string; values: any[] } => {\n const { key, isRaw } = unwrapRawKey(fullKey);\n const parsed = parseConditionKey(key);\n const operator = parsed.operator;\n let field = parsed.field;\n if (!isRaw && !isLegacyNumericSqlToken(field)) {\n try {\n field = renderIdentifier(field, adapterType, options);\n } catch (error) {\n if (\n !(error instanceof Error) ||\n !error.message.startsWith('Invalid SQL identifier:')\n )\n throw error;\n throw new Error(\n `${error.message}. Condition keys must be plain identifiers; wrap developer-authored SQL expressions in raw().`,\n );\n }\n }\n const sqlOperator =\n VALID_OPERATORS[operator as keyof typeof VALID_OPERATORS] || '=';\n const values: any[] = [];\n\n let sql: string;\n\n if (sqlOperator === 'CONTAINS') {\n if (!adapterType) {\n throw new Error(\n 'CONTAINS requires an adapter type so buildWhere can preserve case-sensitive semantics',\n );\n }\n if (typeof value !== 'string') {\n throw new Error('CONTAINS requires a string value');\n }\n\n const placeholder = `$${currIndex.value++}`;\n const containsFunction = adapterType === 'sqlite' ? 'instr' : 'strpos';\n sql = `${containsFunction}(${field}, ${placeholder}) > 0`;\n values.push(value);\n } else if (value === null) {\n sql = `${field} IS ${sqlOperator === '=' ? 'NULL' : 'NOT NULL'}`;\n } else if (\n (sqlOperator === 'IN' || sqlOperator === 'NOT IN') &&\n Array.isArray(value)\n ) {\n if (value.length === 0) {\n throw new Error(`${sqlOperator} requires at least one value`);\n }\n const placeholders = value.map(() => `$${currIndex.value++}`).join(', ');\n sql = `${field} ${sqlOperator} (${placeholders})`;\n values.push(...value);\n } else if (value instanceof Date) {\n // DuckDB/JSON need CAST to TIMESTAMP to prevent ANY type inference (issue #540)\n // SQLite/PostgreSQL handle ISO strings natively without CAST\n const needsCast = adapterType === 'duckdb' || adapterType === 'json';\n if (needsCast) {\n sql = `${field} ${sqlOperator} CAST($${currIndex.value++} AS TIMESTAMP)${\n sqlOperator === 'LIKE' ? \" ESCAPE '\\\\'\" : ''\n }`;\n } else {\n sql = `${field} ${sqlOperator} $${currIndex.value++}${\n sqlOperator === 'LIKE' ? \" ESCAPE '\\\\'\" : ''\n }`;\n }\n values.push(value.toISOString());\n } else {\n sql = `${field} ${sqlOperator} $${currIndex.value++}${\n sqlOperator === 'LIKE' ? \" ESCAPE '\\\\'\" : ''\n }`;\n values.push(value);\n }\n\n return { sql, values };\n};\n\n/**\n * Builds a SQL WHERE clause with parameterized values and flexible operators\n *\n * @param where - Conditions as object (AND-only) or 2D array (OR/AND compound)\n * @param startIndex - Starting index for parameter numbering (default: 1)\n * @param adapterType - Database adapter type. Controls Date and `contains`\n * handling:\n * - `'duckdb'` / `'json'`: Wraps Date values in `CAST($N AS TIMESTAMP)` to\n * prevent DuckDB ANY-type inference issues.\n * - `'sqlite'` / `'postgres'` / `undefined`: Passes ISO strings directly\n * (these adapters handle ISO timestamp strings natively).\n * - Required for `contains`, whose case-sensitive literal substring SQL is\n * emitted with adapter-specific functions.\n *\n * Every condition key is validated as a plain SQL identifier, with or without\n * an operator suffix. To use expression text as a key, wrap it in {@link raw}:\n *\n * ```typescript\n * buildWhere({ [raw('LOWER(status) =')]: 'paid' });\n * ```\n *\n * `raw()` is the only way to reach expression text, so mapping untrusted input\n * into a condition key throws rather than emitting attacker-controlled SQL.\n *\n * @returns Object containing the SQL clause and array of values\n * @throws If a key that is not wrapped in {@link raw} is not a plain identifier\n *\n * @example Basic Usage (Object format - AND-only):\n * ```typescript\n * buildWhere({\n * 'status': 'active', // equals operator is default\n * 'price >': 100, // greater than\n * 'stock <=': 5, // less than or equal\n * 'category in': ['A', 'B'], // IN clause for arrays\n * 'name like': '%shirt%', // LIKE pattern; backslash escapes `%` / `_`\n * 'notes contains': '100% off' // literal, case-sensitive substring\n * });\n * ```\n *\n * @example 2D Array Format (OR/AND compound logic):\n * ```typescript\n * // WHERE (status = 'active' AND price > 100) OR (status = 'pending' AND priority = 'high')\n * buildWhere([\n * [{ status: 'active' }, { 'price >': 100 }],\n * [{ status: 'pending' }, { priority: 'high' }]\n * ]);\n * ```\n *\n * @example NULL Handling:\n * ```typescript\n * buildWhere({\n * 'deleted_at': null, // becomes \"deleted_at IS NULL\"\n * 'updated_at !=': null, // becomes \"updated_at IS NOT NULL\"\n * 'status': 'active' // regular comparison\n * });\n * ```\n *\n * @example Common Patterns:\n * ```typescript\n * // Price range\n * buildWhere({\n * 'price >=': 10,\n * 'price <': 100\n * });\n *\n * // Date filtering\n * buildWhere({\n * 'created_at >': startDate,\n * 'created_at <=': endDate,\n * 'deleted_at': null\n * });\n *\n * // Search with LIKE\n * buildWhere({\n * 'title like': '%search%',\n * 'description like': '%search%',\n * 'status': 'published'\n * });\n *\n * // Multiple values with IN\n * buildWhere({\n * 'role in': ['admin', 'editor'],\n * 'active': true,\n * 'last_login !=': null\n * });\n * ```\n *\n * The function handles:\n * - Standard comparisons (=, >, >=, <, <=, !=)\n * - NULL checks (IS NULL, IS NOT NULL)\n * - IN clauses for arrays\n * - LIKE for pattern matching with an explicit backslash escape character\n * - Case-sensitive literal substring matching with `contains`\n * - Object format: Multiple conditions combined with AND\n * - 2D array format: Inner arrays ANDed, outer array ORed\n */\nexport const buildWhere = (\n where: WhereClause,\n startIndex = 1,\n adapterType?: SqlAdapterType,\n options: IdentifierOptions = {},\n) => {\n let sql = '';\n const values: any[] = [];\n const currIndex = { value: startIndex };\n\n // Handle 2D array format for OR/AND compound logic\n if (Array.isArray(where)) {\n if (where.length === 0) {\n return { sql: '', values: [] };\n }\n\n const orGroups: string[] = [];\n\n for (const andGroup of where) {\n if (!Array.isArray(andGroup) || andGroup.length === 0) {\n continue;\n }\n\n const andConditions: string[] = [];\n\n for (const conditionObj of andGroup) {\n for (const [fullKey, value] of Object.entries(conditionObj)) {\n const result = buildCondition(\n fullKey,\n value,\n currIndex,\n adapterType,\n options,\n );\n andConditions.push(result.sql);\n values.push(...result.values);\n }\n }\n\n if (andConditions.length > 0) {\n // Wrap AND group in parentheses\n orGroups.push(`(${andConditions.join(' AND ')})`);\n }\n }\n\n if (orGroups.length > 0) {\n sql = `WHERE ${orGroups.join(' OR ')}`;\n }\n\n return { sql, values };\n }\n\n // Handle object format (original behavior - AND-only)\n if (where && Object.keys(where).length > 0) {\n sql = 'WHERE ';\n for (const [fullKey, value] of Object.entries(where)) {\n const result = buildCondition(\n fullKey,\n value,\n currIndex,\n adapterType,\n options,\n );\n\n if (sql !== 'WHERE ') {\n sql += ' AND ';\n }\n\n sql += result.sql;\n values.push(...result.values);\n }\n }\n\n return { sql, values };\n};\n\n/** Adapter-owned WHERE policy: quote every identifier component. */\nexport const buildAdapterWhere: typeof buildWhere = (\n where,\n startIndex,\n adapterType,\n) => buildWhere(where, startIndex, adapterType, { quoteIdentifiers: true });\n\n/**\n * Rewrites executable positional parameters while preserving SQL text inside\n * literals, identifiers and comments. Extracted from the PostgreSQL adapter's\n * existing question-mark lexer so native SQLite and PostgreSQL use one policy.\n * SQLite's bracket/backtick identifiers are enabled only for that dialect:\n * PostgreSQL brackets can instead contain executable array subscript binds.\n */\nexport function rewriteSqlParameters(\n sql: string,\n dialect: 'postgres' | 'sqlite',\n replace: (token: string, index?: number) => string,\n): string {\n let output = '';\n let position = 0;\n const copyQuoted = (quote: string, escaped = false) => {\n output += sql[position++];\n while (position < sql.length) {\n const char = sql[position++];\n output += char;\n if (escaped && char === '\\\\' && position < sql.length) {\n output += sql[position++];\n } else if (char === quote) {\n if (quote !== ']' && sql[position] === quote) {\n output += sql[position++];\n } else break;\n }\n }\n };\n const copyUntil = (end: string) => {\n const endIndex = sql.indexOf(end, position + end.length);\n const after = endIndex < 0 ? sql.length : endIndex + end.length;\n output += sql.slice(position, after);\n position = after;\n };\n while (position < sql.length) {\n const char = sql[position];\n const next = sql[position + 1];\n if (\n dialect === 'postgres' &&\n (char === 'E' || char === 'e') &&\n next === \"'\"\n ) {\n output += char;\n position += 1;\n copyQuoted(\"'\", true);\n continue;\n }\n if (\n char === \"'\" ||\n char === '\"' ||\n (dialect === 'sqlite' && char === '`')\n ) {\n copyQuoted(char);\n continue;\n }\n if (dialect === 'sqlite' && char === '[') {\n copyQuoted(']');\n continue;\n }\n if (char === '-' && next === '-') {\n const endIndex = sql.slice(position).search(/[\\r\\n]/);\n const after = endIndex < 0 ? sql.length : position + endIndex + 1;\n output += sql.slice(position, after);\n position = after;\n continue;\n }\n if (char === '/' && next === '*') {\n if (dialect === 'sqlite') copyUntil('*/');\n else {\n const start = position;\n position += 2;\n let depth = 1;\n while (position < sql.length && depth > 0) {\n const pair = sql.slice(position, position + 2);\n if (pair === '/*') {\n depth += 1;\n position += 2;\n } else if (pair === '*/') {\n depth -= 1;\n position += 2;\n } else position += 1;\n }\n output += sql.slice(start, position);\n }\n continue;\n }\n // Both dialects allow $ within an undelimited identifier. Its suffix must\n // not be reinterpreted as a bind (for example, legacy raw foo$1).\n if (char === '$' && !/[\\w$\\u0080-\\uFFFF]/.test(sql[position - 1] ?? '')) {\n if (dialect === 'postgres') {\n const tag = sql.slice(position).match(/^\\$[A-Za-z_]\\w*\\$|^\\$\\$/);\n if (tag) {\n copyUntil(tag[0]);\n continue;\n }\n }\n const numbered = /^\\$(\\d+)/.exec(sql.slice(position));\n if (numbered) {\n output += replace(numbered[0], Number(numbered[1]));\n position += numbered[0].length;\n continue;\n }\n }\n if (char === '?' && next !== '|' && next !== '&') {\n output += replace('?');\n position += 1;\n continue;\n }\n output += char;\n position += 1;\n }\n return output;\n}\n","import {\n renderIdentifierList,\n renderIndexTerm,\n renderSchemaIdentifier,\n} from './shared/alter-utils.js';\n/**\n * Schema management and dependency resolution for JSON manifests\n * Moved from SMRT package to SQL package for proper separation of concerns\n */\n\nimport type {\n DatabaseInterface,\n IndexDefinition,\n SchemaDefinition,\n SchemaInitializationOptions,\n TriggerDefinition,\n} from './shared/types.js';\n\n/**\n * Result returned by DatabaseSchemaManager.initializeSchemas()\n *\n * Contains the list of schemas that were successfully initialized,\n * any that were skipped (already up to date), errors encountered,\n * and the total execution time in milliseconds.\n */\nexport interface SchemaInitializationResult {\n initialized: string[];\n skipped: string[];\n errors: Array<{ schema: string; error: string }>;\n executionTime: number;\n}\n\n/**\n * Manages schema initialization from JSON manifests with dependency resolution\n *\n * Handles topological sorting of schema dependencies, table creation,\n * index and trigger setup, and version tracking to avoid redundant re-initialization.\n */\nexport class DatabaseSchemaManager {\n private static initializationLock = new Map<string, Promise<void>>();\n private initializedSchemas = new Set<string>();\n private schemaVersions = new Map<string, string>();\n\n /**\n * Initializes database schemas from a JSON manifest with dependency resolution\n *\n * Schemas are topologically sorted by their declared dependencies and\n * initialized in order. Supports legacy raw-SQL schemas via the `schema` option,\n * JSON manifests via the `manifest` option, and schema overrides for extending\n * base schemas.\n *\n * @param db - Database interface to execute DDL against\n * @param options - Schema initialization options (manifest, overrides, force, debug)\n * @returns Result with lists of initialized/skipped schemas, errors, and execution time\n */\n async initializeSchemas(\n db: DatabaseInterface,\n options: SchemaInitializationOptions,\n ): Promise<SchemaInitializationResult> {\n const startTime = Date.now();\n const result: SchemaInitializationResult = {\n initialized: [],\n skipped: [],\n errors: [],\n executionTime: 0,\n };\n\n try {\n let schemas: Record<string, SchemaDefinition> = {};\n\n // Handle legacy SQL schema format\n if (options.schema) {\n console.log(\n '[schema] Legacy SQL schema provided, converting to manifest format',\n );\n // For legacy support, we'll still use the original syncSchema method\n if (db.syncSchema) {\n await db.syncSchema(options.schema);\n result.initialized.push('legacy-sql');\n }\n result.executionTime = Date.now() - startTime;\n return result;\n }\n\n // Handle JSON manifest format\n if (options.manifest) {\n schemas = { ...options.manifest.schemas };\n }\n\n // Apply schema overrides\n if (options.overrides) {\n schemas = { ...schemas, ...options.overrides };\n }\n\n if (Object.keys(schemas).length === 0) {\n console.warn('[schema] No schemas provided for initialization');\n result.executionTime = Date.now() - startTime;\n return result;\n }\n\n // Build dependency graph\n const dependencyGraph = this.buildDependencyGraph(schemas);\n\n // Get initialization order\n const initializationOrder = this.resolveDependencies(dependencyGraph);\n\n if (options.debug) {\n console.log('[schema] Initialization order:', initializationOrder);\n }\n\n // Initialize schemas in dependency order\n for (const schemaName of initializationOrder) {\n const schema = schemas[schemaName];\n if (!schema) continue;\n\n try {\n await this.initializeSchema(db, schemaName, schema, {\n force: options.force,\n debug: options.debug,\n });\n result.initialized.push(schemaName);\n } catch (error) {\n const errorMessage =\n error instanceof Error ? error.message : String(error);\n result.errors.push({ schema: schemaName, error: errorMessage });\n\n if (options.debug) {\n console.error(\n `[schema] Failed to initialize ${schemaName}:`,\n error,\n );\n }\n }\n }\n\n result.executionTime = Date.now() - startTime;\n\n if (options.debug) {\n console.log('[schema] Initialization complete:', result);\n }\n\n return result;\n } catch (error) {\n result.executionTime = Date.now() - startTime;\n const errorMessage =\n error instanceof Error ? error.message : String(error);\n result.errors.push({\n schema: 'dependency-resolution',\n error: errorMessage,\n });\n return result;\n }\n }\n\n /**\n * Initialize a single schema\n */\n private async initializeSchema(\n db: DatabaseInterface,\n schemaName: string,\n schema: SchemaDefinition,\n options: { force?: boolean; debug?: boolean },\n ): Promise<void> {\n const { tableName, version } = schema;\n const lockKey = `${schemaName}:${tableName}`;\n\n // Check if already being initialized\n if (DatabaseSchemaManager.initializationLock.has(lockKey)) {\n await DatabaseSchemaManager.initializationLock.get(lockKey);\n return;\n }\n\n // Check if already initialized and up to date\n if (!options.force && this.isSchemaUpToDate(schemaName, version)) {\n if (options.debug) {\n console.log(`[schema] Skipping ${schemaName} - already up to date`);\n }\n return;\n }\n\n // Create initialization promise\n const initPromise = this.performSchemaInitialization(\n db,\n schemaName,\n schema,\n options,\n );\n DatabaseSchemaManager.initializationLock.set(lockKey, initPromise);\n\n try {\n await initPromise;\n this.markSchemaInitialized(schemaName, version);\n } finally {\n DatabaseSchemaManager.initializationLock.delete(lockKey);\n }\n }\n\n /**\n * Perform the actual schema initialization\n */\n private async performSchemaInitialization(\n db: DatabaseInterface,\n schemaName: string,\n schema: SchemaDefinition,\n options: { force?: boolean; debug?: boolean },\n ): Promise<void> {\n const { tableName, columns, indexes, triggers } = schema;\n\n if (options.debug) {\n console.log(`[schema] Initializing ${schemaName} (${tableName})`);\n }\n\n // Check if table exists\n const tableExists = await db.tableExists(tableName);\n\n if (!tableExists) {\n // Create table\n await this.createTable(db, schema);\n\n // Create indexes\n for (const index of indexes) {\n await this.createIndex(db, tableName, index);\n }\n\n // Create triggers\n for (const trigger of triggers) {\n await this.createTrigger(db, trigger);\n }\n } else if (options.force) {\n // Recreate table if forced\n await db.query(\n `DROP TABLE IF EXISTS ${renderSchemaIdentifier(tableName)}`,\n );\n await this.createTable(db, schema);\n\n for (const index of indexes) {\n await this.createIndex(db, tableName, index);\n }\n\n for (const trigger of triggers) {\n await this.createTrigger(db, trigger);\n }\n } else {\n // Table exists, check for schema changes\n await this.updateSchemaIfNeeded(db, schema);\n }\n }\n\n /**\n * Create table from schema definition\n */\n private async createTable(\n db: DatabaseInterface,\n schema: SchemaDefinition,\n ): Promise<void> {\n const { tableName, columns, foreignKeys } = schema;\n\n const columnDefinitions: string[] = [];\n\n // Add column definitions\n for (const [columnName, columnDef] of Object.entries(columns)) {\n let def = `${renderSchemaIdentifier(columnName)} ${columnDef.type}`;\n\n if (columnDef.primaryKey) def += ' PRIMARY KEY';\n if (columnDef.unique && !columnDef.primaryKey) def += ' UNIQUE';\n if (columnDef.notNull) def += ' NOT NULL';\n if (columnDef.defaultValue !== undefined) {\n def += ` DEFAULT ${columnDef.defaultValue}`;\n }\n if (columnDef.check) def += ` CHECK (${columnDef.check})`;\n\n columnDefinitions.push(def);\n }\n\n // Add foreign key constraints\n for (const fk of foreignKeys) {\n let fkDef = `FOREIGN KEY (${renderIdentifierList(fk.column)}) REFERENCES ${renderSchemaIdentifier(fk.referencesTable)}(${renderIdentifierList(fk.referencesColumn)})`;\n if (fk.onDelete) fkDef += ` ON DELETE ${fk.onDelete}`;\n if (fk.onUpdate) fkDef += ` ON UPDATE ${fk.onUpdate}`;\n columnDefinitions.push(fkDef);\n }\n\n const createTableSQL = `CREATE TABLE ${renderSchemaIdentifier(tableName)} (\\n ${columnDefinitions.join(',\\n ')}\\n)`;\n await db.query(createTableSQL);\n }\n\n /**\n * Create index from definition\n */\n private async createIndex(\n db: DatabaseInterface,\n tableName: string,\n index: IndexDefinition,\n ): Promise<void> {\n const uniqueClause = index.unique ? 'UNIQUE ' : '';\n const whereClause = index.where ? ` WHERE ${index.where}` : '';\n const createIndexSQL = `CREATE ${uniqueClause}INDEX ${renderSchemaIdentifier(index.name)} ON ${renderSchemaIdentifier(tableName)} (${index.columns.map((column) => renderIndexTerm(column)).join(', ')})${whereClause}`;\n\n await db.query(createIndexSQL);\n }\n\n /**\n * Create trigger from definition\n */\n private async createTrigger(\n db: DatabaseInterface,\n trigger: TriggerDefinition,\n ): Promise<void> {\n const conditionClause = trigger.condition\n ? ` WHEN ${trigger.condition}`\n : '';\n const createTriggerSQL = `CREATE TRIGGER ${renderSchemaIdentifier(trigger.name)} ${trigger.when} ${trigger.event} ON ${renderSchemaIdentifier(trigger.table)}${conditionClause} BEGIN ${trigger.body} END`;\n\n await db.query(createTriggerSQL);\n }\n\n /**\n * Update schema if changes are detected\n */\n private async updateSchemaIfNeeded(\n _db: DatabaseInterface,\n schema: SchemaDefinition,\n ): Promise<void> {\n // For now, just log that update is needed\n // In future, implement ALTER TABLE logic\n console.log(\n `[schema] Schema update logic not yet implemented for ${schema.tableName}`,\n );\n }\n\n /**\n * Build dependency graph from schemas\n */\n private buildDependencyGraph(\n schemas: Record<string, SchemaDefinition>,\n ): Map<string, string[]> {\n const graph = new Map<string, string[]>();\n\n for (const [schemaName, schema] of Object.entries(schemas)) {\n const dependencies = schema.dependencies.filter((dep) =>\n Object.values(schemas).some((s) => s.tableName === dep),\n );\n graph.set(\n schemaName,\n dependencies.map(\n (dep) =>\n Object.entries(schemas).find(\n ([_, s]) => s.tableName === dep,\n )?.[0] || dep,\n ),\n );\n }\n\n return graph;\n }\n\n /**\n * Resolve dependencies using topological sort\n */\n private resolveDependencies(graph: Map<string, string[]>): string[] {\n const resolved: string[] = [];\n const visited = new Set<string>();\n const visiting = new Set<string>();\n\n const visit = (node: string) => {\n if (visiting.has(node)) {\n throw new Error(`Circular dependency detected involving ${node}`);\n }\n if (visited.has(node)) return;\n\n visiting.add(node);\n const dependencies = graph.get(node) || [];\n\n for (const dep of dependencies) {\n if (graph.has(dep)) {\n visit(dep);\n }\n }\n\n visiting.delete(node);\n visited.add(node);\n resolved.push(node);\n };\n\n for (const node of graph.keys()) {\n if (!visited.has(node)) {\n visit(node);\n }\n }\n\n return resolved;\n }\n\n /**\n * Check if schema is up to date\n */\n private isSchemaUpToDate(schemaName: string, version: string): boolean {\n return (\n this.initializedSchemas.has(schemaName) &&\n this.schemaVersions.get(schemaName) === version\n );\n }\n\n /**\n * Mark schema as initialized\n */\n private markSchemaInitialized(schemaName: string, version: string): void {\n this.initializedSchemas.add(schemaName);\n this.schemaVersions.set(schemaName, version);\n }\n\n /**\n * Reset initialization state (for testing)\n */\n reset(): void {\n this.initializedSchemas.clear();\n this.schemaVersions.clear();\n DatabaseSchemaManager.initializationLock.clear();\n }\n}\n"],"mappings":"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"}