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

package/src/ast/ddl-types.ts

@@ -1,6 +1,7 @@
 import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';
 import { isColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';
 import type { ReferentialAction } from '@prisma-next/sql-contract/types';
+import type { CodecRef } from './codec-types';
 import type { AnyParamRef } from './types';
 
 /**
@@ -71,6 +72,8 @@ export class DdlColumn {
   readonly notNull?: boolean | undefined;
   readonly primaryKey?: boolean | undefined;
   readonly default?: AnyDdlColumnDefault | undefined;
+  /** 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). */
+  readonly codecRef?: CodecRef | undefined;
 
   constructor(options: {
     readonly name: string;
@@ -78,12 +81,14 @@ export class DdlColumn {
     readonly notNull?: boolean;
     readonly primaryKey?: boolean;
     readonly default?: AnyDdlColumnDefault;
+    readonly codecRef?: CodecRef;
   }) {
     this.name = options.name;
     this.type = options.type;
     this.notNull = options.notNull;
     this.primaryKey = options.primaryKey;
     this.default = options.default;
+    this.codecRef = options.codecRef;
     Object.freeze(this);
   }
 }

package/src/ast/driver-types.ts

@@ -1,3 +1,11 @@
+/**
+ * A fully lowered SQL statement ready for a driver to execute: SQL text plus
+ * driver-ready (codec-encoded) parameter values. The output of the control
+ * adapter's `lowerToExecuteRequest`, handed to a driver via `SqlQueryable.query`
+ * or `execute`. Inline-substituted positions (e.g. DDL `DEFAULT`
+ * clauses) carry no param; `params` holds the wire values for the `$N`/`?`
+ * positions, in order.
+ */
 export interface SqlExecuteRequest {
   readonly sql: string;
   readonly params?: readonly unknown[];

package/src/ast/types.ts

@@ -378,6 +378,35 @@ export class DerivedTableSource extends FromSource {
   }
 }
 
+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) {
+    super();
+    this.fn = fn;
+    this.args = frozenArrayCopy(args);
+    this.alias = alias;
+    this.freeze();
+  }
+
+  static of(fn: string, args: ReadonlyArray<AnyExpression>, alias?: string): FunctionSource {
+    return new FunctionSource(fn, args, alias);
+  }
+
+  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);
+  }
+
+  override toFromSource(): AnyFromSource {
+    return this;
+  }
+}
+
 export class ColumnRef extends Expression {
   readonly kind = 'column-ref' as const;
   readonly table: string;
@@ -1299,7 +1328,7 @@ export class ProjectionItem extends AstNode {
 export type LimitOffsetValue = number | AnyExpression;
 
 export interface SelectAstOptions {
-  readonly from: AnyFromSource;
+  readonly from?: AnyFromSource;
   readonly joins: ReadonlyArray<JoinAst> | undefined;
   readonly projection: ReadonlyArray<ProjectionItem>;
   readonly where: AnyExpression | undefined;
@@ -1315,7 +1344,7 @@ export interface SelectAstOptions {
 
 export class SelectAst extends QueryAst {
   readonly kind = 'select' as const;
-  readonly from: AnyFromSource;
+  readonly from: AnyFromSource | undefined;
   readonly joins: ReadonlyArray<JoinAst> | undefined;
   readonly projection: ReadonlyArray<ProjectionItem>;
   readonly where: AnyExpression | undefined;
@@ -1368,79 +1397,113 @@ export class SelectAst extends QueryAst {
     });
   }
 
+  static noFrom(): SelectAst {
+    return new SelectAst({
+      joins: undefined,
+      projection: [],
+      where: undefined,
+      orderBy: undefined,
+      distinct: undefined,
+      distinctOn: undefined,
+      groupBy: undefined,
+      having: undefined,
+      limit: undefined,
+      offset: undefined,
+      selectAllIntent: undefined,
+    });
+  }
+
+  private toOptions(): SelectAstOptions {
+    return {
+      ...(this.from !== undefined ? { from: this.from } : {}),
+      joins: this.joins,
+      projection: this.projection,
+      where: this.where,
+      orderBy: this.orderBy,
+      distinct: this.distinct,
+      distinctOn: this.distinctOn,
+      groupBy: this.groupBy,
+      having: this.having,
+      limit: this.limit,
+      offset: this.offset,
+      selectAllIntent: this.selectAllIntent,
+    };
+  }
+
   withFrom(from: AnyFromSource): SelectAst {
-    return new SelectAst({ ...this, from });
+    return new SelectAst({ ...this.toOptions(), from });
   }
 
   withJoins(joins: ReadonlyArray<JoinAst>): SelectAst {
     return new SelectAst({
-      ...this,
+      ...this.toOptions(),
       joins: joins.length > 0 ? joins : undefined,
     });
   }
 
   withProjection(projection: ReadonlyArray<ProjectionItem>): SelectAst {
-    return new SelectAst({ ...this, projection });
+    return new SelectAst({ ...this.toOptions(), projection });
   }
 
   addProjection(alias: string, expr: ProjectionExpr): SelectAst {
     return new SelectAst({
-      ...this,
+      ...this.toOptions(),
       projection: [...this.projection, new ProjectionItem(alias, expr)],
     });
   }
 
   withWhere(where: AnyExpression | undefined): SelectAst {
-    return new SelectAst({ ...this, where });
+    return new SelectAst({ ...this.toOptions(), where });
   }
 
   withOrderBy(orderBy: ReadonlyArray<OrderByItem>): SelectAst {
     return new SelectAst({
-      ...this,
+      ...this.toOptions(),
       orderBy: orderBy.length > 0 ? orderBy : undefined,
     });
   }
 
   withDistinct(enabled = true): SelectAst {
     return new SelectAst({
-      ...this,
+      ...this.toOptions(),
       distinct: enabled ? true : undefined,
     });
   }
 
   withDistinctOn(distinctOn: ReadonlyArray<AnyExpression>): SelectAst {
     return new SelectAst({
-      ...this,
+      ...this.toOptions(),
       distinctOn: distinctOn.length > 0 ? distinctOn : undefined,
     });
   }
 
   withGroupBy(groupBy: ReadonlyArray<AnyExpression>): SelectAst {
     return new SelectAst({
-      ...this,
+      ...this.toOptions(),
       groupBy: groupBy.length > 0 ? groupBy : undefined,
     });
   }
 
   withHaving(having: AnyExpression | undefined): SelectAst {
-    return new SelectAst({ ...this, having });
+    return new SelectAst({ ...this.toOptions(), having });
   }
 
   withLimit(limit: LimitOffsetValue | undefined): SelectAst {
-    return new SelectAst({ ...this, limit });
+    return new SelectAst({ ...this.toOptions(), limit });
   }
 
   withOffset(offset: LimitOffsetValue | undefined): SelectAst {
-    return new SelectAst({ ...this, offset });
+    return new SelectAst({ ...this.toOptions(), offset });
   }
 
   withSelectAllIntent(selectAllIntent: { readonly table?: string } | undefined): SelectAst {
-    return new SelectAst({ ...this, selectAllIntent });
+    return new SelectAst({ ...this.toOptions(), selectAllIntent });
   }
 
   rewrite(rewriter: AstRewriter): SelectAst {
+    const rewrittenFrom = this.from?.rewrite(rewriter);
     const rewritten = new SelectAst({
-      from: this.from.rewrite(rewriter),
+      ...(rewrittenFrom !== undefined ? { from: rewrittenFrom } : {}),
       joins: this.joins?.map((join) => join.rewrite(rewriter)),
       projection: this.projection.map(
         (projection) =>
@@ -1474,8 +1537,12 @@ export class SelectAst extends QueryAst {
       refs.push(...columns);
     };
 
-    if (this.from.kind === 'derived-table-source') {
+    if (this.from?.kind === 'derived-table-source') {
       pushRefs(this.from.query.collectColumnRefs());
+    } else if (this.from?.kind === 'function-source') {
+      for (const arg of this.from.args) {
+        pushRefs(arg.collectColumnRefs());
+      }
     }
 
     for (const projection of this.projection) {
@@ -1502,6 +1569,10 @@ export class SelectAst extends QueryAst {
     for (const join of this.joins ?? []) {
       if (join.source.kind === 'derived-table-source') {
         pushRefs(join.source.query.collectColumnRefs());
+      } else if (join.source.kind === 'function-source') {
+        for (const arg of join.source.args) {
+          pushRefs(arg.collectColumnRefs());
+        }
       }
       if (join.on.kind === 'eq-col-join-on') {
         refs.push(join.on.left, join.on.right);
@@ -1525,8 +1596,12 @@ export class SelectAst extends QueryAst {
       refs.push(...params);
     };
 
-    if (this.from.kind === 'derived-table-source') {
+    if (this.from?.kind === 'derived-table-source') {
       pushRefs(this.from.query.collectParamRefs());
+    } else if (this.from?.kind === 'function-source') {
+      for (const arg of this.from.args) {
+        pushRefs(arg.collectParamRefs());
+      }
     }
 
     for (const projection of this.projection) {
@@ -1553,6 +1628,10 @@ export class SelectAst extends QueryAst {
     for (const join of this.joins ?? []) {
       if (join.source.kind === 'derived-table-source') {
         pushRefs(join.source.query.collectParamRefs());
+      } else if (join.source.kind === 'function-source') {
+        for (const arg of join.source.args) {
+          pushRefs(arg.collectParamRefs());
+        }
       }
       if (!(join.on.kind === 'eq-col-join-on')) {
         pushRefs(join.on.collectParamRefs());
@@ -1899,7 +1978,7 @@ export class RawSqlExpr extends QueryAst {
 }
 
 export type AnyQueryAst = SelectAst | InsertAst | UpdateAst | DeleteAst | RawSqlExpr;
-export type AnyFromSource = TableSource | DerivedTableSource;
+export type AnyFromSource = TableSource | DerivedTableSource | FunctionSource;
 export type AnyExpression =
   | ColumnRef
   | IdentifierRef

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

@@ -1,11 +1,7 @@
 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,
-} from '@prisma-next/sql-contract/types';
+import { isStorageTypeInstance, type SqlStorage } 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`.
@@ -34,38 +30,9 @@ export function codecRefForStorageColumn(
   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 typeSlot = (ns.entries as { type?: Record<string, unknown> }).type;
-        const nsEntry = typeSlot?.[columnDef.typeRef];
-        if (nsEntry !== undefined) {
-          instance = nsEntry;
-          break;
-        }
-      }
-    }
+    const instance = storage.types?.[columnDef.typeRef];
     if (!instance) return undefined;
-    if (isPostgresEnumStorageEntry(instance)) {
-      // Canonical path: the entry is a live `PostgresEnumType` IR
-      // instance reached through the per-target serializer's
-      // hydration. Raw JSON envelopes carrying `kind: 'postgres-enum'`
-      // never reach this site — `SqlStorage.normaliseTypeEntry`
-      // rejects them upstream (F09). Read `codecId` and `values` off
-      // the structural shape (enumerable own properties on the live
-      // instance) so the dispatch stays layered against the family
-      // alphabet rather than a target-specific class import.
-      return {
-        codecId: instance.codecId,
-        typeParams: { values: instance.values } as unknown as JsonValue,
-      };
-    }
     if (isStorageTypeInstance(instance)) {
-      // 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

package/src/contract-free/column.ts

@@ -1,5 +1,6 @@
 import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';
 import type { ReferentialAction } from '@prisma-next/sql-contract/types';
+import type { CodecRef } from '../ast/codec-types';
 import type { AnyDdlColumnDefault } from '../ast/ddl-types';
 import {
   DdlColumn,
@@ -14,6 +15,7 @@ export interface DdlColumnOptions {
   readonly notNull?: boolean;
   readonly primaryKey?: boolean;
   readonly default?: AnyDdlColumnDefault;
+  readonly codecRef?: CodecRef;
 }
 
 export function lit(value: ColumnDefaultLiteralInputValue): LiteralColumnDefault {

package/src/contract-free/dml.ts

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

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,