@prisma-next/sql-relational-core 0.13.0 → 0.14.0

package/src/contract-free/table.ts

@@ -1,19 +1,28 @@
+import type { ParamSpec } from '@prisma-next/operations';
 import { blindCast } from '@prisma-next/utils/casts';
 import {
+  AggregateExpr,
   AndExpr,
   type AnyExpression,
+  type AnyFromSource,
   BinaryExpr,
   ColumnRef,
+  ExistsExpr,
+  IdentifierRef,
   InsertAst,
   InsertOnConflict,
   type InsertValue,
+  JoinAst,
+  LiteralExpr,
   NullCheckExpr,
+  OperationExpr,
   OrderByItem,
   OrExpr,
   ParamRef,
   ProjectionItem,
+  RawExpr,
   SelectAst,
-  type TableSource,
+  TableSource,
   UpdateAst,
 } from '../ast/types';
 
@@ -43,6 +52,187 @@ export class CfExpr {
   not(): CfExpr {
     return new CfExpr(this.ast.not());
   }
+
+  isNull(): CfExpr {
+    return new CfExpr(NullCheckExpr.isNull(this.ast));
+  }
+
+  isNotNull(): CfExpr {
+    return new CfExpr(NullCheckExpr.isNotNull(this.ast));
+  }
+
+  eqLit(value: number | string | boolean): CfExpr {
+    return new CfExpr(BinaryExpr.eq(this.ast, LiteralExpr.of(value)));
+  }
+
+  gtLit(value: number | string | boolean): CfExpr {
+    return new CfExpr(BinaryExpr.gt(this.ast, LiteralExpr.of(value)));
+  }
+
+  eqParam(value: unknown, codecId: string): CfExpr {
+    return new CfExpr(BinaryExpr.eq(this.ast, ParamRef.of(value, { codec: { codecId } })));
+  }
+
+  eqExpr(other: CfExpr): CfExpr {
+    return new CfExpr(BinaryExpr.eq(this.ast, other.ast));
+  }
+}
+
+export interface CfFnOptions {
+  readonly method: string;
+  readonly template: string;
+  readonly self: CfExpr;
+  readonly args?: ReadonlyArray<CfExpr>;
+  readonly returns: ParamSpec;
+}
+
+export const cfExpr = {
+  countStar(): CfExpr {
+    return new CfExpr(AggregateExpr.count());
+  },
+  lit(value: number | string | boolean): CfExpr {
+    return new CfExpr(LiteralExpr.of(value));
+  },
+  identifierRef(name: string): CfExpr {
+    return new CfExpr(IdentifierRef.of(name));
+  },
+  param(value: unknown, codecId: string): CfExpr {
+    return new CfExpr(ParamRef.of(value, { codec: { codecId } }));
+  },
+  /**
+   * Catalog function call lowered via a `'function'`-strategy template
+   * (e.g. `to_regclass({{self}})`). Owns the `OperationExpr` assembly so
+   * target packages only supply vocabulary: template, codec'd operands,
+   * and return spec.
+   */
+  fn(options: CfFnOptions): CfExpr {
+    return new CfExpr(
+      new OperationExpr({
+        method: options.method,
+        self: options.self.ast,
+        args: options.args?.map((arg) => arg.ast),
+        returns: options.returns,
+        lowering: {
+          targetFamily: 'sql',
+          strategy: 'function',
+          template: options.template,
+        },
+      }),
+    );
+  },
+  columnRef(qualifier: string, name: string): CfExpr {
+    return new CfExpr(ColumnRef.of(qualifier, name));
+  },
+  allOf(exprs: ReadonlyArray<CfExpr>): CfExpr {
+    return new CfExpr(AndExpr.of(exprs.map((expr) => expr.ast)));
+  },
+  /**
+   * Opaque DB-side SQL expression (e.g. `current_schema()`) carried as a
+   * `RawExpr`. For zero-operand catalog functions where a `'function'`
+   * lowering template has nothing to substitute.
+   */
+  raw(sql: string, returns: ParamSpec): CfExpr {
+    return new CfExpr(new RawExpr({ parts: [sql], returns }));
+  },
+  exists(query: CfExprSelectQuery): CfExpr {
+    return new CfExpr(ExistsExpr.exists(query.build()));
+  },
+  notExists(query: CfExprSelectQuery): CfExpr {
+    return new CfExpr(ExistsExpr.notExists(query.build()));
+  },
+};
+
+/** Aliased table source for catalog queries (no namespace coordinate). */
+export function cfTable(name: string, alias?: string): TableSource {
+  return TableSource.named(name, alias);
+}
+
+export class CfExprSelectQuery {
+  constructor(
+    private readonly src: AnyFromSource | undefined,
+    private readonly projectionItems: ReadonlyArray<ProjectionItem>,
+    private readonly whereExpr: CfExpr | undefined,
+    private readonly joinItems: ReadonlyArray<JoinAst> = [],
+    private readonly limitValue: number | undefined = undefined,
+  ) {}
+
+  from(source: AnyFromSource): CfExprSelectQuery {
+    return new CfExprSelectQuery(
+      source,
+      this.projectionItems,
+      this.whereExpr,
+      this.joinItems,
+      this.limitValue,
+    );
+  }
+
+  join(source: AnyFromSource, on: CfExpr): CfExprSelectQuery {
+    return new CfExprSelectQuery(
+      this.src,
+      this.projectionItems,
+      this.whereExpr,
+      [...this.joinItems, JoinAst.inner(source, on.ast)],
+      this.limitValue,
+    );
+  }
+
+  leftJoin(source: AnyFromSource, on: CfExpr): CfExprSelectQuery {
+    return new CfExprSelectQuery(
+      this.src,
+      this.projectionItems,
+      this.whereExpr,
+      [...this.joinItems, JoinAst.left(source, on.ast)],
+      this.limitValue,
+    );
+  }
+
+  project(alias: string, expr: CfExpr): CfExprSelectQuery {
+    return new CfExprSelectQuery(
+      this.src,
+      [...this.projectionItems, ProjectionItem.of(alias, expr.ast)],
+      this.whereExpr,
+      this.joinItems,
+      this.limitValue,
+    );
+  }
+
+  where(expr: CfExpr): CfExprSelectQuery {
+    return new CfExprSelectQuery(
+      this.src,
+      this.projectionItems,
+      expr,
+      this.joinItems,
+      this.limitValue,
+    );
+  }
+
+  limit(value: number): CfExprSelectQuery {
+    return new CfExprSelectQuery(
+      this.src,
+      this.projectionItems,
+      this.whereExpr,
+      this.joinItems,
+      value,
+    );
+  }
+
+  build(): SelectAst {
+    if (this.joinItems.length > 0 && this.src === undefined) {
+      throw new Error('CfExprSelectQuery: cannot add a JOIN without a FROM clause');
+    }
+    const base =
+      this.src !== undefined
+        ? SelectAst.from(this.src).withProjection(this.projectionItems)
+        : SelectAst.noFrom().withProjection(this.projectionItems);
+    const withJoins = this.joinItems.length > 0 ? base.withJoins(this.joinItems) : base;
+    const withWhere =
+      this.whereExpr !== undefined ? withJoins.withWhere(this.whereExpr.ast) : withJoins;
+    return this.limitValue !== undefined ? withWhere.withLimit(this.limitValue) : withWhere;
+  }
+}
+
+export function exprSelect(): CfExprSelectQuery {
+  return new CfExprSelectQuery(undefined, [], undefined);
 }
 
 /**

package/src/exports/contract-free.ts

@@ -10,6 +10,8 @@ export {
 export {
   CfConflictClause,
   CfExpr,
+  CfExprSelectQuery,
+  type CfFnOptions,
   CfInsertQuery,
   CfSelectQuery,
   CfUpdateQuery,
@@ -18,7 +20,10 @@ export {
   type ColumnDescriptor,
   type ColumnProxy,
   type ColumnSchema,
+  cfExpr,
+  cfTable,
   type ExcludedProxy,
+  exprSelect,
   type TableHandle,
   type TableInsertRow,
   type TableSetValues,

package/src/query-lane-context.ts

@@ -51,6 +51,14 @@ export type AppliedMutationDefault = {
 export type MutationDefaultsOptions = {
   readonly op: MutationDefaultsOp;
   readonly table: string;
+  /**
+   * Namespace of the target table. Execution-default refs are namespace-scoped,
+   * so only defaults declared for `(namespace, table)` are applied — this is what
+   * disambiguates same-named tables across namespaces. Required so the coordinate
+   * is always part of the match; a missing namespace is a caller bug, not a
+   * silent degrade to table-name-only matching.
+   */
+  readonly namespace: string;
   readonly values: Record<string, unknown>;
   /**
    * Per-ORM-operation cache for generators that declare `stability: 'query'`. The caller passes the same `Map` across every `applyMutationDefaults` invocation in one bulk operation; the framework keys by `generatorId` so the same value is reused across all rows and columns. Generators with `stability: 'row'` use a fresh per-call cache the framework manages internally; generators with `stability: 'field'` skip caching

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Contract, ContractModelDefinitions } from '@prisma-next/contract/types';
+import type { Contract } from '@prisma-next/contract/types';
 import type { ParamSpec } from '@prisma-next/operations';
 import type {
   ExtractFieldOutputTypes,
@@ -13,11 +13,45 @@ import type { SqlExecutionPlan } from './sql-execution-plan';
 export type Expr = ColumnRef | ParamRef;
 
 /**
- * Extracts the model name for a given table by iterating models to find the one
- * whose `storage.table` matches.
+ * The minimal contract shape the per-namespace column resolver needs: the
+ * application-domain models and the storage tables, both keyed by namespace
+ * coordinate, plus (via the optional TypeMaps phantom key, read structurally by
+ * {@link ExtractFieldOutputTypes}) the refined field-output map. Every emitted
+ * `Contract<SqlStorage>` satisfies it, as does `sql-builder`'s `TableProxyContract`
+ * — so the resolver indexes the coordinate directly without forcing callers to
+ * carry the full `Contract`.
  */
-type ExtractTableToModel<TContract extends Contract<SqlStorage>, TableName extends string> =
-  ContractModelDefinitions<TContract> extends infer Models extends Record<string, unknown>
+export type ColumnResolutionContract = {
+  readonly domain: {
+    readonly namespaces: Readonly<
+      Record<string, { readonly models: Readonly<Record<string, unknown>> }>
+    >;
+  };
+  readonly storage: {
+    readonly namespaces: Readonly<
+      Record<
+        string,
+        { readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>> }
+      >
+    >;
+  };
+};
+
+type NamespaceModels<
+  TContract extends ColumnResolutionContract,
+  NsId extends string,
+> = TContract['domain']['namespaces'][NsId] extends {
+  readonly models: infer Models extends Record<string, unknown>;
+}
+  ? Models
+  : never;
+
+type ExtractTableToModel<
+  TContract extends ColumnResolutionContract,
+  NsId extends string,
+  TableName extends string,
+> =
+  NamespaceModels<TContract, NsId> extends infer Models extends Record<string, unknown>
     ? {
         [M in keyof Models & string]: Models[M] extends {
           readonly storage: { readonly table: TableName };
@@ -27,17 +61,14 @@ type ExtractTableToModel<TContract extends Contract<SqlStorage>, TableName exten
       }[keyof Models & string]
     : never;
 
-/**
- * Extracts the field name for a given column by finding the field in
- * `model.storage.fields` whose `column` matches.
- */
 type ExtractColumnToField<
-  TContract extends Contract<SqlStorage>,
+  TContract extends ColumnResolutionContract,
+  NsId extends string,
   TableName extends string,
   ColumnName extends string,
 > =
-  ExtractTableToModel<TContract, TableName> extends infer ModelName extends string
-    ? ContractModelDefinitions<TContract> extends infer Models extends Record<string, unknown>
+  ExtractTableToModel<TContract, NsId, TableName> extends infer ModelName extends string
+    ? NamespaceModels<TContract, NsId> extends infer Models extends Record<string, unknown>
       ? ModelName & keyof Models extends infer MKey extends string
         ? Models[MKey] extends {
             readonly storage: { readonly fields: infer Fields extends Record<string, unknown> };
@@ -52,6 +83,28 @@ type ExtractColumnToField<
       : never
     : never;
 
+/** Resolves to `never` when the table or column is absent in the namespace. */
+type NamespaceStorageColumn<
+  TContract extends ColumnResolutionContract,
+  NsId extends string,
+  TableName extends string,
+  ColumnName extends string,
+> = TContract['storage']['namespaces'][NsId] extends {
+  readonly entries: { readonly table: infer Tables extends Record<string, unknown> };
+}
+  ? TableName extends keyof Tables
+    ? Tables[TableName] extends {
+        readonly columns: infer Columns extends Record<string, unknown>;
+      }
+      ? ColumnName extends keyof Columns
+        ? Columns[ColumnName] extends StorageColumn
+          ? Columns[ColumnName]
+          : never
+        : never
+      : never
+    : never
+  : never;
+
 type FallbackCodecLookup<
   ColumnMeta extends StorageColumn,
   CodecTypes extends Record<string, { readonly output: unknown }>,
@@ -65,6 +118,53 @@ type FallbackCodecLookup<
     : unknown
   : unknown;
 
+/**
+ * The refined (typeParam-applied) JS output type for a field within a namespace
+ * coordinate, read from the emitter's namespace-nested `FieldOutputTypes` map at
+ * `FieldOutputTypes[NsId][Model][Field]`. This preserves parameterized codec
+ * refinements (e.g. `Vector<N>`, `Char<N>`) that a bare codec-output lookup
+ * would drop. Resolves to `never` when the coordinate is absent from the map.
+ */
+type NamespaceFieldOutput<
+  TContract extends ColumnResolutionContract,
+  NsId extends string,
+  ModelName extends string,
+  FieldName extends string,
+> =
+  ExtractFieldOutputTypes<TContract> extends infer Outputs
+    ? NsId extends keyof Outputs
+      ? Outputs[NsId] extends infer NamespaceOutputs
+        ? ModelName extends keyof NamespaceOutputs
+          ? NamespaceOutputs[ModelName] extends infer ModelOutputs
+            ? FieldName extends keyof ModelOutputs
+              ? ModelOutputs[FieldName]
+              : never
+            : never
+          : never
+        : never
+      : never
+    : never;
+
+/**
+ * The secondary resolution path, taken for a storage column not backed by a
+ * domain model field in the namespace (e.g. a column with no corresponding
+ * field); refined model fields resolve via {@link NamespaceFieldOutput}.
+ */
+type ColumnCodecFallback<
+  TContract extends ColumnResolutionContract,
+  NsId extends string,
+  TableName extends string,
+  ColumnName extends string,
+  CodecTypes extends Record<string, { readonly output: unknown }>,
+> =
+  NamespaceStorageColumn<TContract, NsId, TableName, ColumnName> extends infer ColumnMeta
+    ? [ColumnMeta] extends [never]
+      ? never
+      : ColumnMeta extends StorageColumn
+        ? FallbackCodecLookup<ColumnMeta, CodecTypes>
+        : never
+    : never;
+
 /**
  * Type-level operation signature.
  * Represents an operation at the type level for use in contract type maps.
@@ -126,25 +226,37 @@ export type OperationsForTypeId<TypeId extends string, Operations extends Operat
       ? Operations[TypeId]
       : Record<string, never>;
 
+/**
+ * Resolves the JavaScript output type of a column addressed by an explicit
+ * namespace coordinate.
+ *
+ * The table→model and column→field mapping is resolved per-namespace from
+ * `domain.namespaces[NsId]['models']`, and the refined output type from the
+ * emitter's namespace-nested `FieldOutputTypes[NsId][Model][Field]` — so a bare
+ * table name shared across namespaces resolves to each namespace's own field,
+ * and parameterized codec refinements (e.g. `Vector<N>`) are preserved. A
+ * storage column not backed by a model field in the namespace falls back to a
+ * codec-output lookup; a column absent in the namespace resolves to `never`.
+ */
 export type ComputeColumnJsType<
-  TContract extends Contract<SqlStorage>,
+  TContract extends ColumnResolutionContract,
+  NsId extends string,
   TableName extends string,
   ColumnName extends string,
-  ColumnMeta extends StorageColumn,
   CodecTypes extends Record<string, { readonly output: unknown }>,
 > =
-  ExtractTableToModel<TContract, TableName> extends infer ModelName
+  ExtractTableToModel<TContract, NsId, TableName> extends infer ModelName
     ? [ModelName] extends [never]
-      ? FallbackCodecLookup<ColumnMeta, CodecTypes>
+      ? ColumnCodecFallback<TContract, NsId, TableName, ColumnName, CodecTypes>
       : ModelName extends string
-        ? ExtractColumnToField<TContract, TableName, ColumnName> extends infer FieldName
+        ? ExtractColumnToField<TContract, NsId, TableName, ColumnName> extends infer FieldName
           ? [FieldName] extends [never]
-            ? FallbackCodecLookup<ColumnMeta, CodecTypes>
+            ? ColumnCodecFallback<TContract, NsId, TableName, ColumnName, CodecTypes>
             : FieldName extends string
-              ? ModelName extends keyof ExtractFieldOutputTypes<TContract>
-                ? FieldName extends keyof ExtractFieldOutputTypes<TContract>[ModelName]
-                  ? ExtractFieldOutputTypes<TContract>[ModelName][FieldName]
-                  : never
+              ? NamespaceFieldOutput<TContract, NsId, ModelName, FieldName> extends infer Out
+                ? [Out] extends [never]
+                  ? ColumnCodecFallback<TContract, NsId, TableName, ColumnName, CodecTypes>
+                  : Out
                 : never
               : never
           : never

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

@@ -1 +0,0 @@
-{"version":3,"file":"ddl-types-D3vlEjMA.d.mts","names":[],"sources":["../src/ast/ddl-types.ts"],"mappings":";;;;;;;AAcA;;;;AACqB;AAGrB;;UAJiB,sBAAA;EAAA,SACN,UAAU;AAAA;AAAA,UAGJ,uBAAA;EACf,OAAA,CAAQ,IAAA,EAAM,oBAAA,EAAsB,GAAA,EAAK,sBAAA,GAAyB,CAAA;EAClE,QAAA,CAAS,IAAA,EAAM,qBAAA,EAAuB,GAAA,EAAK,sBAAA,GAAyB,CAAA;AAAA;AAAA,uBAGhD,gBAAA;EAAA,kBACF,IAAA;EAAA,SACT,MAAA,IAAU,OAAA,EAAS,uBAAA,CAAwB,CAAA,GAAI,GAAA,EAAK,sBAAA,GAAyB,CAAA;EAAA,UAE5E,MAAA;AAAA;AAAA,cAKC,oBAAA,SAA6B,gBAAA;EAAA,SAC/B,IAAA;EAAA,SACA,KAAA,EAAO,8BAAA;cAEJ,KAAA,EAAO,8BAAA;EASV,MAAA,IAAU,OAAA,EAAS,uBAAA,CAAwB,CAAA,GAAI,GAAA,EAAK,sBAAA,GAAyB,CAAA;AAAA;AAAA,cAK3E,qBAAA,SAA8B,gBAAA;EAAA,SAChC,IAAA;EAAA,SACA,UAAA;cAEG,UAAA;EAMH,MAAA,IAAU,OAAA,EAAS,uBAAA,CAAwB,CAAA,GAAI,GAAA,EAAK,sBAAA,GAAyB,CAAA;AAAA;AAAA,KAK5E,mBAAA,GAAsB,oBAAA,GAAuB,qBAAqB;AAAA,cAEjE,SAAA;EAAA,SACF,IAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA,GAAU,mBAAA;cAEP,OAAA;IAAA,SACD,IAAA;IAAA,SACA,IAAA;IAAA,SACA,OAAA;IAAA,SACA,UAAA;IAAA,SACA,OAAA,GAAU,mBAAmB;EAAA;AAAA;AAAA,uBAWpB,OAAA;EAAA,kBACF,IAAA;EAlEoE;;;AAEtE;AAKlB;;EAmEE,SAAA;EAAA,UAIU,MAAA;EAIV,gBAAA,IAAoB,WAAW;AAAA;AAAA,iBAKjB,SAAA,CAAU,KAAA,YAAiB,KAAA,IAAS,OAAO;;;;;;;;cAoB9C,oBAAA;EAAA,SACF,IAAA;EAAA,SACA,OAAA,EAAS,aAAa;EAAA,SACtB,IAAA;cAEG,OAAA;IAAA,SAAoB,OAAA;IAAA,SAAqC,IAAA;EAAA;AAAA;;;;;;AA5FkB;AAKzF;cAqGa,oBAAA;EAAA,SACF,IAAA;EAAA,SACA,OAAA,EAAS,aAAA;EAAA,SACT,QAAA;EAAA,SACA,UAAA,EAAY,aAAA;EAAA,SACZ,QAAA,EAAU,iBAAA;EAAA,SACV,QAAA,EAAU,iBAAA;EAAA,SACV,IAAA;cAEG,OAAA;IAAA,SACD,OAAA;IAAA,SACA,QAAA;IAAA,SACA,UAAA;IAAA,SACA,QAAA,GAAW,iBAAA;IAAA,SACX,QAAA,GAAW,iBAAA;IAAA,SACX,IAAA;EAAA;AAAA;;;;;;;AA1G4E;cA6H5E,gBAAA;EAAA,SACF,IAAA;EAAA,SACA,OAAA,EAAS,aAAa;EAAA,SACtB,IAAA;cAEG,OAAA;IAAA,SAAoB,OAAA;IAAA,SAAqC,IAAA;EAAA;AAAA;AAAA,KAO3D,kBAAA,GAAqB,oBAAA,GAAuB,oBAAA,GAAuB,gBAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"ddl-types-X9_XHUl0.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 { 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\n  constructor(options: {\n    readonly name: string;\n    readonly type: string;\n    readonly notNull?: boolean;\n    readonly primaryKey?: boolean;\n    readonly default?: AnyDdlColumnDefault;\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    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\nexport type DdlTableConstraint = PrimaryKeyConstraint | ForeignKeyConstraint | UniqueConstraint;\n"],"mappings":";;AAuBA,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,YAAY,SAMT;EACD,KAAK,OAAO,QAAQ;EACpB,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,aAAa,QAAQ;EAC1B,KAAK,UAAU,QAAQ;EACvB,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"}

package/dist/query-lane-context-CY0-e8Qo.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query-lane-context-CY0-e8Qo.d.mts","names":[],"sources":["../src/query-lane-context.ts"],"mappings":";;;;;;;;;AASA;UAAiB,uBAAA;;;;EAIf,aAAA,CAAc,OAAA,WAAkB,eAAA;EAkBtB;;;;;;;;;;;;;EAJV,iBAAA,CAAkB,WAAA,UAAqB,KAAA,UAAe,MAAA,WAAiB,QAAA;EAI5C;;;EAA3B,MAAA,IAAU,gBAAA,CAAiB,eAAA;EAI+B;AAAA;AAM5D;EANE,YAAA,CAAa,UAAA,oBAA8B,eAAA;AAAA;;AAMN;AAEvC;KAFY,kBAAA,GAAqB,MAAM;AAAA,KAE3B,kBAAA;AAAA,KAEA,sBAAA;EAAA,SACD,MAAA;EAAA,SACA,KAAK;AAAA;AAAA,KAGJ,uBAAA;EAAA,SACD,EAAA,EAAI,kBAAA;EAAA,SACJ,KAAA;EAAA,SACA,MAAA,EAAQ,MAAA;EAHgB;;;;EAAA,SAQxB,iBAAA,GAAoB,GAAA;AAAA;;;;;;UAQd,gBAAA,mBAAmC,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA;EAAA,SACzE,QAAA,EAAU,SAAA;EATU;;AAAG;EAAH,SAapB,cAAA,EAAgB,qBAAA;EALM;;;EAAA,SAStB,gBAAA,EAAkB,uBAAA;EAAA,SAClB,eAAA,EAAiB,oBAAA;EAV+C;;;EAAA,SAchE,KAAA,EAAO,kBAAA;EAJU;;;EAQ1B,qBAAA,CAAsB,OAAA,EAAS,uBAAA,GAA0B,aAAA,CAAc,sBAAA;AAAA"}

package/dist/types-CQVke4QO.d.mts

@@ -1,181 +0,0 @@
-import { J as ParamRef, g as ColumnRef } from "./types-BbGUx5Bi.mjs";
-import { r as ExecutionContext } from "./query-lane-context-CY0-e8Qo.mjs";
-import { t as SqlExecutionPlan } from "./sql-execution-plan-JwVeAzXt.mjs";
-import { Contract, ContractModelDefinitions } from "@prisma-next/contract/types";
-import { ExtractFieldOutputTypes, SqlStorage, StorageColumn } from "@prisma-next/sql-contract/types";
-import { ParamSpec } from "@prisma-next/operations";
-import { SqlLoweringSpec } from "@prisma-next/sql-operations";
-
-//#region src/types.d.ts
-type Expr = ColumnRef | ParamRef;
-/**
- * Extracts the model name for a given table by iterating models to find the one
- * whose `storage.table` matches.
- */
-type ExtractTableToModel<TContract extends Contract<SqlStorage>, TableName extends string> = ContractModelDefinitions<TContract> extends infer Models extends Record<string, unknown> ? { [M in keyof Models & string]: Models[M] extends {
-  readonly storage: {
-    readonly table: TableName;
-  };
-} ? M : never }[keyof Models & string] : never;
-/**
- * Extracts the field name for a given column by finding the field in
- * `model.storage.fields` whose `column` matches.
- */
-type ExtractColumnToField<TContract extends Contract<SqlStorage>, TableName extends string, ColumnName extends string> = ExtractTableToModel<TContract, TableName> extends infer ModelName extends string ? ContractModelDefinitions<TContract> extends infer Models extends Record<string, unknown> ? ModelName & keyof Models extends infer MKey extends string ? Models[MKey] extends {
-  readonly storage: {
-    readonly fields: infer Fields extends Record<string, unknown>;
-  };
-} ? { [F in keyof Fields & string]: Fields[F] extends {
-  readonly column: ColumnName;
-} ? F : never }[keyof Fields & string] : never : never : never : never;
-type FallbackCodecLookup<ColumnMeta extends StorageColumn, CodecTypes extends Record<string, {
-  readonly output: unknown;
-}>> = ColumnMeta extends {
-  codecId: infer CodecId extends string;
-} ? CodecId extends keyof CodecTypes ? CodecTypes[CodecId] extends {
-  readonly output: infer O;
-} ? ColumnMeta extends {
-  nullable: true;
-} ? O | null : O : unknown : unknown : unknown;
-/**
- * Type-level operation signature.
- * Represents an operation at the type level for use in contract type maps.
- */
-type OperationTypeSignature = {
-  readonly args: ReadonlyArray<ParamSpec>;
-  readonly returns: ParamSpec;
-  readonly lowering: SqlLoweringSpec;
-  readonly capabilities?: ReadonlyArray<string>;
-};
-/**
- * Type-level operation registry.
- * Maps typeId → operations, where operations is a record of method name → operation signature.
- *
- * Example:
- * ```typescript
- * type MyOperations: OperationTypes = {
- *   'pg/vector@1': {
- *     cosineDistance: {
- *       args: [{ codecId: 'pg/vector@1'; nullable: false }];
- *       returns: { codecId: 'core/float8'; nullable: false };
- *       lowering: { targetFamily: 'sql'; strategy: 'function'; template: '...' };
- *     };
- *   };
- * };
- * ```
- */
-type OperationTypes = Record<string, Record<string, OperationTypeSignature>>;
-/**
- * CodecTypes represents a map of typeId to codec definitions.
- * Each codec definition must have an `output` property indicating the JavaScript type.
- *
- * Example:
- * ```typescript
- * type MyCodecTypes: CodecTypes = {
- *   'pg/int4@1': { output: number };
- *   'pg/text@1': { output: string };
- * };
- * ```
- */
-type CodecTypes = Record<string, {
-  readonly output: unknown;
-}>;
-/**
- * Extracts operations for a given typeId from the operation registry.
- * Returns an empty record if the typeId is not found.
- *
- * @example
- * ```typescript
- * type Ops = OperationsForTypeId<'pg/vector@1', MyOperations>;
- * // Ops = { cosineDistance: { ... }, l2Distance: { ... } }
- * ```
- */
-type OperationsForTypeId<TypeId extends string, Operations extends OperationTypes> = Operations extends Record<string, never> ? Record<string, never> : TypeId extends keyof Operations ? Operations[TypeId] : Record<string, never>;
-type ComputeColumnJsType<TContract extends Contract<SqlStorage>, TableName extends string, ColumnName extends string, ColumnMeta extends StorageColumn, CodecTypes extends Record<string, {
-  readonly output: unknown;
-}>> = ExtractTableToModel<TContract, TableName> extends infer ModelName ? [ModelName] extends [never] ? FallbackCodecLookup<ColumnMeta, CodecTypes> : ModelName extends string ? ExtractColumnToField<TContract, TableName, ColumnName> extends infer FieldName ? [FieldName] extends [never] ? FallbackCodecLookup<ColumnMeta, CodecTypes> : FieldName extends string ? ModelName extends keyof ExtractFieldOutputTypes<TContract> ? FieldName extends keyof ExtractFieldOutputTypes<TContract>[ModelName] ? ExtractFieldOutputTypes<TContract>[ModelName][FieldName] : never : never : never : never : never : never;
-/**
- * Alias for the SQL-domain executable plan, exposed under the legacy
- * `SqlPlan` name for compatibility with SQL builder/utility call sites.
- * The canonical name is `SqlExecutionPlan` (`./sql-execution-plan`).
- */
-type SqlPlan<Row = unknown> = SqlExecutionPlan<Row>;
-/**
- * Helper types for extracting contract structure.
- */
-type TablesOf<TContract> = TContract extends {
-  storage: {
-    tables: infer U;
-  };
-} ? U : never;
-type TableKey<TContract> = Extract<keyof TablesOf<TContract>, string>;
-/**
- * Unique symbol for metadata property to avoid collisions with user-defined properties
- */
-declare const META: unique symbol;
-/**
- * Extracts metadata from a type that has a META property
- */
-type Meta<T extends {
-  [META]: unknown;
-}> = T[typeof META];
-/**
- * Metadata interface for table definitions
- */
-interface TableMetadata<Name extends string> {
-  name: Name;
-}
-/**
- * Metadata interface for model definitions
- */
-interface ModelMetadata<Name extends string> {
-  name: Name;
-}
-/**
- * Base interface for table definitions with metadata
- * Used in contract.d.ts to define storage-level table types
- */
-interface TableDef<Name extends string> {
-  readonly [META]: TableMetadata<Name>;
-}
-/**
- * Base interface for model definitions with metadata
- * Used in contract.d.ts to define application-level model types
- */
-interface ModelDef<Name extends string> {
-  readonly [META]: ModelMetadata<Name>;
-}
-type ColumnsOf<TContract, K extends TableKey<TContract>> = K extends keyof TablesOf<TContract> ? TablesOf<TContract>[K] extends {
-  columns: infer C;
-} ? C : never : never;
-interface RawTemplateOptions {
-  readonly annotations?: Record<string, unknown>;
-}
-interface RawFunctionOptions extends RawTemplateOptions {
-  readonly params: ReadonlyArray<unknown>;
-}
-type RawTemplateFactory = (strings: TemplateStringsArray, ...values: readonly unknown[]) => SqlExecutionPlan;
-interface RawFactory extends RawTemplateFactory {
-  (text: string, options: RawFunctionOptions): SqlExecutionPlan;
-  with(options: RawTemplateOptions): RawTemplateFactory;
-}
-interface RuntimeError extends Error {
-  readonly code: string;
-  readonly category: 'PLAN';
-  readonly severity: 'error';
-  readonly details?: Record<string, unknown>;
-  readonly hints?: readonly string[];
-  readonly docs?: readonly string[];
-}
-interface BuildParamsMap {
-  readonly [name: string]: unknown;
-}
-interface BuildOptions {
-  readonly params?: BuildParamsMap;
-}
-interface SqlBuilderOptions<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> {
-  readonly context: ExecutionContext<TContract>;
-}
-//#endregion
-export { TableMetadata as C, TableKey as S, RawTemplateOptions as _, ComputeColumnJsType as a, SqlPlan as b, Meta as c, OperationTypeSignature as d, OperationTypes as f, RawTemplateFactory as g, RawFunctionOptions as h, ColumnsOf as i, ModelDef as l, RawFactory as m, BuildParamsMap as n, Expr as o, OperationsForTypeId as p, CodecTypes as r, META as s, BuildOptions as t, ModelMetadata as u, RuntimeError as v, TablesOf as w, TableDef as x, SqlBuilderOptions as y };
-//# sourceMappingURL=types-CQVke4QO.d.mts.map

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

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