@prisma-next/sql-relational-core 0.12.0 → 0.13.0-dev.2

package/src/codec-ref-for-column.ts

@@ -1,50 +1,47 @@
 import type { JsonValue } from '@prisma-next/contract/types';
 import type { CodecRef } from '@prisma-next/framework-components/codec';
+import { resolveStorageTable } from '@prisma-next/sql-contract/resolve-storage-table';
 import {
   isPostgresEnumStorageEntry,
   isStorageTypeInstance,
   type SqlStorage,
-  type StorageTable,
 } from '@prisma-next/sql-contract/types';
 
 /**
  * Derive the canonical {@link CodecRef} for a `(table, column)` pair against a {@link SqlStorage}. This is the build-time path every column-bound `ParamRef` / `ProjectionItem` uses to stamp its `codec` slot before the AST is handed to the runtime — the runtime resolver then materialises a memoised {@link import('@prisma-next/sql-relational-core/ast').Codec} for the same `CodecRef` via `forCodecRef`.
  *
- * Resolution rules over `storage.tables[table].columns[column]`:
+ * Resolution rules over namespace `entries.table[table].columns[column]`:
  *
  * - `typeRef` column → `{codecId, typeParams}` from `storage.types[typeRef]` (multiple columns sharing the typeRef share one ref → one memoised codec).
  * - inline `typeParams` column → `{codecId, typeParams}` from the column itself.
  * - non-parameterized column → `{codecId}` with `typeParams` undefined.
  *
  * Returns `undefined` when the table or column is unknown, or when a `typeRef` column references a `storage.types` entry that does not exist.
+ *
+ * `namespaceId` leads the coordinate args and is always supplied: every
+ * model/table sits in an explicit namespace, so the table is resolved strictly
+ * within that namespace (see {@link resolveStorageTable}).
  */
 export function codecRefForStorageColumn(
   storage: SqlStorage,
+  namespaceId: string,
   tableName: string,
   columnName: string,
 ): CodecRef | undefined {
-  let tableDef: StorageTable | undefined;
-  for (const ns of Object.values(storage.namespaces)) {
-    const candidate = ns.tables[tableName] as StorageTable | undefined;
-    if (candidate !== undefined) {
-      tableDef = candidate;
-      break;
-    }
-  }
-  if (!tableDef) return undefined;
+  const resolved = resolveStorageTable(storage, tableName, namespaceId);
+  if (resolved === undefined) return undefined;
+  const tableDef = resolved.table;
   const columnDef = tableDef.columns[columnName];
   if (!columnDef) return undefined;
   if (columnDef.typeRef !== undefined) {
     let instance: unknown = storage.types?.[columnDef.typeRef];
     if (!instance) {
       for (const ns of Object.values(storage.namespaces)) {
-        const nsEnums = (ns as { enum?: Record<string, unknown> }).enum;
-        if (nsEnums) {
-          const nsEntry = nsEnums[columnDef.typeRef];
-          if (nsEntry !== undefined) {
-            instance = nsEntry;
-            break;
-          }
+        const typeSlot = (ns.entries as { type?: Record<string, unknown> }).type;
+        const nsEntry = typeSlot?.[columnDef.typeRef];
+        if (nsEntry !== undefined) {
+          instance = nsEntry;
+          break;
         }
       }
     }
@@ -64,11 +61,20 @@ export function codecRefForStorageColumn(
       };
     }
     if (isStorageTypeInstance(instance)) {
-      return { codecId: instance.codecId, typeParams: instance.typeParams as JsonValue };
+      // Empty-state canonicalization: a `StorageTypeInstance` with absent
+      // (or empty) `typeParams` produces a `CodecRef` with no `typeParams`
+      // field. Equivalent to the non-parameterized-column branch below.
+      // Carrying `{}` here would break content-keyed memoisation and trip
+      // the runtime validator against non-parameterized codec descriptors.
+      const instanceParams = instance.typeParams;
+      const hasParamKeys = instanceParams !== undefined && Object.keys(instanceParams).length > 0;
+      return hasParamKeys
+        ? { codecId: instance.codecId, typeParams: instanceParams as JsonValue }
+        : { codecId: instance.codecId };
     }
     return undefined;
   }
-  if (columnDef.typeParams !== undefined) {
+  if (columnDef.typeParams !== undefined && Object.keys(columnDef.typeParams).length > 0) {
     return { codecId: columnDef.codecId, typeParams: columnDef.typeParams as JsonValue };
   }
   return { codecId: columnDef.codecId };

package/src/contract-free/column.ts

@@ -0,0 +1,56 @@
+import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';
+import type { ReferentialAction } from '@prisma-next/sql-contract/types';
+import type { AnyDdlColumnDefault } from '../ast/ddl-types';
+import {
+  DdlColumn,
+  ForeignKeyConstraint,
+  FunctionColumnDefault,
+  LiteralColumnDefault,
+  PrimaryKeyConstraint,
+  UniqueConstraint,
+} from '../ast/ddl-types';
+
+export interface DdlColumnOptions {
+  readonly notNull?: boolean;
+  readonly primaryKey?: boolean;
+  readonly default?: AnyDdlColumnDefault;
+}
+
+export function lit(value: ColumnDefaultLiteralInputValue): LiteralColumnDefault {
+  return new LiteralColumnDefault(value);
+}
+
+export function fn(expression: string): FunctionColumnDefault {
+  return new FunctionColumnDefault(expression);
+}
+
+export function col(name: string, type: string, options?: DdlColumnOptions): DdlColumn {
+  return new DdlColumn({ name, type, ...options });
+}
+
+export function primaryKey(
+  columns: readonly string[],
+  options?: { readonly name?: string },
+): PrimaryKeyConstraint {
+  return new PrimaryKeyConstraint({ columns, ...options });
+}
+
+export function foreignKey(
+  columns: readonly string[],
+  refTable: string,
+  refColumns: readonly string[],
+  options?: {
+    readonly name?: string;
+    readonly onDelete?: ReferentialAction;
+    readonly onUpdate?: ReferentialAction;
+  },
+): ForeignKeyConstraint {
+  return new ForeignKeyConstraint({ columns, refTable, refColumns, ...options });
+}
+
+export function unique(
+  columns: readonly string[],
+  options?: { readonly name?: string },
+): UniqueConstraint {
+  return new UniqueConstraint({ columns, ...options });
+}

package/src/contract-free/dml.ts

@@ -0,0 +1,17 @@
+export {
+  CfConflictClause,
+  CfExpr,
+  CfInsertQuery,
+  CfSelectQuery,
+  CfUpdateQuery,
+  CfUpsertBuilder,
+  CfUpsertQuery,
+  type ColumnDescriptor,
+  type ColumnProxy,
+  type ColumnSchema,
+  type ExcludedProxy,
+  type TableHandle,
+  type TableInsertRow,
+  type TableSetValues,
+  table,
+} from './table';

package/src/contract-free/table.ts

@@ -0,0 +1,390 @@
+import { blindCast } from '@prisma-next/utils/casts';
+import {
+  AndExpr,
+  type AnyExpression,
+  BinaryExpr,
+  ColumnRef,
+  InsertAst,
+  InsertOnConflict,
+  type InsertValue,
+  NullCheckExpr,
+  OrderByItem,
+  OrExpr,
+  ParamRef,
+  ProjectionItem,
+  SelectAst,
+  type TableSource,
+  UpdateAst,
+} from '../ast/types';
+
+export interface ColumnDescriptor {
+  readonly codecId: string;
+  readonly nullable: boolean;
+}
+
+export type ColumnSchema = Record<string, ColumnDescriptor>;
+
+/**
+ * A composable WHERE / ON expression. Wraps an `AnyExpression` and exposes
+ * fluent boolean combinators, mirroring the spirit of `sql-builder`'s
+ * `Expression` interface without the contract-bound type machinery.
+ */
+export class CfExpr {
+  constructor(readonly ast: AnyExpression) {}
+
+  and(other: CfExpr): CfExpr {
+    return new CfExpr(AndExpr.of([this.ast, other.ast]));
+  }
+
+  or(other: CfExpr): CfExpr {
+    return new CfExpr(OrExpr.of([this.ast, other.ast]));
+  }
+
+  not(): CfExpr {
+    return new CfExpr(this.ast.not());
+  }
+}
+
+/**
+ * Per-column authoring handle exposed as a keyed property on a {@link TableHandle}.
+ * Carries codec metadata baked at declaration time so no codec ID, table name, or
+ * column name needs to be repeated at the call site.
+ */
+export interface ColumnProxy {
+  readonly codecId: string;
+  readonly nullable: boolean;
+  readonly columnName: string;
+  readonly tableName: string;
+  eq(value: unknown): CfExpr;
+  neq(value: unknown): CfExpr;
+  isNull(): CfExpr;
+  isNotNull(): CfExpr;
+  toRef(): ColumnRef;
+  toProjectionItem(alias?: string): ProjectionItem;
+}
+
+/**
+ * Object passed to the {@link CfConflictClause.doUpdate} callback. Each key
+ * resolves to a `ColumnRef` for the corresponding `excluded.<column>`, so the
+ * upsert conflict-update branch can copy proposed values without re-binding
+ * parameters.
+ */
+export type ExcludedProxy<Schema extends ColumnSchema> = {
+  readonly [K in keyof Schema]: ColumnRef;
+};
+
+export type TableInsertRow<Schema extends ColumnSchema> = {
+  readonly [K in keyof Schema]: unknown;
+};
+
+export type TableSetValues<Schema extends ColumnSchema> = {
+  readonly [K in keyof Schema]?: unknown;
+};
+
+/**
+ * Fluent authoring handle for a fixed control-plane table. Column proxies are
+ * exposed as keyed properties so `handle.columnName.eq(value)` composes without
+ * threading codec IDs, table names, or column refs at the call site.
+ */
+export type TableHandle<Schema extends ColumnSchema> = {
+  readonly source: TableSource;
+  insert(row: TableInsertRow<Schema>): CfInsertQuery<Schema>;
+  upsert(row: TableInsertRow<Schema>): CfUpsertBuilder<Schema>;
+  update(): CfUpdateQuery<Schema>;
+  select(...columns: ReadonlyArray<ColumnProxy>): CfSelectQuery;
+} & {
+  readonly [K in keyof Schema]: ColumnProxy;
+};
+
+export class CfInsertQuery<Schema extends ColumnSchema> {
+  constructor(
+    private readonly src: TableSource,
+    private readonly schema: Schema,
+    private readonly rowValues: TableInsertRow<Schema>,
+    private readonly returningItems: ReadonlyArray<ProjectionItem> | undefined = undefined,
+  ) {}
+
+  returning(...columns: ReadonlyArray<ColumnProxy>): CfInsertQuery<Schema> {
+    return new CfInsertQuery(
+      this.src,
+      this.schema,
+      this.rowValues,
+      columns.map((col) => col.toProjectionItem()),
+    );
+  }
+
+  build(): InsertAst {
+    const row = buildInsertRow(this.schema, this.rowValues);
+    const ast = InsertAst.into(this.src).withRows([row]);
+    return this.returningItems ? ast.withReturning(this.returningItems) : ast;
+  }
+}
+
+export class CfUpsertBuilder<Schema extends ColumnSchema> {
+  constructor(
+    private readonly src: TableSource,
+    private readonly schema: Schema,
+    private readonly rowValues: TableInsertRow<Schema>,
+  ) {}
+
+  onConflict(...columns: ReadonlyArray<ColumnProxy>): CfConflictClause<Schema> {
+    return new CfConflictClause(this.src, this.schema, this.rowValues, [...columns]);
+  }
+}
+
+export class CfConflictClause<Schema extends ColumnSchema> {
+  constructor(
+    private readonly src: TableSource,
+    private readonly schema: Schema,
+    private readonly rowValues: TableInsertRow<Schema>,
+    private readonly conflictCols: ReadonlyArray<ColumnProxy>,
+  ) {}
+
+  doUpdate(
+    setOrCallback:
+      | TableSetValues<Schema>
+      | ((excluded: ExcludedProxy<Schema>) => TableSetValues<Schema>),
+  ): CfUpsertQuery<Schema> {
+    const set =
+      typeof setOrCallback === 'function'
+        ? setOrCallback(buildExcludedProxy(this.schema))
+        : setOrCallback;
+    return new CfUpsertQuery(this.src, this.schema, this.rowValues, this.conflictCols, set);
+  }
+
+  doNothing(): CfUpsertQuery<Schema> {
+    return new CfUpsertQuery(this.src, this.schema, this.rowValues, this.conflictCols, undefined);
+  }
+}
+
+export class CfUpsertQuery<Schema extends ColumnSchema> {
+  constructor(
+    private readonly src: TableSource,
+    private readonly schema: Schema,
+    private readonly rowValues: TableInsertRow<Schema>,
+    private readonly conflictCols: ReadonlyArray<ColumnProxy>,
+    private readonly updateSet: TableSetValues<Schema> | undefined,
+  ) {}
+
+  build(): InsertAst {
+    const row = buildInsertRow(this.schema, this.rowValues);
+    const conflictRefs = this.conflictCols.map((col) => col.toRef());
+    const onConflict =
+      this.updateSet === undefined
+        ? InsertOnConflict.on(conflictRefs).doNothing()
+        : InsertOnConflict.on(conflictRefs).doUpdateSet(buildSetMap(this.schema, this.updateSet));
+    return InsertAst.into(this.src).withRows([row]).withOnConflict(onConflict);
+  }
+}
+
+export class CfUpdateQuery<Schema extends ColumnSchema> {
+  constructor(
+    private readonly src: TableSource,
+    private readonly schema: Schema,
+    private readonly setValues: TableSetValues<Schema> | undefined = undefined,
+    private readonly whereExpr: CfExpr | undefined = undefined,
+    private readonly returningItems: ReadonlyArray<ProjectionItem> | undefined = undefined,
+  ) {}
+
+  set(values: TableSetValues<Schema>): CfUpdateQuery<Schema> {
+    return new CfUpdateQuery(this.src, this.schema, values, this.whereExpr, this.returningItems);
+  }
+
+  where(expr: CfExpr): CfUpdateQuery<Schema> {
+    return new CfUpdateQuery(this.src, this.schema, this.setValues, expr, this.returningItems);
+  }
+
+  returning(...columns: ReadonlyArray<ColumnProxy>): CfUpdateQuery<Schema> {
+    return new CfUpdateQuery(
+      this.src,
+      this.schema,
+      this.setValues,
+      this.whereExpr,
+      columns.map((col) => col.toProjectionItem()),
+    );
+  }
+
+  build(): UpdateAst {
+    const set = buildSetMap(this.schema, this.setValues);
+    const base = UpdateAst.table(this.src).withSet(set);
+    const withWhere = this.whereExpr ? base.withWhere(this.whereExpr.ast) : base;
+    return this.returningItems ? withWhere.withReturning(this.returningItems) : withWhere;
+  }
+}
+
+export class CfSelectQuery {
+  constructor(
+    private readonly src: TableSource,
+    private readonly projectionItems: ReadonlyArray<ProjectionItem>,
+    private readonly whereExpr: CfExpr | undefined = undefined,
+    private readonly orderByItems: ReadonlyArray<OrderByItem> = [],
+  ) {}
+
+  where(expr: CfExpr): CfSelectQuery {
+    return new CfSelectQuery(this.src, this.projectionItems, expr, this.orderByItems);
+  }
+
+  orderBy(column: ColumnProxy, dir: 'asc' | 'desc' = 'asc'): CfSelectQuery {
+    const item = dir === 'asc' ? OrderByItem.asc(column.toRef()) : OrderByItem.desc(column.toRef());
+    return new CfSelectQuery(this.src, this.projectionItems, this.whereExpr, [
+      ...this.orderByItems,
+      item,
+    ]);
+  }
+
+  build(): SelectAst {
+    const base = SelectAst.from(this.src).withProjection(this.projectionItems);
+    const withWhere = this.whereExpr ? base.withWhere(this.whereExpr.ast) : base;
+    return this.orderByItems.length > 0 ? withWhere.withOrderBy(this.orderByItems) : withWhere;
+  }
+}
+
+/**
+ * Declare a control-plane table once, binding column codecs at declaration time.
+ * Returns a `TableHandle` whose column properties compose expressions directly
+ * without per-call-site codec or column-name threading.
+ *
+ * ```ts
+ * const marker = pgTable({ name: 'marker', schema: 'prisma_contract' }, {
+ *   space:      text(),
+ *   core_hash:  text(),
+ *   updated_at: timestamptz(),
+ * });
+ *
+ * const query = marker.update()
+ *   .set({ core_hash: newHash, updated_at: NOW })
+ *   .where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom)))
+ *   .returning(marker.space)
+ *   .build();
+ * ```
+ */
+export function table<Schema extends ColumnSchema>(
+  source: TableSource,
+  schema: Schema,
+): TableHandle<Schema> {
+  const proxies: Record<string, ColumnProxy> = {};
+  for (const [col, desc] of Object.entries(schema)) {
+    proxies[col] = makeColumnProxy(source.alias ?? source.name, col, desc);
+  }
+
+  const handle = {
+    ...proxies,
+    source,
+    insert: (row: TableInsertRow<Schema>) => new CfInsertQuery(source, schema, row),
+    upsert: (row: TableInsertRow<Schema>) => new CfUpsertBuilder(source, schema, row),
+    update: () => new CfUpdateQuery(source, schema),
+    select: (...cols: ReadonlyArray<ColumnProxy>) =>
+      new CfSelectQuery(
+        source,
+        cols.map((col) => col.toProjectionItem()),
+      ),
+  };
+
+  return blindCast<
+    TableHandle<Schema>,
+    'Column proxies are dynamically built from Schema keys — TypeScript cannot verify the per-key ColumnProxy constraint at the spread call site. Construction is correct by construction: every key maps to makeColumnProxy(source.name, key, schema[key]).'
+  >(handle);
+}
+
+function makeColumnProxy(
+  tableName: string,
+  columnName: string,
+  desc: ColumnDescriptor,
+): ColumnProxy {
+  const ref = ColumnRef.of(tableName, columnName);
+  return {
+    codecId: desc.codecId,
+    nullable: desc.nullable,
+    columnName,
+    tableName,
+    eq: (value) =>
+      value === null
+        ? new CfExpr(NullCheckExpr.isNull(ref))
+        : new CfExpr(BinaryExpr.eq(ref, toSetExpression(value, desc))),
+    neq: (value) =>
+      value === null
+        ? new CfExpr(NullCheckExpr.isNotNull(ref))
+        : new CfExpr(BinaryExpr.neq(ref, toSetExpression(value, desc))),
+    isNull: () => new CfExpr(NullCheckExpr.isNull(ref)),
+    isNotNull: () => new CfExpr(NullCheckExpr.isNotNull(ref)),
+    toRef: () => ref,
+    toProjectionItem: (alias = columnName) =>
+      ProjectionItem.of(alias, ref, { codecId: desc.codecId }),
+  };
+}
+
+function buildExcludedProxy<Schema extends ColumnSchema>(schema: Schema): ExcludedProxy<Schema> {
+  return blindCast<
+    ExcludedProxy<Schema>,
+    'Object.fromEntries cannot preserve per-key ColumnRef types — correct by construction: every key maps to ColumnRef.of("excluded", key).'
+  >(Object.fromEntries(Object.keys(schema).map((col) => [col, ColumnRef.of('excluded', col)])));
+}
+
+function isExpressionSource(value: unknown): value is { toExpr(): AnyExpression } {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'toExpr' in value &&
+    typeof value.toExpr === 'function'
+  );
+}
+
+function toInsertValue(value: unknown, desc: ColumnDescriptor): InsertValue {
+  if (isExpressionSource(value)) {
+    const expr = value.toExpr();
+    if (
+      expr.kind === 'column-ref' ||
+      expr.kind === 'param-ref' ||
+      expr.kind === 'prepared-param-ref' ||
+      expr.kind === 'raw-expr'
+    ) {
+      return expr;
+    }
+  }
+  return ParamRef.of(value, { codec: { codecId: desc.codecId } });
+}
+
+function toSetExpression(value: unknown, desc: ColumnDescriptor): AnyExpression {
+  if (isExpressionSource(value)) {
+    return value.toExpr();
+  }
+  return ParamRef.of(value, { codec: { codecId: desc.codecId } });
+}
+
+function buildInsertRow<Schema extends ColumnSchema>(
+  schema: Schema,
+  values: TableInsertRow<Schema>,
+): Record<string, InsertValue> {
+  const row: Record<string, InsertValue> = {};
+  const rawValues = blindCast<
+    Record<string, unknown>,
+    'TableInsertRow<Schema> maps Schema keys to unknown; indexing by the same string keys is correct by construction'
+  >(values);
+  for (const [col, desc] of Object.entries(schema)) {
+    row[col] = toInsertValue(rawValues[col], desc);
+  }
+  return row;
+}
+
+function buildSetMap<Schema extends ColumnSchema>(
+  schema: Schema,
+  values: TableSetValues<Schema> | undefined,
+): Record<string, AnyExpression> {
+  if (values === undefined) return {};
+  const set: Record<string, AnyExpression> = {};
+  const rawSchema = blindCast<
+    Record<string, ColumnDescriptor>,
+    'Schema extends ColumnSchema = Record<string, ColumnDescriptor>; runtime key access is correct by construction'
+  >(schema);
+  const rawValues = blindCast<
+    Record<string, unknown>,
+    'TableSetValues<Schema> maps Schema keys to unknown; iterating with Object.entries is correct by construction'
+  >(values);
+  for (const [col, value] of Object.entries(rawValues)) {
+    const desc = rawSchema[col];
+    if (desc !== undefined) {
+      set[col] = toSetExpression(value, desc);
+    }
+  }
+  return set;
+}

package/src/exports/ast.ts

@@ -1,5 +1,6 @@
 export * from '../ast/adapter-types';
 export * from '../ast/codec-types';
+export * from '../ast/ddl-types';
 export * from '../ast/driver-types';
 export * from '../ast/sql-codec-helpers';
 export * from '../ast/sql-codecs';

package/src/exports/contract-free.ts

@@ -0,0 +1,26 @@
+export {
+  col,
+  type DdlColumnOptions,
+  fn,
+  foreignKey,
+  lit,
+  primaryKey,
+  unique,
+} from '../contract-free/column';
+export {
+  CfConflictClause,
+  CfExpr,
+  CfInsertQuery,
+  CfSelectQuery,
+  CfUpdateQuery,
+  CfUpsertBuilder,
+  CfUpsertQuery,
+  type ColumnDescriptor,
+  type ColumnProxy,
+  type ColumnSchema,
+  type ExcludedProxy,
+  type TableHandle,
+  type TableInsertRow,
+  type TableSetValues,
+  table,
+} from '../contract-free/dml';

package/src/query-lane-context.ts

@@ -15,15 +15,17 @@ export interface CodecDescriptorRegistry {
   /**
    * Derive the canonical {@link CodecRef} for a contract `(table, column)`. The builder side calls this at AST construction time to stamp `codec` onto every column-bound `ParamRef` / `ProjectionItem`; the runtime side uses the result as the cache key into the content-keyed codec resolver.
    *
-   * Resolution rules over `storage.tables[table].columns[column]`:
+   * Resolution rules over `storage.namespaces[namespaceId].tables[table].columns[column]`:
    *
    * - `typeRef` column → emit `{codecId, typeParams}` from `storage.types[typeRef]` (multiple columns sharing the typeRef produce the same ref → same memoised codec).
    * - inline `typeParams` column → emit `{codecId, typeParams}` from the column itself.
    * - non-parameterized column → emit `{codecId}` with `typeParams` undefined (keys as `${codecId}:undefined` → one shared codec).
    *
-   * Returns `undefined` when the registry was built without contract storage (package-scoped registries used purely as descriptor lookups), when the table or column is unknown, or when the column declares a `typeRef` that the storage doesn't define.
+   * The `namespaceId` coordinate leads and is always supplied — the table is resolved strictly within that namespace, so two same-bare-named tables in different namespaces resolve to their own per-namespace columns/codecs without colliding.
+   *
+   * Returns `undefined` when the registry was built without contract storage (package-scoped registries used purely as descriptor lookups), when the table or column is unknown in the namespace, or when the column declares a `typeRef` that the storage doesn't define.
    */
-  codecRefForColumn(table: string, column: string): CodecRef | undefined;
+  codecRefForColumn(namespaceId: string, table: string, column: string): CodecRef | undefined;
   /**
    * All registered descriptors. Used by `validateCodecRegistryCompleteness` and other startup-time consumers that enumerate descriptors.
    */

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Contract, ContractModelsMap } from '@prisma-next/contract/types';
+import type { Contract, ContractModelDefinitions } from '@prisma-next/contract/types';
 import type { ParamSpec } from '@prisma-next/operations';
 import type {
   ExtractFieldOutputTypes,
@@ -17,7 +17,7 @@ export type Expr = ColumnRef | ParamRef;
  * whose `storage.table` matches.
  */
 type ExtractTableToModel<TContract extends Contract<SqlStorage>, TableName extends string> =
-  ContractModelsMap<TContract> extends infer Models extends Record<string, unknown>
+  ContractModelDefinitions<TContract> extends infer Models extends Record<string, unknown>
     ? {
         [M in keyof Models & string]: Models[M] extends {
           readonly storage: { readonly table: TableName };
@@ -37,7 +37,7 @@ type ExtractColumnToField<
   ColumnName extends string,
 > =
   ExtractTableToModel<TContract, TableName> extends infer ModelName extends string
-    ? ContractModelsMap<TContract> extends infer Models extends Record<string, unknown>
+    ? 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> };
@@ -151,26 +151,6 @@ export type ComputeColumnJsType<
         : never
     : never;
 
-/**
- * Utility type to check if a contract has the required capabilities for includeMany.
- * Requires both `lateral` and `jsonAgg` to be `true` in the contract's capabilities for the target.
- * Capabilities are nested by target: `{ [target]: { lateral: true, jsonAgg: true } }`
- */
-export type HasIncludeManyCapabilities<TContract extends Contract<SqlStorage>> = TContract extends {
-  capabilities: infer C;
-  target: infer T;
-}
-  ? T extends string
-    ? C extends Record<string, Record<string, boolean>>
-      ? C extends { [K in T]: infer TargetCaps }
-        ? TargetCaps extends { lateral: true; jsonAgg: true }
-          ? true
-          : false
-        : false
-      : false
-    : false
-  : false;
-
 /**
  * Alias for the SQL-domain executable plan, exposed under the legacy
  * `SqlPlan` name for compatibility with SQL builder/utility call sites.

package/dist/codec-types-Cezo7k-i.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-types-Cezo7k-i.d.mts","names":[],"sources":["../src/ast/codec-types.ts"],"mappings":";;;;AAqBA;;;;UAAiB,YAAA;EAAA,SACN,KAAA;EAAA,SACA,IAAI;AAAA;;;;;;UAQE,mBAAA,SAA4B,gBAAgB;EAAA,SAClD,MAAA,GAAS,YAAA;AAAA;;;;;;;;;AAasD;UADzD,uBAAA,SAAgC,oBAAoB;EAAA,SAC1D,MAAA,EAAQ,aAAA;IAAA,SAAyB,KAAA;IAAA,SAAwB,MAAA;EAAA;AAAA;;;;UAMnD,SAAA;EAAA,SACN,EAAA;IAAA,SACE,GAAA;MAAA,SACE,QAAA;QAAA,SACE,UAAA;MAAA;IAAA;EAAA;AAAA;;;;;;;;UAaA,OAAA,sDAEU,UAAA,cAAwB,UAAA,+CAGzC,KAAA,CAAU,EAAA,EAAI,OAAA,EAAS,KAAA,EAAO,MAAA;EACtC,MAAA,CAAO,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,mBAAA,GAAsB,OAAA,CAAQ,KAAA;EACzD,MAAA,CAAO,IAAA,EAAM,KAAA,EAAO,GAAA,EAAK,mBAAA,GAAsB,OAAA,CAAQ,MAAA;AAAA;;;;;;;;UAUxC,qBAAA;EAZG;;;EAgBlB,SAAA,CAAU,KAAA,UAAe,MAAA,WAAiB,OAAA;EAf1C;;;;;EAsBA,WAAA,CAAY,GAAA,EAAK,QAAA,GAAW,OAAA;AAAA;;;;;KAQlB,kBAAA,GAAqB,eAAe;AAAA,KAE3C,uBAAA,MACH,CAAA,SAAU,eAAA,aAA4B,UAAA,CAAW,UAAA,CAAW,CAAA;AAAA,KAElD,iBAAA,MAAuB,CAAA,SAAU,kBAAA,GAAqB,CAAA;AAAA,KAEtD,oBAAA,MACV,uBAAA,CAAwB,CAAA,UAAW,KAAA,kBAA2B,UAAA,yBAC1D,EAAA;AAtCyD;AAU/D;;;;;AAV+D,KA+CnD,qBAAA,MAA2B,CAAA;EAAA,SAC5B,MAAA,iCAAuC,UAAA;AAAA,IAE9C,OAAA,WAAkB,UAAA;;;;;;KAQV,iBAAA,4CAEa,WAAA,GAAc,kBAAA,KACjC,MAAA,yCAEiB,WAAA,IAAe,iBAAA,CAAkB,WAAA,CAAY,CAAA;EAAA,SACvD,KAAA,EAAO,oBAAA,CAAqB,WAAA,CAAY,CAAA;EAAA,SACxC,MAAA,EAAQ,oBAAA,CAAqB,WAAA,CAAY,CAAA;EAAA,SACzC,MAAA,EAAQ,qBAAA,CAAsB,WAAA,CAAY,CAAA;AAAA"}

package/dist/plan-CG3sy5kw.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan-CG3sy5kw.d.mts","names":[],"sources":["../src/plan.ts"],"mappings":";;;;;;;;AAkBA;;;;;;;;;;;UAAiB,YAAA,wBAAoC,SAAA,CAAU,GAAA;EAAA,SACpD,GAAA,EAAK,WAAA;EAAA,SACL,MAAA;AAAA;AAAM;AAoBjB;;;;;;;;;;;;;;;;AApBiB,iBAoBD,WAAA,eAAA,CACd,GAAA,EAAK,WAAA,EACL,QAAA,EAAU,QAAA,CAAS,UAAA,GACnB,MAAA,YACC,YAAA,CAAa,GAAA"}

package/dist/query-lane-context-Dw1Tz0kv.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query-lane-context-Dw1Tz0kv.d.mts","names":[],"sources":["../src/query-lane-context.ts"],"mappings":";;;;;;;;;AASA;UAAiB,uBAAA;;;;EAIf,aAAA,CAAc,OAAA,WAAkB,eAAA;EAgBtB;;;;;;;;;;;EAJV,iBAAA,CAAkB,KAAA,UAAe,MAAA,WAAiB,QAAA;EAIxC;;;EAAV,MAAA,IAAU,gBAAA,CAAiB,eAAA;EAIgB;;AAAe;EAA1D,YAAA,CAAa,UAAA,oBAA8B,eAAA;AAAA;;;AAMN;KAA3B,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;EAHP;;;;EAAA,SAQD,iBAAA,GAAoB,GAAA;AAAA;;;;;;UAQd,gBAAA,mBAAmC,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA;EAAA,SACzE,QAAA,EAAU,SAAA;EATV;;;EAAA,SAaA,cAAA,EAAgB,qBAAA;EALV;;;EAAA,SASN,gBAAA,EAAkB,uBAAA;EAAA,SAClB,eAAA,EAAiB,oBAAA;EAVwD;;;EAAA,SAczE,KAAA,EAAO,kBAAA;EALW;;;EAS3B,qBAAA,CAAsB,OAAA,EAAS,uBAAA,GAA0B,aAAA,CAAc,sBAAA;AAAA"}