@prisma-next/sql-relational-core 0.12.0-dev.4 → 0.12.0-dev.40

package/src/ast/ddl-types.ts

@@ -0,0 +1,106 @@
+import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';
+import { isColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';
+import type { AnyParamRef } from './types';
+
+export interface DdlColumnDefaultVisitor<R> {
+  literal(node: LiteralColumnDefault): R;
+  function(node: FunctionColumnDefault): R;
+}
+
+export abstract class DdlColumnDefault {
+  abstract readonly kind: string;
+  abstract accept<R>(visitor: DdlColumnDefaultVisitor<R>): R;
+
+  protected freeze(): void {
+    Object.freeze(this);
+  }
+}
+
+export class LiteralColumnDefault extends DdlColumnDefault {
+  readonly kind = 'literal' as const;
+  readonly value: ColumnDefaultLiteralInputValue;
+
+  constructor(value: ColumnDefaultLiteralInputValue) {
+    super();
+    if (!isColumnDefaultLiteralInputValue(value)) {
+      throw new Error('Invalid column default literal value');
+    }
+    this.value = value;
+    this.freeze();
+  }
+
+  override accept<R>(visitor: DdlColumnDefaultVisitor<R>): R {
+    return visitor.literal(this);
+  }
+}
+
+export class FunctionColumnDefault extends DdlColumnDefault {
+  readonly kind = 'function' as const;
+  readonly expression: string;
+
+  constructor(expression: string) {
+    super();
+    this.expression = expression;
+    this.freeze();
+  }
+
+  override accept<R>(visitor: DdlColumnDefaultVisitor<R>): R {
+    return visitor.function(this);
+  }
+}
+
+export type AnyDdlColumnDefault = LiteralColumnDefault | FunctionColumnDefault;
+
+export class DdlColumn {
+  readonly name: string;
+  readonly type: string;
+  readonly notNull?: boolean | undefined;
+  readonly primaryKey?: boolean | undefined;
+  readonly default?: DdlColumnDefault | undefined;
+
+  constructor(options: {
+    readonly name: string;
+    readonly type: string;
+    readonly notNull?: boolean;
+    readonly primaryKey?: boolean;
+    readonly default?: DdlColumnDefault;
+  }) {
+    this.name = options.name;
+    this.type = options.type;
+    this.notNull = options.notNull;
+    this.primaryKey = options.primaryKey;
+    this.default = options.default;
+    Object.freeze(this);
+  }
+}
+
+export abstract class DdlNode {
+  abstract readonly kind: string;
+
+  /**
+   * Structural brand: every DDL node answers `true`. Lets {@link isDdlNode}
+   * recognise any `DdlNode` subclass — including target-contributed kinds —
+   * without a central kind registry that subclasses would have to register
+   * into.
+   */
+  isDdlNode(): true {
+    return true;
+  }
+
+  protected freeze(): void {
+    Object.freeze(this);
+  }
+
+  collectParamRefs(): AnyParamRef[] {
+    return [];
+  }
+}
+
+export function isDdlNode(value: unknown): value is DdlNode {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'isDdlNode' in value &&
+    typeof value.isDdlNode === 'function'
+  );
+}

package/src/ast/types.ts

@@ -80,7 +80,7 @@ export interface ExpressionFolder<T> {
 }
 
 export type ProjectionExpr = AnyExpression;
-export type InsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr;
+export type InsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr | RawExpr;
 export type JoinOnExpr = EqColJoinOn | AnyExpression;
 export type WhereArg = AnyExpression | ToWhereExpr;
 export type JsonObjectEntry = {
@@ -205,6 +205,11 @@ function rewriteInsertValue(value: InsertValue, rewriter: AstRewriter): InsertVa
       return rewriter.columnRef ? rewriteColumnRefForInsert(value, rewriter) : value;
     case 'default-value':
       return value;
+    // RawExpr insert values are opaque DB-side expressions (e.g. `now()` /
+    // `datetime('now')`) carried in value position; they are not a rewrite
+    // target on the insert path.
+    case 'raw-expr':
+      return value;
   }
 }
 
@@ -312,16 +317,25 @@ export class TableSource extends FromSource {
   readonly kind = 'table-source' as const;
   readonly name: string;
   readonly alias: string | undefined;
+  /**
+   * Resolved storage namespace coordinate for this table, stamped when the
+   * table proxy constructs the AST. Renderers qualify via the namespace
+   * concretion's `qualifyTable()` using this id — never by re-resolving the
+   * bare table name at render time.
+   */
+  readonly namespaceId: string | undefined;
 
-  constructor(name: string, alias?: string) {
+  protected constructor(name: string, alias?: string, namespaceId?: string) {
     super();
     this.name = name;
     this.alias = alias;
-    this.freeze();
+    this.namespaceId = namespaceId;
   }
 
-  static named(name: string, alias?: string): TableSource {
-    return new TableSource(name, alias);
+  static named(name: string, alias?: string, namespaceId?: string): TableSource {
+    const source = new TableSource(name, alias, namespaceId);
+    source.freeze();
+    return source;
   }
 
   override rewrite(rewriter: AstRewriter): AnyFromSource {
@@ -857,6 +871,15 @@ export class OrderByItem extends AstNode {
   rewrite(rewriter: ExpressionRewriter): OrderByItem {
     return new OrderByItem(this.expr.rewrite(rewriter), this.dir);
   }
+
+  /**
+   * A new frozen item with the sort direction flipped and `expr` unchanged.
+   * Integrations that own pagination (e.g. backward cursor pagination) use
+   * this to reverse a user's sort order without reaching into the AST.
+   */
+  reverse(): OrderByItem {
+    return new OrderByItem(this.expr, this.dir === 'asc' ? 'desc' : 'asc');
+  }
 }
 
 export class JsonArrayAggExpr extends Expression {
@@ -1674,6 +1697,8 @@ export class InsertAst extends QueryAst {
       for (const value of Object.values(row)) {
         if (value.kind === 'param-ref' || value.kind === 'prepared-param-ref') {
           refs.push(value);
+        } else if (value.kind === 'raw-expr') {
+          refs.push(...value.collectParamRefs());
         }
       }
     }
@@ -1897,7 +1922,7 @@ export type AnyExpression =
   | RawExpr;
 export type AnyParamRef = ParamRef | PreparedParamRef;
 export type AnyInsertOnConflictAction = DoNothingConflictAction | DoUpdateSetConflictAction;
-export type AnyInsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr;
+export type AnyInsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr | RawExpr;
 export type AnyOperationArg = AnyExpression | ParamRef | PreparedParamRef | LiteralExpr;
 
 export const queryAstKinds: ReadonlySet<string> = new Set<AnyQueryAst['kind']>([

package/src/contract-free/column.ts

@@ -0,0 +1,21 @@
+import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';
+import type { DdlColumnDefault } from '../ast/ddl-types';
+import { DdlColumn, FunctionColumnDefault, LiteralColumnDefault } from '../ast/ddl-types';
+
+export interface DdlColumnOptions {
+  readonly notNull?: boolean;
+  readonly primaryKey?: boolean;
+  readonly default?: DdlColumnDefault;
+}
+
+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 });
+}

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,18 @@
+export { col, type DdlColumnOptions, fn, lit } 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/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.