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

package/src/runtime/mutation-impl.ts

@@ -12,7 +12,7 @@ import {
   InsertAst,
   ParamRef,
   ProjectionItem,
-  TableSource,
+  type TableSource,
   UpdateAst,
 } from '@prisma-next/sql-relational-core/ast';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
@@ -68,6 +68,7 @@ export type UpdateSetCallback = (
 
 export function buildParamValues(
   values: Record<string, unknown>,
+  namespaceId: string,
   table: StorageTable,
   tableName: string,
   op: MutationDefaultsOp,
@@ -76,12 +77,12 @@ export function buildParamValues(
   const params: Record<string, ParamRef> = {};
   for (const [col, value] of Object.entries(values)) {
     const column = table.columns[col];
-    const codec = column ? codecRefFor(ctx, tableName, col) : undefined;
+    const codec = column ? codecRefFor(ctx, namespaceId, tableName, col) : undefined;
     params[col] = ParamRef.of(value, codec ? { codec } : undefined);
   }
   for (const def of ctx.applyMutationDefaults({ op, table: tableName, values })) {
     const column = table.columns[def.column];
-    const codec = column ? codecRefFor(ctx, tableName, def.column) : undefined;
+    const codec = column ? codecRefFor(ctx, namespaceId, tableName, def.column) : undefined;
     params[def.column] = ParamRef.of(def.value, codec ? { codec } : undefined);
   }
   return params;
@@ -129,6 +130,7 @@ export function evaluateUpdateCallback(
 
 export function buildSetExpressions(
   exprs: Record<string, AstExpression>,
+  namespaceId: string,
   table: StorageTable,
   tableName: string,
   op: MutationDefaultsOp,
@@ -138,7 +140,7 @@ export function buildSetExpressions(
   for (const def of ctx.applyMutationDefaults({ op, table: tableName, values: exprs })) {
     if (!(def.column in set)) {
       const column = table.columns[def.column];
-      const codec = column ? codecRefFor(ctx, tableName, def.column) : undefined;
+      const codec = column ? codecRefFor(ctx, namespaceId, tableName, def.column) : undefined;
       set[def.column] = ParamRef.of(def.value, ifDefined('codec', codec));
     }
   }
@@ -153,7 +155,9 @@ export class InsertQueryImpl<
   extends BuilderBase<QC['capabilities']>
   implements InsertQuery<QC, AvailableScope, RowType>
 {
+  readonly #tableSource: TableSource;
   readonly #tableName: string;
+  readonly #namespaceId: string;
   readonly #table: StorageTable;
   readonly #scope: Scope;
   readonly #rows: ReadonlyArray<Record<string, unknown>>;
@@ -162,7 +166,8 @@ export class InsertQueryImpl<
   readonly #annotations: ReadonlyMap<string, AnnotationValue<unknown, OperationKind>>;
 
   constructor(
-    tableName: string,
+    tableSource: TableSource,
+    namespaceId: string,
     table: StorageTable,
     scope: Scope,
     rows: ReadonlyArray<Record<string, unknown>>,
@@ -172,7 +177,9 @@ export class InsertQueryImpl<
     annotations: ReadonlyMap<string, AnnotationValue<unknown, OperationKind>> = new Map(),
   ) {
     super(ctx);
-    this.#tableName = tableName;
+    this.#tableSource = tableSource;
+    this.#tableName = tableSource.name;
+    this.#namespaceId = namespaceId;
     this.#table = table;
     this.#scope = scope;
     this.#rows = rows;
@@ -192,7 +199,8 @@ export class InsertQueryImpl<
         newRowFields[col] = field;
       }
       return new InsertQueryImpl(
-        this.#tableName,
+        this.#tableSource,
+        this.#namespaceId,
         this.#table,
         this.#scope,
         this.#rows,
@@ -215,7 +223,8 @@ export class InsertQueryImpl<
     ...annotations: As & ValidAnnotations<'write', As>
   ): InsertQuery<QC, AvailableScope, RowType> {
     return new InsertQueryImpl(
-      this.#tableName,
+      this.#tableSource,
+      this.#namespaceId,
       this.#table,
       this.#scope,
       this.#rows,
@@ -235,10 +244,17 @@ export class InsertQueryImpl<
     }
 
     const paramRows = this.#rows.map((rowValues) =>
-      buildParamValues(rowValues, this.#table, this.#tableName, 'create', this.ctx),
+      buildParamValues(
+        rowValues,
+        this.#namespaceId,
+        this.#table,
+        this.#tableName,
+        'create',
+        this.ctx,
+      ),
     );
 
-    let ast = InsertAst.into(TableSource.named(this.#tableName)).withRows(paramRows);
+    let ast = InsertAst.into(this.#tableSource).withRows(paramRows);
 
     if (this.#returningColumns.length > 0) {
       ast = ast.withReturning(
@@ -262,6 +278,7 @@ export class UpdateQueryImpl<
   extends BuilderBase<QC['capabilities']>
   implements UpdateQuery<QC, AvailableScope, RowType>
 {
+  readonly #tableSource: TableSource;
   readonly #tableName: string;
   readonly #scope: Scope;
   readonly #setExpressions: Record<string, AstExpression>;
@@ -271,7 +288,7 @@ export class UpdateQueryImpl<
   readonly #annotations: ReadonlyMap<string, AnnotationValue<unknown, OperationKind>>;
 
   constructor(
-    tableName: string,
+    tableSource: TableSource,
     scope: Scope,
     setExpressions: Record<string, AstExpression>,
     ctx: BuilderContext,
@@ -281,7 +298,8 @@ export class UpdateQueryImpl<
     annotations: ReadonlyMap<string, AnnotationValue<unknown, OperationKind>> = new Map(),
   ) {
     super(ctx);
-    this.#tableName = tableName;
+    this.#tableSource = tableSource;
+    this.#tableName = tableSource.name;
     this.#scope = scope;
     this.#setExpressions = setExpressions;
     this.#whereExprs = whereExprs;
@@ -295,7 +313,7 @@ export class UpdateQueryImpl<
     const fns = createFunctions(this.ctx.queryOperationTypes, this.ctx.rawCodecInferer);
     const result = (expr as ExpressionBuilder<Scope, QueryContext>)(fieldProxy, fns as never);
     return new UpdateQueryImpl(
-      this.#tableName,
+      this.#tableSource,
       this.#scope,
       this.#setExpressions,
       this.ctx,
@@ -317,7 +335,7 @@ export class UpdateQueryImpl<
         newRowFields[col] = field;
       }
       return new UpdateQueryImpl(
-        this.#tableName,
+        this.#tableSource,
         this.#scope,
         this.#setExpressions,
         this.ctx,
@@ -338,7 +356,7 @@ export class UpdateQueryImpl<
     ...annotations: As & ValidAnnotations<'write', As>
   ): UpdateQuery<QC, AvailableScope, RowType> {
     return new UpdateQueryImpl(
-      this.#tableName,
+      this.#tableSource,
       this.#scope,
       this.#setExpressions,
       this.ctx,
@@ -353,7 +371,7 @@ export class UpdateQueryImpl<
   }
 
   build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>> {
-    let ast = UpdateAst.table(TableSource.named(this.#tableName))
+    let ast = UpdateAst.table(this.#tableSource)
       .withSet(this.#setExpressions)
       .withWhere(combineWhereExprs(this.#whereExprs));
 
@@ -379,6 +397,7 @@ export class DeleteQueryImpl<
   extends BuilderBase<QC['capabilities']>
   implements DeleteQuery<QC, AvailableScope, RowType>
 {
+  readonly #tableSource: TableSource;
   readonly #tableName: string;
   readonly #scope: Scope;
   readonly #whereCallbacks: readonly WhereCallback[];
@@ -387,7 +406,7 @@ export class DeleteQueryImpl<
   readonly #annotations: ReadonlyMap<string, AnnotationValue<unknown, OperationKind>>;
 
   constructor(
-    tableName: string,
+    tableSource: TableSource,
     scope: Scope,
     ctx: BuilderContext,
     whereCallbacks: readonly WhereCallback[] = [],
@@ -396,7 +415,8 @@ export class DeleteQueryImpl<
     annotations: ReadonlyMap<string, AnnotationValue<unknown, OperationKind>> = new Map(),
   ) {
     super(ctx);
-    this.#tableName = tableName;
+    this.#tableSource = tableSource;
+    this.#tableName = tableSource.name;
     this.#scope = scope;
     this.#whereCallbacks = whereCallbacks;
     this.#returningColumns = returningColumns;
@@ -406,7 +426,7 @@ export class DeleteQueryImpl<
 
   where(expr: ExpressionBuilder<AvailableScope, QC>): DeleteQuery<QC, AvailableScope, RowType> {
     return new DeleteQueryImpl(
-      this.#tableName,
+      this.#tableSource,
       this.#scope,
       this.ctx,
       [...this.#whereCallbacks, expr as unknown as WhereCallback],
@@ -427,7 +447,7 @@ export class DeleteQueryImpl<
         newRowFields[col] = field;
       }
       return new DeleteQueryImpl(
-        this.#tableName,
+        this.#tableSource,
         this.#scope,
         this.ctx,
         this.#whereCallbacks,
@@ -446,7 +466,7 @@ export class DeleteQueryImpl<
     ...annotations: As & ValidAnnotations<'write', As>
   ): DeleteQuery<QC, AvailableScope, RowType> {
     return new DeleteQueryImpl(
-      this.#tableName,
+      this.#tableSource,
       this.#scope,
       this.ctx,
       this.#whereCallbacks,
@@ -466,7 +486,7 @@ export class DeleteQueryImpl<
       ),
     );
 
-    let ast = DeleteAst.from(TableSource.named(this.#tableName)).withWhere(whereExpr);
+    let ast = DeleteAst.from(this.#tableSource).withWhere(whereExpr);
 
     if (this.#returningColumns.length > 0) {
       ast = ast.withReturning(

package/src/runtime/resolve-table.ts

@@ -0,0 +1,13 @@
+import type { SqlStorage, StorageTable } from '@prisma-next/sql-contract/types';
+
+export function resolveTableInNamespace(
+  storage: SqlStorage,
+  namespaceId: string,
+  tableName: string,
+): StorageTable | undefined {
+  const namespace = storage.namespaces[namespaceId];
+  if (namespace === undefined || !Object.hasOwn(namespace.entries.table, tableName)) {
+    return undefined;
+  }
+  return namespace.entries.table[tableName];
+}

package/src/runtime/sql.ts

@@ -1,9 +1,10 @@
 import type { Contract } from '@prisma-next/contract/types';
-import type { SqlStorage, StorageTable } from '@prisma-next/sql-contract/types';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { RawCodecInferer } from '@prisma-next/sql-relational-core/expression';
 import type { ExecutionContext } from '@prisma-next/sql-relational-core/query-lane-context';
 import type { Db, TableProxyContract } from '../types/db';
 import type { BuilderContext } from './builder-base';
+import { resolveTableInNamespace } from './resolve-table';
 import { TableProxyImpl } from './table-proxy-impl';
 
 export interface SqlOptions<C extends Contract<SqlStorage> & TableProxyContract> {
@@ -11,21 +12,6 @@ export interface SqlOptions<C extends Contract<SqlStorage> & TableProxyContract>
   readonly rawCodecInferer: RawCodecInferer;
 }
 
-// Find a table by name across every declared namespace. Mirrors the
-// flat-DSL contract (db.<tableName>): the first namespace that declares
-// `name` wins. Name collisions across namespaces are a type-level error
-// at the DSL call site; landing the namespace-aware DSL is tracked
-// separately.
-function findTableAcrossNamespaces(storage: SqlStorage, name: string): StorageTable | undefined {
-  for (const ns of Object.values(storage.namespaces)) {
-    const tables = (ns as { tables?: Readonly<Record<string, StorageTable>> }).tables ?? {};
-    if (Object.hasOwn(tables, name)) {
-      return tables[name];
-    }
-  }
-  return undefined;
-}
-
 export function sql<C extends Contract<SqlStorage> & TableProxyContract>(
   options: SqlOptions<C>,
 ): Db<C> {
@@ -40,13 +26,32 @@ export function sql<C extends Contract<SqlStorage> & TableProxyContract>(
     rawCodecInferer,
   };
 
+  const { storage } = context.contract;
+
   return new Proxy({} as Db<C>, {
-    get(_target, prop: string) {
-      const table = findTableAcrossNamespaces(context.contract.storage, prop);
-      if (table) {
-        return new TableProxyImpl(prop, table, prop, ctx);
+    get(_target, prop: string | symbol) {
+      if (typeof prop !== 'string') {
+        return undefined;
+      }
+      if (!Object.hasOwn(storage.namespaces, prop)) {
+        return undefined;
       }
-      return undefined;
+      const namespaceId = prop;
+      return new Proxy(
+        {},
+        {
+          get(_facetTarget, tableName: string | symbol) {
+            if (typeof tableName !== 'string') {
+              return undefined;
+            }
+            const table = resolveTableInNamespace(storage, namespaceId, tableName);
+            if (table) {
+              return new TableProxyImpl(tableName, table, tableName, ctx, namespaceId);
+            }
+            return undefined;
+          },
+        },
+      );
     },
   });
 }

package/src/runtime/table-proxy-impl.ts

@@ -1,5 +1,5 @@
 import type { StorageTable } from '@prisma-next/sql-contract/types';
-import { type AnyFromSource, TableSource } from '@prisma-next/sql-relational-core/ast';
+import type { AnyFromSource, TableSource } from '@prisma-next/sql-relational-core/ast';
 import type {
   AggregateFunctions,
   Expression,
@@ -43,6 +43,7 @@ import {
   type UpdateSetCallback,
 } from './mutation-impl';
 import { SelectQueryImpl } from './query-impl';
+import { tableSourceForProxy } from './table-source-for-proxy';
 
 export class TableProxyImpl<
     C extends TableProxyContract,
@@ -61,15 +62,27 @@ export class TableProxyImpl<
 
   readonly #tableName: string;
   readonly #table: StorageTable;
+  readonly #namespaceId: string;
   readonly #fromSource: TableSource;
   readonly #scope: Scope;
 
-  constructor(tableName: string, table: StorageTable, alias: string, ctx: BuilderContext) {
+  constructor(
+    tableName: string,
+    table: StorageTable,
+    alias: string,
+    ctx: BuilderContext,
+    namespaceId: string,
+  ) {
     super(ctx);
     this.#tableName = tableName;
     this.#table = table;
-    this.#scope = tableToScope(alias, table, { storage: ctx.storage, tableName });
-    this.#fromSource = TableSource.named(tableName, alias !== tableName ? alias : undefined);
+    this.#namespaceId = namespaceId;
+    this.#scope = tableToScope(alias, table, {
+      storage: ctx.storage,
+      tableName,
+      namespaceId,
+    });
+    this.#fromSource = tableSourceForProxy(tableName, alias, namespaceId);
   }
 
   lateralJoin = this._gate(
@@ -114,7 +127,7 @@ export class TableProxyImpl<
   as<NewAlias extends string>(
     newAlias: NewAlias,
   ): TableProxy<C, Name, NewAlias, RebindScope<AvailableScope, Alias, NewAlias>, QC> {
-    return new TableProxyImpl(this.#tableName, this.#table, newAlias, this.ctx);
+    return new TableProxyImpl(this.#tableName, this.#table, newAlias, this.ctx, this.#namespaceId);
   }
 
   select<Columns extends (keyof AvailableScope['topLevel'] & string)[]>(
@@ -165,7 +178,14 @@ export class TableProxyImpl<
   }
 
   insert(rows: ReadonlyArray<Record<string, unknown>>): InsertQuery<QC, AvailableScope, EmptyRow> {
-    return new InsertQueryImpl(this.#tableName, this.#table, this.#scope, rows, this.ctx);
+    return new InsertQueryImpl(
+      this.#fromSource,
+      this.#namespaceId,
+      this.#table,
+      this.#scope,
+      rows,
+      this.ctx,
+    );
   }
 
   update(
@@ -185,25 +205,27 @@ export class TableProxyImpl<
       );
       const setExpressions = buildSetExpressions(
         callbackExprs,
+        this.#namespaceId,
         this.#table,
         this.#tableName,
         'update',
         this.ctx,
       );
-      return new UpdateQueryImpl(this.#tableName, this.#scope, setExpressions, this.ctx);
+      return new UpdateQueryImpl(this.#fromSource, this.#scope, setExpressions, this.ctx);
     }
     const setExpressions = buildParamValues(
       setOrCallback,
+      this.#namespaceId,
       this.#table,
       this.#tableName,
       'update',
       this.ctx,
     );
-    return new UpdateQueryImpl(this.#tableName, this.#scope, setExpressions, this.ctx);
+    return new UpdateQueryImpl(this.#fromSource, this.#scope, setExpressions, this.ctx);
   }
 
   delete(): DeleteQuery<QC, AvailableScope, EmptyRow> {
-    return new DeleteQueryImpl(this.#tableName, this.#scope, this.ctx);
+    return new DeleteQueryImpl(this.#fromSource, this.#scope, this.ctx);
   }
 
   #toJoined(): JoinedTables<QC, AvailableScope> {

package/src/runtime/table-source-for-proxy.ts

@@ -0,0 +1,9 @@
+import { TableSource } from '@prisma-next/sql-relational-core/ast';
+
+export function tableSourceForProxy(
+  tableName: string,
+  alias: string,
+  namespaceId: string,
+): TableSource {
+  return TableSource.named(tableName, alias !== tableName ? alias : undefined, namespaceId);
+}

package/src/types/db.ts

@@ -3,16 +3,13 @@ import type { TableProxy } from './table-proxy';
 
 export type CapabilitiesBase = Record<string, Record<string, boolean>>;
 
-// The sql-builder DSL is flat by table name across every declared
-// namespace. Two namespaces declaring tables with the same name produce
-// a union at the DSL surface (which collapses to a type error at the
-// first call site); landing the namespace-aware DSL surface (db.<ns>.<table>)
-// is tracked separately. Within scope here: the DSL accepts the
-// namespaced storage shape directly and walks every namespace.
 export type TableProxyContract = {
   readonly storage: {
     readonly namespaces: Readonly<
-      Record<string, { readonly tables: Readonly<Record<string, StorageTable>> }>
+      Record<
+        string,
+        { readonly entries: { readonly table: Readonly<Record<string, StorageTable>> } }
+      >
     >;
   };
   readonly capabilities: CapabilitiesBase;
@@ -24,17 +21,28 @@ export type UnboundTables<C extends TableProxyContract> = {
   readonly [Name in TableNamesAcrossNamespaces<C>]: TableInAnyNamespace<C, Name>;
 };
 
-type TableNamesAcrossNamespaces<C extends TableProxyContract> = {
-  [NSId in keyof C['storage']['namespaces']]: keyof C['storage']['namespaces'][NSId]['tables'] &
+export type TableNamesAcrossNamespaces<C extends TableProxyContract> = {
+  [NSId in keyof C['storage']['namespaces']]: keyof C['storage']['namespaces'][NSId]['entries']['table'] &
     string;
 }[keyof C['storage']['namespaces']];
 
-type TableInAnyNamespace<C extends TableProxyContract, Name extends string> = {
-  [NSId in keyof C['storage']['namespaces']]: Name extends keyof C['storage']['namespaces'][NSId]['tables']
-    ? C['storage']['namespaces'][NSId]['tables'][Name]
+export type TableInAnyNamespace<C extends TableProxyContract, Name extends string> = {
+  [NSId in keyof C['storage']['namespaces']]: Name extends keyof C['storage']['namespaces'][NSId]['entries']['table']
+    ? C['storage']['namespaces'][NSId]['entries']['table'][Name]
     : never;
 }[keyof C['storage']['namespaces']];
 
+// The tables of a single storage namespace, keyed by bare table name. Lets
+// callers reach a table by its namespace coordinate (`db.<ns>.<table>`) when
+// the same bare name is declared in more than one namespace.
+export type Namespace<
+  C extends TableProxyContract,
+  NsId extends keyof C['storage']['namespaces'],
+> = {
+  readonly [Name in keyof C['storage']['namespaces'][NsId]['entries']['table'] &
+    string]: TableProxy<C, Name>;
+};
+
 export type Db<C extends TableProxyContract> = {
-  [Name in TableNamesAcrossNamespaces<C>]: TableProxy<C, Name>;
+  readonly [Ns in keyof C['storage']['namespaces']]: Namespace<C, Ns>;
 };

package/src/types/table-proxy.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 {
   ExtractCodecTypes,
   ExtractFieldInputTypes,
@@ -22,24 +22,24 @@ import type { WithJoin, WithSelect } from './shared';
 
 type FindModelForTable<C, TableName extends string> = C extends Contract
   ? {
-      [M in keyof ContractModelsMap<C> & string]: ContractModelsMap<C>[M] extends {
+      [M in keyof ContractModelDefinitions<C> & string]: ContractModelDefinitions<C>[M] extends {
         readonly storage: { readonly table: TableName };
       }
         ? M
         : never;
-    }[keyof ContractModelsMap<C> & string]
+    }[keyof ContractModelDefinitions<C> & string]
   : never;
 
 type FindFieldForColumn<C, ModelName extends string, ColumnName extends string> = C extends Contract
-  ? ModelName extends keyof ContractModelsMap<C>
+  ? ModelName extends keyof ContractModelDefinitions<C>
     ? {
-        [F in keyof ContractModelsMap<C>[ModelName]['storage']['fields'] &
-          string]: ContractModelsMap<C>[ModelName]['storage']['fields'][F] extends {
+        [F in keyof ContractModelDefinitions<C>[ModelName]['storage']['fields'] &
+          string]: ContractModelDefinitions<C>[ModelName]['storage']['fields'][F] extends {
           readonly column: ColumnName;
         }
           ? F
           : never;
-      }[keyof ContractModelsMap<C>[ModelName]['storage']['fields'] & string]
+      }[keyof ContractModelDefinitions<C>[ModelName]['storage']['fields'] & string]
     : never
   : never;