@prisma-next/sql-relational-core 0.16.0-dev.3 → 0.16.0-dev.31

package/src/ast/types.ts

@@ -1,7 +1,11 @@
 import type { ParamSpec } from '@prisma-next/operations';
 import type { SqlLoweringSpec } from '@prisma-next/sql-operations';
+
 import { ifDefined } from '@prisma-next/utils/defined';
-import type { CodecRef } from './codec-types';
+import { InternalError } from '@prisma-next/utils/internal-error';
+import { structuredError } from '@prisma-next/utils/structured-error';
+import { type CodecRef, frozenCodecRef } from './codec-types';
+import type { AnyJsonValueProjection } from './json-value-projection';
 
 export type Direction = 'asc' | 'desc';
 
@@ -50,6 +54,9 @@ export interface ExprVisitor<R> {
   operation(expr: OperationExpr): R;
   aggregate(expr: AggregateExpr): R;
   windowFunc(expr: WindowFuncExpr): R;
+  functionCall(expr: FunctionCallExpr): R;
+  cast(expr: CastExpr): R;
+  case(expr: CaseExpr): R;
   jsonObject(expr: JsonObjectExpr): R;
   jsonArrayAgg(expr: JsonArrayAggExpr): R;
   binary(expr: BinaryExpr): R;
@@ -65,6 +72,31 @@ export interface ExprVisitor<R> {
   rawExpr(expr: RawExpr): R;
 }
 
+const toAnyExpressionVisitor: ExprVisitor<AnyExpression> = {
+  columnRef: (expr) => expr,
+  identifierRef: (expr) => expr,
+  subquery: (expr) => expr,
+  operation: (expr) => expr,
+  aggregate: (expr) => expr,
+  windowFunc: (expr) => expr,
+  functionCall: (expr) => expr,
+  cast: (expr) => expr,
+  case: (expr) => expr,
+  jsonObject: (expr) => expr,
+  jsonArrayAgg: (expr) => expr,
+  binary: (expr) => expr,
+  and: (expr) => expr,
+  or: (expr) => expr,
+  exists: (expr) => expr,
+  nullCheck: (expr) => expr,
+  not: (expr) => expr,
+  literal: (expr) => expr,
+  param: (expr) => expr,
+  preparedParam: (expr) => expr,
+  list: (expr) => expr,
+  rawExpr: (expr) => expr,
+};
+
 export interface ExpressionFolder<T> {
   empty: T;
   combine(a: T, b: T): T;
@@ -85,7 +117,7 @@ export type JoinOnExpr = EqColJoinOn | AnyExpression;
 export type WhereArg = AnyExpression | ToWhereExpr;
 export type JsonObjectEntry = {
   readonly key: string;
-  readonly value: ProjectionExpr;
+  readonly value: AnyJsonValueProjection;
 };
 
 function frozenArrayCopy<T>(values: readonly T[]): ReadonlyArray<T> {
@@ -102,18 +134,6 @@ function frozenRecordCopy<T>(record: Readonly<Record<string, T>>): Readonly<Reco
   return Object.freeze({ ...record });
 }
 
-function frozenCodecRef(codec: CodecRef): CodecRef {
-  const typeParams =
-    codec.typeParams === undefined
-      ? undefined
-      : (structuredClone(codec.typeParams) as CodecRef['typeParams']);
-  const base = {
-    codecId: codec.codecId,
-    ...ifDefined('typeParams', typeParams),
-  };
-  return Object.freeze(codec.many ? { ...base, many: true } : base);
-}
-
 function freezeRows(
   rows: ReadonlyArray<Record<string, InsertValue>>,
 ): ReadonlyArray<Readonly<Record<string, InsertValue>>> {
@@ -242,7 +262,7 @@ function rewriteUpdateSet(
 ): Record<string, AnyExpression> {
   const result: Record<string, AnyExpression> = {};
   for (const [key, value] of Object.entries(set)) {
-    result[key] = value.rewrite(rewriter as ExpressionRewriter);
+    result[key] = value.rewrite(rewriter);
   }
   return result;
 }
@@ -250,9 +270,13 @@ function rewriteUpdateSet(
 function rewriteLimitOffset<T extends number | AnyExpression | undefined>(
   value: T,
   rewriter: AstRewriter,
-): T {
+): T;
+function rewriteLimitOffset(
+  value: number | AnyExpression | undefined,
+  rewriter: AstRewriter,
+): number | AnyExpression | undefined {
   if (value === undefined || typeof value === 'number') return value;
-  return value.rewrite(rewriter) as T;
+  return value.rewrite(rewriter);
 }
 
 function rewriteOnConflict(onConflict: InsertOnConflict, rewriter: AstRewriter): InsertOnConflict {
@@ -303,15 +327,19 @@ abstract class Expression extends AstNode implements ExpressionSource {
   }
 
   baseColumnRef(): ColumnRef {
-    throw new Error(`${this.constructor.name} does not expose a base column reference`);
+    throw new InternalError(`${this.constructor.name} does not expose a base column reference`);
+  }
+
+  #asAnyExpression(): AnyExpression {
+    return this.accept(toAnyExpressionVisitor);
   }
 
   toExpr(): AnyExpression {
-    return this as unknown as AnyExpression;
+    return this.#asAnyExpression();
   }
 
   not(): NotExpr {
-    return new NotExpr(this as unknown as AnyExpression);
+    return new NotExpr(this.#asAnyExpression());
   }
 }
 
@@ -380,28 +408,65 @@ export class DerivedTableSource extends FromSource {
   }
 }
 
+export interface FunctionSourceAlias {
+  readonly alias: string;
+  readonly columnAliases?: ReadonlyArray<string>;
+}
+
 export class FunctionSource extends FromSource {
   readonly kind = 'function-source' as const;
   readonly fn: string;
   readonly args: ReadonlyArray<AnyExpression>;
   readonly alias: string | undefined;
-
-  protected constructor(fn: string, args: ReadonlyArray<AnyExpression>, alias?: string) {
+  readonly columnAliases: ReadonlyArray<string> | undefined;
+  readonly ordinality: boolean;
+
+  protected constructor(
+    fn: string,
+    args: ReadonlyArray<AnyExpression>,
+    alias?: FunctionSourceAlias,
+    ordinality = false,
+  ) {
     super();
+    if (alias?.columnAliases?.length === 0) {
+      throw structuredError('SQL.AST_INVALID', 'FunctionSource column aliases must not be empty', {
+        meta: { kind: 'function-source', field: 'columnAliases' },
+      });
+    }
     this.fn = fn;
     this.args = frozenArrayCopy(args);
-    this.alias = alias;
+    this.alias = alias?.alias;
+    this.columnAliases =
+      alias?.columnAliases === undefined ? undefined : frozenArrayCopy(alias.columnAliases);
+    this.ordinality = ordinality;
     this.freeze();
   }
 
-  static of(fn: string, args: ReadonlyArray<AnyExpression>, alias?: string): FunctionSource {
+  static of(
+    fn: string,
+    args: ReadonlyArray<AnyExpression>,
+    alias?: FunctionSourceAlias,
+  ): FunctionSource {
     return new FunctionSource(fn, args, alias);
   }
 
+  #aliasOptions(): FunctionSourceAlias | undefined {
+    if (this.alias === undefined) return undefined;
+    return {
+      alias: this.alias,
+      ...ifDefined('columnAliases', this.columnAliases),
+    };
+  }
+
+  withOrdinality(): FunctionSource {
+    if (this.ordinality) return this;
+    return new FunctionSource(this.fn, this.args, this.#aliasOptions(), true);
+  }
+
   override rewrite(rewriter: AstRewriter): AnyFromSource {
     const rewrittenArgs = this.args.map((arg) => rewriteComparable(arg, rewriter));
     if (rewrittenArgs.every((arg, i) => arg === this.args[i])) return this;
-    return new FunctionSource(this.fn, rewrittenArgs, this.alias);
+    return new FunctionSource(this.fn, rewrittenArgs, this.#aliasOptions(), this.ordinality);
   }
 
   override toFromSource(): AnyFromSource {
@@ -648,9 +713,7 @@ export class OperationExpr extends Expression {
     return new OperationExpr({
       method: this.method,
       self: this.self.rewrite(rewriter),
-      args: this.args.map((arg) => rewriteComparable(arg, rewriter)) as ReadonlyArray<
-        AnyExpression | ParamRef | LiteralExpr
-      >,
+      args: this.args.map((arg) => rewriteComparable(arg, rewriter)),
       returns: this.returns,
       lowering: this.lowering,
     });
@@ -712,7 +775,11 @@ export class AggregateExpr extends Expression {
   constructor(fn: AggregateFn, expr?: AnyExpression) {
     super();
     if (fn !== 'count' && expr === undefined) {
-      throw new Error(`Aggregate function "${fn}" requires an expression`);
+      throw structuredError(
+        'ORM.ARGUMENT_INVALID',
+        `Aggregate function "${fn}" requires an expression`,
+        { meta: { fn } },
+      );
     }
     this.fn = fn;
     this.expr = expr;
@@ -825,6 +892,129 @@ export class WindowFuncExpr extends Expression {
   }
 }
 
+export class FunctionCallExpr extends Expression {
+  readonly kind = 'function-call' as const;
+  readonly fn: string;
+  readonly args: ReadonlyArray<AnyExpression>;
+
+  constructor(fn: string, args: ReadonlyArray<AnyExpression>) {
+    super();
+    this.fn = fn;
+    this.args = frozenArrayCopy(args);
+    this.freeze();
+  }
+
+  static of(fn: string, args: ReadonlyArray<AnyExpression>): FunctionCallExpr {
+    return new FunctionCallExpr(fn, args);
+  }
+
+  override accept<R>(visitor: ExprVisitor<R>): R {
+    return visitor.functionCall(this);
+  }
+
+  override rewrite(rewriter: ExpressionRewriter): AnyExpression {
+    return new FunctionCallExpr(
+      this.fn,
+      this.args.map((arg) => arg.rewrite(rewriter)),
+    );
+  }
+
+  override fold<T>(folder: ExpressionFolder<T>): T {
+    return combineAll(
+      folder,
+      this.args.map((arg) => () => arg.fold(folder)),
+    );
+  }
+}
+
+export class CastExpr extends Expression {
+  readonly kind = 'cast' as const;
+  readonly expr: AnyExpression;
+  readonly targetType: string;
+
+  constructor(expr: AnyExpression, targetType: string) {
+    super();
+    this.expr = expr;
+    this.targetType = targetType;
+    this.freeze();
+  }
+
+  static as(expr: AnyExpression, targetType: string): CastExpr {
+    return new CastExpr(expr, targetType);
+  }
+
+  override accept<R>(visitor: ExprVisitor<R>): R {
+    return visitor.cast(this);
+  }
+
+  override rewrite(rewriter: ExpressionRewriter): AnyExpression {
+    return new CastExpr(this.expr.rewrite(rewriter), this.targetType);
+  }
+
+  override fold<T>(folder: ExpressionFolder<T>): T {
+    return this.expr.fold(folder);
+  }
+}
+
+export interface CaseBranch {
+  readonly condition: AnyExpression;
+  readonly value: AnyExpression;
+}
+
+export class CaseExpr extends Expression {
+  readonly kind = 'case' as const;
+  readonly branches: ReadonlyArray<Readonly<CaseBranch>>;
+  readonly elseExpr: AnyExpression | undefined;
+
+  constructor(branches: ReadonlyArray<CaseBranch>, elseExpr?: AnyExpression) {
+    super();
+    if (branches.length === 0) {
+      throw structuredError('SQL.AST_INVALID', 'CaseExpr requires at least one branch', {
+        meta: { kind: 'case', field: 'branches' },
+      });
+    }
+    this.branches = Object.freeze(
+      branches.map((branch) =>
+        Object.freeze({
+          condition: branch.condition,
+          value: branch.value,
+        }),
+      ),
+    );
+    this.elseExpr = elseExpr;
+    this.freeze();
+  }
+
+  static of(branches: ReadonlyArray<CaseBranch>, elseExpr?: AnyExpression): CaseExpr {
+    return new CaseExpr(branches, elseExpr);
+  }
+
+  override accept<R>(visitor: ExprVisitor<R>): R {
+    return visitor.case(this);
+  }
+
+  override rewrite(rewriter: ExpressionRewriter): AnyExpression {
+    return new CaseExpr(
+      this.branches.map((branch) => ({
+        condition: branch.condition.rewrite(rewriter),
+        value: branch.value.rewrite(rewriter),
+      })),
+      this.elseExpr?.rewrite(rewriter),
+    );
+  }
+
+  override fold<T>(folder: ExpressionFolder<T>): T {
+    const elseExpr = this.elseExpr;
+    return combineAll(folder, [
+      ...this.branches.flatMap((branch) => [
+        () => branch.condition.fold(folder),
+        () => branch.value.fold(folder),
+      ]),
+      ...(elseExpr === undefined ? [] : [() => elseExpr.fold(folder)]),
+    ]);
+  }
+}
+
 export class JsonObjectExpr extends Expression {
   readonly kind = 'json-object' as const;
   readonly entries: ReadonlyArray<JsonObjectEntry>;
@@ -835,7 +1025,7 @@ export class JsonObjectExpr extends Expression {
     this.freeze();
   }
 
-  static entry(key: string, value: ProjectionExpr): JsonObjectEntry {
+  static entry(key: string, value: AnyJsonValueProjection): JsonObjectEntry {
     return {
       key,
       value,
@@ -854,12 +1044,7 @@ export class JsonObjectExpr extends Expression {
     return new JsonObjectExpr(
       this.entries.map((entry) => ({
         key: entry.key,
-        value:
-          entry.value.kind === 'literal'
-            ? rewriter.literal
-              ? rewriter.literal(entry.value)
-              : entry.value
-            : entry.value.rewrite(rewriter),
+        value: entry.value.rewrite(rewriter),
       })),
     );
   }
@@ -867,14 +1052,7 @@ export class JsonObjectExpr extends Expression {
   override fold<T>(folder: ExpressionFolder<T>): T {
     return combineAll(
       folder,
-      this.entries.map(
-        (entry) => () =>
-          entry.value.kind === 'literal'
-            ? folder.literal
-              ? folder.literal(entry.value)
-              : folder.empty
-            : entry.value.fold(folder),
-      ),
+      this.entries.map((entry) => () => entry.value.fold(folder)),
     );
   }
 }
@@ -915,12 +1093,12 @@ export class OrderByItem extends AstNode {
 
 export class JsonArrayAggExpr extends Expression {
   readonly kind = 'json-array-agg' as const;
-  readonly expr: AnyExpression;
+  readonly expr: AnyJsonValueProjection;
   readonly onEmpty: 'null' | 'emptyArray';
   readonly orderBy: ReadonlyArray<OrderByItem> | undefined;
 
   constructor(
-    expr: AnyExpression,
+    expr: AnyJsonValueProjection,
     onEmpty: 'null' | 'emptyArray' = 'null',
     orderBy?: ReadonlyArray<OrderByItem>,
   ) {
@@ -932,7 +1110,7 @@ export class JsonArrayAggExpr extends Expression {
   }
 
   static of(
-    expr: AnyExpression,
+    expr: AnyJsonValueProjection,
     onEmpty: 'null' | 'emptyArray' = 'null',
     orderBy?: ReadonlyArray<OrderByItem>,
   ): JsonArrayAggExpr {
@@ -1304,9 +1482,9 @@ export class ProjectionItem extends AstNode {
   readonly alias: string;
   readonly expr: ProjectionExpr;
   /**
-   * Codec identity for the projected cell. Decode-side dispatch resolves the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation collapses repeated lookups for the same logical column onto one shared {@link Codec}.
+   * Codec identity for any known projected result, whether read directly from a contract column or forwarded through a query wrapper. Decode-side dispatch resolves the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation collapses repeated lookups for the same logical result onto one shared {@link Codec}.
    *
-   * Stays `undefined` for non-column-bound projections (computed expressions, subqueries, raw aliases) whose decoded type the runtime cannot infer from a single contract column.
+   * Stays `undefined` only when the projected result's codec is unknown, such as computed expressions, subqueries, or raw aliases whose decoded type the runtime cannot infer.
    */
   readonly codec: CodecRef | undefined;
 
@@ -1949,7 +2127,7 @@ export class RawSqlExpr extends QueryAst {
   constructor(fragments: readonly string[], args: readonly AnyExpression[]) {
     super();
     if (fragments.length !== args.length + 1) {
-      throw new Error(
+      throw new InternalError(
         `RawSqlExpr: fragments.length must equal args.length + 1 (got fragments=${fragments.length}, args=${args.length})`,
       );
     }
@@ -1991,6 +2169,9 @@ export type AnyExpression =
   | OperationExpr
   | AggregateExpr
   | WindowFuncExpr
+  | FunctionCallExpr
+  | CastExpr
+  | CaseExpr
   | JsonObjectExpr
   | JsonArrayAggExpr
   | ListExpression
@@ -2027,7 +2208,8 @@ export function isQueryAst(value: unknown): value is AnyQueryAst {
     typeof value === 'object' &&
     value !== null &&
     'kind' in value &&
-    queryAstKinds.has((value as { kind: string }).kind)
+    typeof value.kind === 'string' &&
+    queryAstKinds.has(value.kind)
   );
 }
 
@@ -2036,7 +2218,8 @@ export function isWhereExpr(value: unknown): value is AnyExpression {
     typeof value === 'object' &&
     value !== null &&
     'kind' in value &&
-    whereExprKinds.has((value as { kind: string }).kind)
+    typeof value.kind === 'string' &&
+    whereExprKinds.has(value.kind)
   );
 }
 

package/src/codec-descriptor-registry.ts

@@ -1,5 +1,6 @@
 import type { CodecDescriptor, CodecRef } from '@prisma-next/framework-components/codec';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { structuredError } from '@prisma-next/utils/structured-error';
 import type { AnyCodecDescriptor } from './ast/codec-types';
 import { codecRefForStorageColumn } from './codec-ref-for-column';
 import type { CodecDescriptorRegistry } from './query-lane-context';
@@ -24,9 +25,11 @@ export function buildCodecDescriptorRegistry(
 
   for (const descriptor of allDescriptors) {
     if (byId.has(descriptor.codecId)) {
-      throw new Error(
+      throw structuredError(
+        'RUNTIME.DUPLICATE_CODEC',
         `Duplicate codec descriptor id: '${descriptor.codecId}' — registered twice during registry construction. ` +
           'Each codecId must be contributed by exactly one component (target / adapter / extension pack).',
+        { meta: { codecId: descriptor.codecId } },
       );
     }
     const widened = descriptor as unknown as AnyDescriptor;

package/src/contract-free/table.ts

@@ -1,5 +1,6 @@
 import type { ParamSpec } from '@prisma-next/operations';
 import { blindCast } from '@prisma-next/utils/casts';
+import { structuredError } from '@prisma-next/utils/structured-error';
 import {
   AggregateExpr,
   AndExpr,
@@ -218,7 +219,10 @@ export class CfExprSelectQuery {
 
   build(): SelectAst {
     if (this.joinItems.length > 0 && this.src === undefined) {
-      throw new Error('CfExprSelectQuery: cannot add a JOIN without a FROM clause');
+      throw structuredError(
+        'ORM.ARGUMENT_INVALID',
+        'CfExprSelectQuery: cannot add a JOIN without a FROM clause',
+      );
     }
     const base =
       this.src !== undefined

package/src/exports/ast.ts

@@ -2,6 +2,7 @@ export * from '../ast/adapter-types';
 export * from '../ast/codec-types';
 export * from '../ast/ddl-types';
 export * from '../ast/driver-types';
+export * from '../ast/json-value-projection';
 export * from '../ast/sql-codec-helpers';
 export * from '../ast/sql-codecs';
 export * from '../ast/types';

package/dist/codec-types-C8vFGWij.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-types-C8vFGWij.d.mts","names":[],"sources":["../src/ast/codec-types.ts"],"mappings":";;;;;;;UAqBiB;WACN;WACA;;;;;;;UAQM,4BAA4B;WAClC,SAAS;;;;;;;;;;;UAYH,gCAAgC;WACtC,QAAQ;aAAyB;aAAwB;;;;;;UAMnD;WACN;aACE;eACE;iBACE;;;;;;;;;;;;UAaA,QACf,4BACA,yBAAyB,wBAAwB,cACjD,iBACA,0BACQ,MAAU,IAAI,SAAS,OAAO;EACtC,OAAO,OAAO,QAAQ,KAAK,sBAAsB,QAAQ;EACzD,OAAO,MAAM,OAAO,KAAK,sBAAsB,QAAQ;;;;;;;;;UAUxC;;;;;;EAMf,UAAU,qBAAqB,eAAe,iBAAiB;;;;;;EAO/D,YAAY,KAAK,WAAW;;;;;;KAQlB,qBAAqB;KAE5B,wBAAwB,KAC3B,UAAU,sBAAsB,MAAM,WAAW,WAAW;KAElD,kBAAkB,KAAK,UAAU,qBAAqB;KAEtD,qBAAqB,KAC/B,wBAAwB,WAAW,uBAA2B,6BAA6B,MACvF;;;;;;;KASM,sBAAsB,KAAK;WAC5B,cAAc,yBAAyB;IAE9C,kBAAkB;;;;;;KAQV,kBACV,gCACY,WAAW,cAAc,wBACjC,oCAEM,WAAW,eAAe,kBAAkB,YAAY;WACvD,OAAO,qBAAqB,YAAY;WACxC,QAAQ,qBAAqB,YAAY;WACzC,QAAQ,sBAAsB,YAAY"}

package/dist/ddl-types-DFKQr_qQ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ddl-types-DFKQr_qQ.mjs","names":[],"sources":["../src/ast/ddl-types.ts"],"sourcesContent":["import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';\nimport { isColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';\nimport type { ReferentialAction } from '@prisma-next/sql-contract/types';\nimport type { CodecRef } from './codec-types';\nimport type { AnyParamRef } from './types';\n\n/**\n * Render-time context the column-default visitor needs to make dialect\n * decisions that depend on the parent column. Today only the parent\n * column's native type (`\"jsonb\"`, `\"text\"`, …) — the Postgres renderer\n * uses it to decide whether to emit a `::jsonb` / `::json` cast on JSON\n * literal defaults so the emitted DDL matches the column type without\n * relying on Postgres's implicit text → jsonb cast at default-evaluation\n * time. Additional fields can join without re-shaping the interface.\n */\nexport interface DdlColumnRenderContext {\n  readonly nativeType: string;\n}\n\nexport interface DdlColumnDefaultVisitor<R> {\n  literal(node: LiteralColumnDefault, ctx: DdlColumnRenderContext): R;\n  function(node: FunctionColumnDefault, ctx: DdlColumnRenderContext): R;\n}\n\nexport abstract class DdlColumnDefault {\n  abstract readonly kind: string;\n  abstract accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R;\n\n  protected freeze(): void {\n    Object.freeze(this);\n  }\n}\n\nexport class LiteralColumnDefault extends DdlColumnDefault {\n  readonly kind = 'literal' as const;\n  readonly value: ColumnDefaultLiteralInputValue;\n\n  constructor(value: ColumnDefaultLiteralInputValue) {\n    super();\n    if (!isColumnDefaultLiteralInputValue(value)) {\n      throw new Error('Invalid column default literal value');\n    }\n    this.value = value;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R {\n    return visitor.literal(this, ctx);\n  }\n}\n\nexport class FunctionColumnDefault extends DdlColumnDefault {\n  readonly kind = 'function' as const;\n  readonly expression: string;\n\n  constructor(expression: string) {\n    super();\n    this.expression = expression;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R {\n    return visitor.function(this, ctx);\n  }\n}\n\nexport type AnyDdlColumnDefault = LiteralColumnDefault | FunctionColumnDefault;\n\nexport class DdlColumn {\n  readonly name: string;\n  readonly type: string;\n  readonly notNull?: boolean | undefined;\n  readonly primaryKey?: boolean | undefined;\n  readonly default?: AnyDdlColumnDefault | undefined;\n  /** Codec identity for this column. When present, the DDL walker resolves the codec via `codecLookup.get(codecRef.codecId)` and calls `codec.encode(default.value, {})` to obtain the wire value before inlining the literal default into the DDL string. When absent, literal defaults follow RawSqlLiteral wire-scalar semantics (string / number / boolean / bigint / null / Uint8Array / Date inlined directly). */\n  readonly codecRef?: CodecRef | undefined;\n\n  constructor(options: {\n    readonly name: string;\n    readonly type: string;\n    readonly notNull?: boolean;\n    readonly primaryKey?: boolean;\n    readonly default?: AnyDdlColumnDefault;\n    readonly codecRef?: CodecRef;\n  }) {\n    this.name = options.name;\n    this.type = options.type;\n    this.notNull = options.notNull;\n    this.primaryKey = options.primaryKey;\n    this.default = options.default;\n    this.codecRef = options.codecRef;\n    Object.freeze(this);\n  }\n}\n\nexport abstract class DdlNode {\n  abstract readonly kind: string;\n\n  /**\n   * Structural brand: every DDL node answers `true`. Lets {@link isDdlNode}\n   * recognise any `DdlNode` subclass — including target-contributed kinds —\n   * without a central kind registry that subclasses would have to register\n   * into.\n   */\n  isDdlNode(): true {\n    return true;\n  }\n\n  protected freeze(): void {\n    Object.freeze(this);\n  }\n\n  collectParamRefs(): AnyParamRef[] {\n    return [];\n  }\n}\n\nexport function isDdlNode(value: unknown): value is DdlNode {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'isDdlNode' in value &&\n    typeof value.isDdlNode === 'function'\n  );\n}\n\n// ---------------------------------------------------------------------------\n// Table-level constraint nodes\n// ---------------------------------------------------------------------------\n\n/**\n * A composite (or single-column) PRIMARY KEY constraint on a `CreateTable`\n * node. When `name` is set, the adapter renders `CONSTRAINT <name> PRIMARY KEY\n * (…)`; otherwise it renders an anonymous `PRIMARY KEY (…)`.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class PrimaryKeyConstraint {\n  readonly kind = 'primary-key' as const;\n  readonly columns: ReadonlyArray<string>;\n  readonly name: string | undefined;\n\n  constructor(options: { readonly columns: readonly string[]; readonly name?: string }) {\n    this.columns = Object.freeze([...options.columns]);\n    this.name = options.name;\n    Object.freeze(this);\n  }\n}\n\n/**\n * A FOREIGN KEY constraint on a `CreateTable` node. `onDelete` and `onUpdate`\n * use the same `ReferentialAction` vocabulary already used by the migration\n * planner and the contract IR — no parallel string enum.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class ForeignKeyConstraint {\n  readonly kind = 'foreign-key' as const;\n  readonly columns: ReadonlyArray<string>;\n  readonly refTable: string;\n  readonly refColumns: ReadonlyArray<string>;\n  readonly onDelete: ReferentialAction | undefined;\n  readonly onUpdate: ReferentialAction | undefined;\n  readonly name: string | undefined;\n\n  constructor(options: {\n    readonly columns: readonly string[];\n    readonly refTable: string;\n    readonly refColumns: readonly string[];\n    readonly onDelete?: ReferentialAction;\n    readonly onUpdate?: ReferentialAction;\n    readonly name?: string;\n  }) {\n    this.columns = Object.freeze([...options.columns]);\n    this.refTable = options.refTable;\n    this.refColumns = Object.freeze([...options.refColumns]);\n    this.onDelete = options.onDelete;\n    this.onUpdate = options.onUpdate;\n    this.name = options.name;\n    Object.freeze(this);\n  }\n}\n\n/**\n * A table-level UNIQUE constraint on a `CreateTable` node. When `name` is\n * set, the adapter renders `CONSTRAINT <name> UNIQUE (…)`; otherwise it\n * renders an anonymous `UNIQUE (…)`.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class UniqueConstraint {\n  readonly kind = 'unique' as const;\n  readonly columns: ReadonlyArray<string>;\n  readonly name: string | undefined;\n\n  constructor(options: { readonly columns: readonly string[]; readonly name?: string }) {\n    this.columns = Object.freeze([...options.columns]);\n    this.name = options.name;\n    Object.freeze(this);\n  }\n}\n\n/**\n * A table-level CHECK constraint carrying a raw SQL predicate expression. Used\n * for checks that are not enum value-set restrictions — e.g. the element-non-null\n * constraint on a scalar-array column (`array_position(col, NULL) IS NULL`).\n * The `expression` is emitted verbatim, so callers must supply safe,\n * pre-validated SQL.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class CheckExpressionConstraint {\n  readonly kind = 'check-expression' as const;\n  readonly name: string;\n  readonly expression: string;\n\n  constructor(options: { readonly name: string; readonly expression: string }) {\n    this.name = options.name;\n    this.expression = options.expression;\n    Object.freeze(this);\n  }\n}\n\nexport type DdlTableConstraint =\n  | PrimaryKeyConstraint\n  | ForeignKeyConstraint\n  | UniqueConstraint\n  | CheckExpressionConstraint;\n"],"mappings":";;AAwBA,IAAsB,mBAAtB,MAAuC;CAIrC,SAAyB;EACvB,OAAO,OAAO,IAAI;CACpB;AACF;AAEA,IAAa,uBAAb,cAA0C,iBAAiB;CACzD,OAAgB;CAChB;CAEA,YAAY,OAAuC;EACjD,MAAM;EACN,IAAI,CAAC,iCAAiC,KAAK,GACzC,MAAM,IAAI,MAAM,sCAAsC;EAExD,KAAK,QAAQ;EACb,KAAK,OAAO;CACd;CAEA,OAAmB,SAAqC,KAAgC;EACtF,OAAO,QAAQ,QAAQ,MAAM,GAAG;CAClC;AACF;AAEA,IAAa,wBAAb,cAA2C,iBAAiB;CAC1D,OAAgB;CAChB;CAEA,YAAY,YAAoB;EAC9B,MAAM;EACN,KAAK,aAAa;EAClB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAqC,KAAgC;EACtF,OAAO,QAAQ,SAAS,MAAM,GAAG;CACnC;AACF;AAIA,IAAa,YAAb,MAAuB;CACrB;CACA;CACA;CACA;CACA;;CAEA;CAEA,YAAY,SAOT;EACD,KAAK,OAAO,QAAQ;EACpB,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,aAAa,QAAQ;EAC1B,KAAK,UAAU,QAAQ;EACvB,KAAK,WAAW,QAAQ;EACxB,OAAO,OAAO,IAAI;CACpB;AACF;AAEA,IAAsB,UAAtB,MAA8B;;;;;;;CAS5B,YAAkB;EAChB,OAAO;CACT;CAEA,SAAyB;EACvB,OAAO,OAAO,IAAI;CACpB;CAEA,mBAAkC;EAChC,OAAO,CAAC;CACV;AACF;AAEA,SAAgB,UAAU,OAAkC;CAC1D,OACE,OAAO,UAAU,YACjB,UAAU,QACV,eAAe,SACf,OAAO,MAAM,cAAc;AAE/B;;;;;;;;AAaA,IAAa,uBAAb,MAAkC;CAChC,OAAgB;CAChB;CACA;CAEA,YAAY,SAA0E;EACpF,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACpB;AACF;;;;;;;;AASA,IAAa,uBAAb,MAAkC;CAChC,OAAgB;CAChB;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,SAOT;EACD,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,WAAW,QAAQ;EACxB,KAAK,aAAa,OAAO,OAAO,CAAC,GAAG,QAAQ,UAAU,CAAC;EACvD,KAAK,WAAW,QAAQ;EACxB,KAAK,WAAW,QAAQ;EACxB,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACpB;AACF;;;;;;;;AASA,IAAa,mBAAb,MAA8B;CAC5B,OAAgB;CAChB;CACA;CAEA,YAAY,SAA0E;EACpF,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACpB;AACF;;;;;;;;;;AAWA,IAAa,4BAAb,MAAuC;CACrC,OAAgB;CAChB;CACA;CAEA,YAAY,SAAiE;EAC3E,KAAK,OAAO,QAAQ;EACpB,KAAK,aAAa,QAAQ;EAC1B,OAAO,OAAO,IAAI;CACpB;AACF"}

package/dist/ddl-types-DzaZCtFT.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ddl-types-DzaZCtFT.d.mts","names":[],"sources":["../src/ast/ddl-types.ts"],"mappings":";;;;;;;;;;;;;;UAeiB;WACN;;UAGM,wBAAwB;EACvC,QAAQ,MAAM,sBAAsB,KAAK,yBAAyB;EAClE,SAAS,MAAM,uBAAuB,KAAK,yBAAyB;;uBAGhD;oBACF;WACT,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;YAE5E;;cAKC,6BAA6B;WAC/B;WACA,OAAO;cAEJ,OAAO;EASV,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;;cAK3E,8BAA8B;WAChC;WACA;cAEG;EAMH,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;;KAK5E,sBAAsB,uBAAuB;cAE5C;WACF;WACA;WACA;WACA;WACA,UAAU;;WAEV,WAAW;cAER;aACD;aACA;aACA;aACA;aACA,UAAU;aACV,WAAW;;;uBAYF;oBACF;;;;;;;EAQlB;YAIU;EAIV,oBAAoB;;iBAKN,UAAU,iBAAiB,SAAS;;;;;;;;cAoBvC;WACF;WACA,SAAS;WACT;cAEG;aAAoB;aAAqC;;;;;;;;;;cAc1D;WACF;WACA,SAAS;WACT;WACA,YAAY;WACZ,UAAU;WACV,UAAU;WACV;cAEG;aACD;aACA;aACA;aACA,WAAW;aACX,WAAW;aACX;;;;;;;;;;cAmBA;WACF;WACA,SAAS;WACT;cAEG;aAAoB;aAAqC;;;;;;;;;;;;cAgB1D;WACF;WACA;WACA;cAEG;aAAoB;aAAuB;;;KAO7C,qBACR,uBACA,uBACA,mBACA"}

package/dist/types-Dr3jep6j.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-Dr3jep6j.d.mts","names":[],"sources":["../src/ast/types.ts"],"mappings":"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"}