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

package/src/ast/ddl-types.ts

@@ -0,0 +1,198 @@
+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 { AnyParamRef } from './types';
+
+/**
+ * Render-time context the column-default visitor needs to make dialect
+ * decisions that depend on the parent column. Today only the parent
+ * column's native type (`"jsonb"`, `"text"`, …) — the Postgres renderer
+ * uses it to decide whether to emit a `::jsonb` / `::json` cast on JSON
+ * literal defaults so the emitted DDL matches the column type without
+ * relying on Postgres's implicit text → jsonb cast at default-evaluation
+ * time. Additional fields can join without re-shaping the interface.
+ */
+export interface DdlColumnRenderContext {
+  readonly nativeType: string;
+}
+
+export interface DdlColumnDefaultVisitor<R> {
+  literal(node: LiteralColumnDefault, ctx: DdlColumnRenderContext): R;
+  function(node: FunctionColumnDefault, ctx: DdlColumnRenderContext): R;
+}
+
+export abstract class DdlColumnDefault {
+  abstract readonly kind: string;
+  abstract accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): 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>, ctx: DdlColumnRenderContext): R {
+    return visitor.literal(this, ctx);
+  }
+}
+
+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>, ctx: DdlColumnRenderContext): R {
+    return visitor.function(this, ctx);
+  }
+}
+
+export type AnyDdlColumnDefault = LiteralColumnDefault | FunctionColumnDefault;
+
+export class DdlColumn {
+  readonly name: string;
+  readonly type: string;
+  readonly notNull?: boolean | undefined;
+  readonly primaryKey?: boolean | undefined;
+  readonly default?: AnyDdlColumnDefault | undefined;
+
+  constructor(options: {
+    readonly name: string;
+    readonly type: string;
+    readonly notNull?: boolean;
+    readonly primaryKey?: boolean;
+    readonly default?: AnyDdlColumnDefault;
+  }) {
+    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'
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Table-level constraint nodes
+// ---------------------------------------------------------------------------
+
+/**
+ * A composite (or single-column) PRIMARY KEY constraint on a `CreateTable`
+ * node. When `name` is set, the adapter renders `CONSTRAINT <name> PRIMARY KEY
+ * (…)`; otherwise it renders an anonymous `PRIMARY KEY (…)`.
+ *
+ * Frozen on construction — immutable after creation.
+ */
+export class PrimaryKeyConstraint {
+  readonly kind = 'primary-key' as const;
+  readonly columns: ReadonlyArray<string>;
+  readonly name: string | undefined;
+
+  constructor(options: { readonly columns: readonly string[]; readonly name?: string }) {
+    this.columns = Object.freeze([...options.columns]);
+    this.name = options.name;
+    Object.freeze(this);
+  }
+}
+
+/**
+ * A FOREIGN KEY constraint on a `CreateTable` node. `onDelete` and `onUpdate`
+ * use the same `ReferentialAction` vocabulary already used by the migration
+ * planner and the contract IR — no parallel string enum.
+ *
+ * Frozen on construction — immutable after creation.
+ */
+export class ForeignKeyConstraint {
+  readonly kind = 'foreign-key' as const;
+  readonly columns: ReadonlyArray<string>;
+  readonly refTable: string;
+  readonly refColumns: ReadonlyArray<string>;
+  readonly onDelete: ReferentialAction | undefined;
+  readonly onUpdate: ReferentialAction | undefined;
+  readonly name: string | undefined;
+
+  constructor(options: {
+    readonly columns: readonly string[];
+    readonly refTable: string;
+    readonly refColumns: readonly string[];
+    readonly onDelete?: ReferentialAction;
+    readonly onUpdate?: ReferentialAction;
+    readonly name?: string;
+  }) {
+    this.columns = Object.freeze([...options.columns]);
+    this.refTable = options.refTable;
+    this.refColumns = Object.freeze([...options.refColumns]);
+    this.onDelete = options.onDelete;
+    this.onUpdate = options.onUpdate;
+    this.name = options.name;
+    Object.freeze(this);
+  }
+}
+
+/**
+ * A table-level UNIQUE constraint on a `CreateTable` node. When `name` is
+ * set, the adapter renders `CONSTRAINT <name> UNIQUE (…)`; otherwise it
+ * renders an anonymous `UNIQUE (…)`.
+ *
+ * Frozen on construction — immutable after creation.
+ */
+export class UniqueConstraint {
+  readonly kind = 'unique' as const;
+  readonly columns: ReadonlyArray<string>;
+  readonly name: string | undefined;
+
+  constructor(options: { readonly columns: readonly string[]; readonly name?: string }) {
+    this.columns = Object.freeze([...options.columns]);
+    this.name = options.name;
+    Object.freeze(this);
+  }
+}
+
+export type DdlTableConstraint = PrimaryKeyConstraint | ForeignKeyConstraint | UniqueConstraint;

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 {
@@ -1683,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());
         }
       }
     }
@@ -1906,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/codec-descriptor-registry.ts

@@ -45,9 +45,9 @@ export function buildCodecDescriptorRegistry(
     descriptorFor(codecId: string): AnyDescriptor | undefined {
       return byId.get(codecId);
     },
-    codecRefForColumn(table: string, column: string): CodecRef | undefined {
+    codecRefForColumn(namespaceId: string, table: string, column: string): CodecRef | undefined {
       if (!storage) return undefined;
-      return codecRefForStorageColumn(storage, table, column);
+      return codecRefForStorageColumn(storage, namespaceId, table, column);
     },
     *values(): IterableIterator<AnyDescriptor> {
       yield* byId.values();

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';