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

package/dist/{types-CkTDkFcK.d.mts.map → types-DRBn98H_.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-CkTDkFcK.d.mts","names":[],"sources":["../src/runtime-scope.ts"],"mappings":";;;;;;;;AASA;;KAAY,UAAA,GAAa,gBAAA,GAAmB,YAAY;;AAAA;AAUxD;;;;;;KAAY,YAAA,GAAe,IAAA,CAAK,eAAA,CAAgB,UAAA"}
+{"version":3,"file":"types-DRBn98H_.d.mts","names":[],"sources":["../src/runtime-scope.ts"],"mappings":";;;;;;;;AASA;;KAAY,UAAA,GAAa,gBAAA,GAAmB,YAAY;;AAAA;AAUxD;;;;;;KAAY,YAAA,GAAe,IAAA,CAAK,eAAA,CAAgB,UAAA"}

package/dist/{util-DWmhUCEO.mjs → util-DUXs0nZ9.mjs}

@@ -31,4 +31,4 @@ function collectOrderedParamRefs(ast) {
 //#endregion
 export { compact as n, collectOrderedParamRefs as t };
 
-//# sourceMappingURL=util-DWmhUCEO.mjs.map
+//# sourceMappingURL=util-DUXs0nZ9.mjs.map

package/dist/{util-DWmhUCEO.mjs.map → util-DUXs0nZ9.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"util-DWmhUCEO.mjs","names":[],"sources":["../src/ast/util.ts"],"sourcesContent":["import type { AnyParamRef, AnyQueryAst } from './types';\n\nexport function compact<T extends Record<string, unknown>>(o: T): T {\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(o)) {\n    if (v === undefined || v === null) continue;\n    if (Array.isArray(v) && v.length === 0) continue;\n    out[k] = v;\n  }\n  return out as T;\n}\n\n/**\n * Walks an AST's parameter references in first-encounter order and dedupes\n * by ParamRef identity. The single canonical helper used by every consumer\n * that aligns `plan.params` with metadata-by-index — the SQL builder lane,\n * the SQL ORM client, the SQL runtime encoder, and the Postgres renderer's\n * `$N` index map — so the four walks cannot drift in dedupe semantics.\n *\n * SQLite's `?`-placeholder renderer intentionally does NOT use this helper\n * because it needs one params entry per occurrence in the SQL.\n */\nexport function collectOrderedParamRefs(ast: AnyQueryAst): ReadonlyArray<AnyParamRef> {\n  const seen = new Set<AnyParamRef>();\n  const ordered: AnyParamRef[] = [];\n  for (const ref of ast.collectParamRefs()) {\n    if (seen.has(ref)) continue;\n    seen.add(ref);\n    ordered.push(ref);\n  }\n  return Object.freeze(ordered);\n}\n"],"mappings":";AAEA,SAAgB,QAA2C,GAAS;CAClE,MAAM,MAA+B,CAAC;CACtC,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,CAAC,GAAG;EACtC,IAAI,MAAM,KAAA,KAAa,MAAM,MAAM;EACnC,IAAI,MAAM,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG;EACxC,IAAI,KAAK;CACX;CACA,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,wBAAwB,KAA8C;CACpF,MAAM,uBAAO,IAAI,IAAiB;CAClC,MAAM,UAAyB,CAAC;CAChC,KAAK,MAAM,OAAO,IAAI,iBAAiB,GAAG;EACxC,IAAI,KAAK,IAAI,GAAG,GAAG;EACnB,KAAK,IAAI,GAAG;EACZ,QAAQ,KAAK,GAAG;CAClB;CACA,OAAO,OAAO,OAAO,OAAO;AAC9B"}
+{"version":3,"file":"util-DUXs0nZ9.mjs","names":[],"sources":["../src/ast/util.ts"],"sourcesContent":["import type { AnyParamRef, AnyQueryAst } from './types';\n\nexport function compact<T extends Record<string, unknown>>(o: T): T {\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(o)) {\n    if (v === undefined || v === null) continue;\n    if (Array.isArray(v) && v.length === 0) continue;\n    out[k] = v;\n  }\n  return out as T;\n}\n\n/**\n * Walks an AST's parameter references in first-encounter order and dedupes\n * by ParamRef identity. The single canonical helper used by every consumer\n * that aligns `plan.params` with metadata-by-index — the SQL builder lane,\n * the SQL ORM client, the SQL runtime encoder, and the Postgres renderer's\n * `$N` index map — so the four walks cannot drift in dedupe semantics.\n *\n * SQLite's `?`-placeholder renderer intentionally does NOT use this helper\n * because it needs one params entry per occurrence in the SQL.\n */\nexport function collectOrderedParamRefs(ast: AnyQueryAst): ReadonlyArray<AnyParamRef> {\n  const seen = new Set<AnyParamRef>();\n  const ordered: AnyParamRef[] = [];\n  for (const ref of ast.collectParamRefs()) {\n    if (seen.has(ref)) continue;\n    seen.add(ref);\n    ordered.push(ref);\n  }\n  return Object.freeze(ordered);\n}\n"],"mappings":";AAEA,SAAgB,QAA2C,GAAS;CAClE,MAAM,MAA+B,CAAC;CACtC,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,CAAC,GAAG;EACtC,IAAI,MAAM,KAAA,KAAa,MAAM,MAAM;EACnC,IAAI,MAAM,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG;EACxC,IAAI,KAAK;CACX;CACA,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,wBAAwB,KAA8C;CACpF,MAAM,uBAAO,IAAI,IAAiB;CAClC,MAAM,UAAyB,CAAC;CAChC,KAAK,MAAM,OAAO,IAAI,iBAAiB,GAAG;EACxC,IAAI,KAAK,IAAI,GAAG,GAAG;EACnB,KAAK,IAAI,GAAG;EACZ,QAAQ,KAAK,GAAG;CAClB;CACA,OAAO,OAAO,OAAO,OAAO;AAC9B"}

package/package.json

@@ -1,26 +1,26 @@
 {
   "name": "@prisma-next/sql-relational-core",
-  "version": "0.12.0-dev.4",
+  "version": "0.12.0-dev.41",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "AST types, query lane context, and type utilities for Prisma Next SQL lanes",
   "dependencies": {
-    "@prisma-next/contract": "0.12.0-dev.4",
-    "@prisma-next/framework-components": "0.12.0-dev.4",
-    "@prisma-next/operations": "0.12.0-dev.4",
-    "@prisma-next/sql-contract": "0.12.0-dev.4",
-    "@prisma-next/sql-operations": "0.12.0-dev.4",
-    "@prisma-next/utils": "0.12.0-dev.4",
+    "@prisma-next/contract": "0.12.0-dev.41",
+    "@prisma-next/framework-components": "0.12.0-dev.41",
+    "@prisma-next/operations": "0.12.0-dev.41",
+    "@prisma-next/sql-contract": "0.12.0-dev.41",
+    "@prisma-next/sql-operations": "0.12.0-dev.41",
+    "@prisma-next/utils": "0.12.0-dev.41",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@prisma-next/sql-contract-ts": "0.12.0-dev.4",
-    "@prisma-next/test-utils": "0.12.0-dev.4",
-    "@prisma-next/tsconfig": "0.12.0-dev.4",
-    "@prisma-next/tsdown": "0.12.0-dev.4",
+    "@prisma-next/sql-contract-ts": "0.12.0-dev.41",
+    "@prisma-next/test-utils": "0.12.0-dev.41",
+    "@prisma-next/tsconfig": "0.12.0-dev.41",
+    "@prisma-next/tsdown": "0.12.0-dev.41",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.6"
@@ -42,6 +42,7 @@
     ".": "./dist/index.mjs",
     "./ast": "./dist/exports/ast.mjs",
     "./codec-descriptor-registry": "./dist/exports/codec-descriptor-registry.mjs",
+    "./contract-free": "./dist/exports/contract-free.mjs",
     "./errors": "./dist/exports/errors.mjs",
     "./expression": "./dist/exports/expression.mjs",
     "./middleware": "./dist/exports/middleware.mjs",

package/src/ast/adapter-types.ts

@@ -4,11 +4,6 @@ import type { LoweredStatement } from './types';
 
 export type AdapterTarget = string;
 
-export interface MarkerStatement {
-  readonly sql: string;
-  readonly params: readonly unknown[];
-}
-
 /**
  * Outcome of an adapter's marker read. `no-table` means the marker storage itself is absent
  * (e.g. attaching to a database that was never `db init`'d); `absent` means the storage exists

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/codec-ref-for-column.ts

@@ -10,7 +10,7 @@ import {
 /**
  * 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.
@@ -25,7 +25,7 @@ export function codecRefForStorageColumn(
 ): CodecRef | undefined {
   let tableDef: StorageTable | undefined;
   for (const ns of Object.values(storage.namespaces)) {
-    const candidate = ns.tables[tableName] as StorageTable | undefined;
+    const candidate = ns.entries.table[tableName] as StorageTable | undefined;
     if (candidate !== undefined) {
       tableDef = candidate;
       break;
@@ -38,13 +38,11 @@ export function codecRefForStorageColumn(
     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;
         }
       }
     }

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