@prisma-next/sql-builder 0.13.0 → 0.14.0

package/src/runtime/sql.ts

@@ -4,7 +4,7 @@ import type { RawCodecInferer } from '@prisma-next/sql-relational-core/expressio
 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 { resolveTableForFlatName, resolveTableInNamespace } from './resolve-table';
+import { resolveTableInNamespace } from './resolve-table';
 import { TableProxyImpl } from './table-proxy-impl';
 
 export interface SqlOptions<C extends Contract<SqlStorage> & TableProxyContract> {
@@ -29,27 +29,32 @@ export function sql<C extends Contract<SqlStorage> & TableProxyContract>(
   const { storage } = context.contract;
 
   return new Proxy({} as Db<C>, {
-    get(_target, prop: string) {
-      if (Object.hasOwn(storage.namespaces, prop)) {
-        const namespaceId = prop;
-        return new Proxy(
-          {},
-          {
-            get(_facetTarget, tableName: string) {
-              const table = resolveTableInNamespace(storage, namespaceId, tableName);
-              if (table) {
-                return new TableProxyImpl(tableName, table, tableName, ctx, namespaceId);
-              }
-              return undefined;
-            },
-          },
-        );
+    get(_target, prop: string | symbol) {
+      if (typeof prop !== 'string') {
+        return undefined;
       }
-      const resolved = resolveTableForFlatName(storage, prop);
-      if (resolved) {
-        return new TableProxyImpl(prop, resolved.table, prop, ctx, resolved.namespaceId);
+      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) {
+              // `namespaceId` is a dynamic Proxy key with no static literal here, so the
+              // proxy's `NsId` type param lands on its `string` default at this boundary.
+              // `TableProxyImpl` still forwards `NsId` through its `as()`/join chain.
+              return new TableProxyImpl(tableName, table, tableName, ctx, namespaceId);
+            }
+            return undefined;
+          },
+        },
+      );
     },
   });
 }

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

@@ -25,7 +25,7 @@ import type {
   StorageTableToScopeTable,
   Subquery,
 } from '../scope';
-import type { TableProxyContract, UnboundTables } from '../types/db';
+import type { NamespaceTable, TableProxyContract } from '../types/db';
 import type { JoinedTables } from '../types/joined-tables';
 import type { DeleteQuery, InsertQuery, UpdateQuery } from '../types/mutation-query';
 import type { SelectQuery } from '../types/select-query';
@@ -47,16 +47,17 @@ import { tableSourceForProxy } from './table-source-for-proxy';
 
 export class TableProxyImpl<
     C extends TableProxyContract,
-    Name extends string & keyof UnboundTables<C>,
+    Name extends string,
     Alias extends string,
     AvailableScope extends Scope,
     QC extends QueryContext,
+    NsId extends string = string,
   >
   extends BuilderBase<C['capabilities']>
-  implements TableProxy<C, Name, Alias, AvailableScope, QC>
+  implements TableProxy<C, NsId, Name, Alias, AvailableScope, QC>
 {
   declare readonly [JoinOuterScope]: JoinSource<
-    StorageTableToScopeTable<UnboundTables<C>[Name]>,
+    StorageTableToScopeTable<NamespaceTable<C, NsId, Name>>,
     Alias
   >[typeof JoinOuterScope];
 
@@ -97,7 +98,7 @@ export class TableProxyImpl<
     > => {
       return this.#toJoined().lateralJoin(alias, builder);
     },
-  ) as TableProxy<C, Name, Alias, AvailableScope, QC>['lateralJoin'];
+  ) as TableProxy<C, NsId, Name, Alias, AvailableScope, QC>['lateralJoin'];
 
   outerLateralJoin = this._gate(
     { sql: { lateral: true } },
@@ -114,7 +115,7 @@ export class TableProxyImpl<
     > => {
       return this.#toJoined().outerLateralJoin(alias, builder);
     },
-  ) as TableProxy<C, Name, Alias, AvailableScope, QC>['outerLateralJoin'];
+  ) as TableProxy<C, NsId, Name, Alias, AvailableScope, QC>['outerLateralJoin'];
 
   getJoinOuterScope(): Scope {
     return this.#scope;
@@ -126,8 +127,15 @@ 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, this.#namespaceId);
+  ): TableProxy<C, NsId, Name, NewAlias, RebindScope<AvailableScope, Alias, NewAlias>, QC> {
+    return new TableProxyImpl<
+      C,
+      Name,
+      NewAlias,
+      RebindScope<AvailableScope, Alias, NewAlias>,
+      QC,
+      NsId
+    >(this.#tableName, this.#table, newAlias, this.ctx, this.#namespaceId);
   }
 
   select<Columns extends (keyof AvailableScope['topLevel'] & string)[]>(

package/src/types/db.ts

@@ -3,24 +3,33 @@ 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.
+type NamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+
+// The application-domain models the table-proxy helpers read to map a storage
+// table -> model and column -> field within a namespace coordinate. The index
+// signature lets the helpers index `C['domain']['namespaces'][NsId]` by a
+// generic `NsId` directly, so `FindModelForTable` / `FindFieldForColumn` no
+// longer need a `C extends Contract<SqlStorage>` guard to reach the per-namespace
+// models; concrete emitted contracts (whose models are richer) satisfy it.
+type NamespaceDomain = Readonly<
+  Record<string, { readonly models: Readonly<Record<string, unknown>> }>
+>;
+
 export type TableProxyContract = {
+  readonly domain: {
+    readonly namespaces: NamespaceDomain;
+  };
   readonly storage: {
-    readonly namespaces: Readonly<
-      Record<
-        string,
-        { readonly entries: { readonly table: Readonly<Record<string, StorageTable>> } }
-      >
-    >;
+    readonly namespaces: Readonly<Record<string, { readonly entries: NamespaceEntries }>>;
   };
   readonly capabilities: CapabilitiesBase;
 };
 
+type TablesInNamespace<NS extends { readonly entries: NamespaceEntries }> =
+  NS['entries']['table'] extends Readonly<Record<string, StorageTable>>
+    ? NS['entries']['table']
+    : Readonly<Record<string, StorageTable>>;
+
 // Union of every table name declared in any namespace of `C`. Replaces
 // the prior `UnboundTables<C>` indexing (which only saw `__unbound__`).
 export type UnboundTables<C extends TableProxyContract> = {
@@ -28,31 +37,48 @@ export type UnboundTables<C extends TableProxyContract> = {
 };
 
 export type TableNamesAcrossNamespaces<C extends TableProxyContract> = {
-  [NSId in keyof C['storage']['namespaces']]: keyof C['storage']['namespaces'][NSId]['entries']['table'] &
+  [NSId in keyof C['storage']['namespaces']]: keyof TablesInNamespace<
+    C['storage']['namespaces'][NSId]
+  > &
     string;
 }[keyof C['storage']['namespaces']];
 
 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]
+  [NSId in keyof C['storage']['namespaces']]: Name extends keyof TablesInNamespace<
+    C['storage']['namespaces'][NSId]
+  >
+    ? TablesInNamespace<C['storage']['namespaces'][NSId]>[Name]
     : never;
 }[keyof C['storage']['namespaces']];
 
+// The exact storage table at a single namespace coordinate. Resolving through
+// the coordinate (rather than the cross-namespace `UnboundTables` union) keeps
+// a bare table name shared across namespaces resolving to each namespace's own
+// table — no per-namespace column intersection. `TablesInNamespace` narrows the
+// open-dict `entries['table']` (`Record<string, unknown>`) back to the typed
+// `StorageTable` map before indexing by the bare name.
+export type NamespaceTable<
+  C extends TableProxyContract,
+  NsId extends string,
+  Name extends string,
+> = TablesInNamespace<C['storage']['namespaces'][NsId]>[Name];
+
 // 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.
+// the same bare name is declared in more than one namespace. The `NsId`
+// coordinate is threaded into each `TableProxy` so its column/field resolution
+// is a function of `(NsId, Name)`, not `Name` alone.
 export type Namespace<
   C extends TableProxyContract,
-  NsId extends keyof C['storage']['namespaces'],
+  NsId extends string & keyof C['storage']['namespaces'],
 > = {
-  readonly [Name in keyof C['storage']['namespaces'][NsId]['entries']['table'] &
-    string]: TableProxy<C, Name>;
+  readonly [Name in keyof TablesInNamespace<C['storage']['namespaces'][NsId]> & string]: TableProxy<
+    C,
+    NsId,
+    Name
+  >;
 };
 
-// Additive intersection: the flat by-bare-name surface retained alongside a
-// per-namespace facet keyed by namespace id.
 export type Db<C extends TableProxyContract> = {
-  readonly [Name in TableNamesAcrossNamespaces<C>]: TableProxy<C, Name>;
-} & {
-  readonly [Ns in keyof C['storage']['namespaces']]: Namespace<C, Ns>;
+  readonly [Ns in keyof C['storage']['namespaces'] & string]: Namespace<C, Ns>;
 };

package/src/types/table-proxy.ts

@@ -1,11 +1,10 @@
-import type { Contract, ContractModelDefinitions } from '@prisma-next/contract/types';
 import type {
   ExtractCodecTypes,
   ExtractFieldInputTypes,
-  ExtractFieldOutputTypes,
   ExtractQueryOperationTypes,
   StorageTable,
 } from '@prisma-next/sql-contract/types';
+import type { ComputeColumnJsType } from '@prisma-next/sql-relational-core/types';
 import type { Expression, FieldProxy, Functions } from '../expression';
 import type {
   DefaultScope,
@@ -16,98 +15,111 @@ import type {
   Scope,
   StorageTableToScopeTable,
 } from '../scope';
-import type { TableProxyContract, UnboundTables } from './db';
+import type { NamespaceTable, TableProxyContract } from './db';
 import type { DeleteQuery, InsertQuery, InsertValues, UpdateQuery } from './mutation-query';
 import type { WithJoin, WithSelect } from './shared';
 
-type FindModelForTable<C, TableName extends string> = C extends Contract
+type FindModelForTable<
+  C extends TableProxyContract,
+  NsId extends string,
+  TableName extends string,
+> = C['domain']['namespaces'][NsId]['models'] extends infer Models extends Record<string, unknown>
   ? {
-      [M in keyof ContractModelDefinitions<C> & string]: ContractModelDefinitions<C>[M] extends {
+      [M in keyof Models & string]: Models[M] extends {
         readonly storage: { readonly table: TableName };
       }
         ? M
         : never;
-    }[keyof ContractModelDefinitions<C> & string]
+    }[keyof Models & string]
   : never;
 
-type FindFieldForColumn<C, ModelName extends string, ColumnName extends string> = C extends Contract
-  ? ModelName extends keyof ContractModelDefinitions<C>
-    ? {
-        [F in keyof ContractModelDefinitions<C>[ModelName]['storage']['fields'] &
-          string]: ContractModelDefinitions<C>[ModelName]['storage']['fields'][F] extends {
-          readonly column: ColumnName;
-        }
-          ? F
-          : never;
-      }[keyof ContractModelDefinitions<C>[ModelName]['storage']['fields'] & string]
+type FindFieldForColumn<
+  C extends TableProxyContract,
+  NsId extends string,
+  ModelName extends string,
+  ColumnName extends string,
+> = C['domain']['namespaces'][NsId]['models'] extends infer Models extends Record<string, unknown>
+  ? ModelName extends keyof Models
+    ? Models[ModelName] extends {
+        readonly storage: { readonly fields: infer Fields extends Record<string, unknown> };
+      }
+      ? {
+          [F in keyof Fields & string]: Fields[F] extends { readonly column: ColumnName }
+            ? F
+            : never;
+        }[keyof Fields & string]
+      : never
     : never
   : never;
 
+// The select-result row's column types for a table at a namespace coordinate.
+// Each column resolves through `ComputeColumnJsType` with the coordinate, so
+// refined per-namespace output types (e.g. `Vector<N>`) are preserved and
+// same-named tables across namespaces resolve to each namespace's own columns.
+// `ComputeColumnJsType`'s constraint is the minimal `ColumnResolutionContract`,
+// which `TableProxyContract` satisfies, so `C` is indexed directly — no
+// `C extends Contract<SqlStorage>` guard.
 type ResolvedColumnTypes<
-  C,
+  C extends TableProxyContract,
+  NsId extends string,
   TableName extends string,
-  FieldTypes extends Record<string, Record<string, unknown>>,
-> = string extends keyof FieldTypes
-  ? Record<string, never>
-  : FindModelForTable<C, TableName> extends infer ModelName extends string
-    ? ModelName extends keyof FieldTypes
-      ? C extends TableProxyContract
-        ? UnboundTables<C> extends infer Tables extends Record<string, StorageTable>
-          ? TableName extends keyof Tables
-            ? {
-                [ColName in keyof Tables[TableName]['columns'] & string]: FindFieldForColumn<
-                  C,
-                  ModelName,
-                  ColName
-                > extends infer FieldName extends string
-                  ? FieldName extends keyof FieldTypes[ModelName]
-                    ? FieldTypes[ModelName][FieldName]
-                    : unknown
-                  : unknown;
-              }
-            : Record<string, never>
-          : Record<string, never>
-        : Record<string, never>
-      : Record<string, never>
+> =
+  NamespaceTable<C, NsId, TableName> extends infer Table extends StorageTable
+    ? {
+        [ColName in keyof Table['columns'] & string]: ComputeColumnJsType<
+          C,
+          NsId,
+          TableName,
+          ColName,
+          ExtractCodecTypes<C>
+        >;
+      }
     : Record<string, never>;
 
 type ResolvedInsertValues<
-  C,
+  C extends TableProxyContract,
+  NsId extends string,
   Table extends StorageTable,
   TableName extends string,
   CT extends Record<string, { readonly input: unknown }>,
-  FieldInputs extends Record<string, Record<string, unknown>>,
+  FieldInputs extends Record<string, Record<string, Record<string, unknown>>>,
 > = string extends keyof FieldInputs
   ? InsertValues<Table, CT>
-  : FindModelForTable<C, TableName> extends infer ModelName extends string
-    ? ModelName extends keyof FieldInputs
-      ? {
-          [K in keyof Table['columns']]?: FindFieldForColumn<
-            C,
-            ModelName,
-            K & string
-          > extends infer FieldName extends string
-            ? FieldName extends keyof FieldInputs[ModelName]
-              ? Table['columns'][K]['nullable'] extends true
-                ? NonNullable<FieldInputs[ModelName][FieldName]> | null
-                : NonNullable<FieldInputs[ModelName][FieldName]>
-              : Table['columns'][K]['codecId'] extends keyof CT
-                ? CT[Table['columns'][K]['codecId']]['input']
-                : unknown
-            : Table['columns'][K]['codecId'] extends keyof CT
-              ? CT[Table['columns'][K]['codecId']]['input']
-              : unknown;
-        }
+  : NsId extends keyof FieldInputs
+    ? FieldInputs[NsId] extends infer NsInputs extends Record<string, Record<string, unknown>>
+      ? FindModelForTable<C, NsId, TableName> extends infer ModelName extends string
+        ? ModelName extends keyof NsInputs
+          ? {
+              [K in keyof Table['columns']]?: FindFieldForColumn<
+                C,
+                NsId,
+                ModelName,
+                K & string
+              > extends infer FieldName extends string
+                ? FieldName extends keyof NsInputs[ModelName]
+                  ? Table['columns'][K]['nullable'] extends true
+                    ? NonNullable<NsInputs[ModelName][FieldName]> | null
+                    : NonNullable<NsInputs[ModelName][FieldName]>
+                  : Table['columns'][K]['codecId'] extends keyof CT
+                    ? CT[Table['columns'][K]['codecId']]['input']
+                    : unknown
+                : Table['columns'][K]['codecId'] extends keyof CT
+                  ? CT[Table['columns'][K]['codecId']]['input']
+                  : unknown;
+            }
+          : InsertValues<Table, CT>
+        : InsertValues<Table, CT>
       : InsertValues<Table, CT>
     : InsertValues<Table, CT>;
 
 type ResolvedUpdateValues<
-  C,
+  C extends TableProxyContract,
+  NsId extends string,
   Table extends StorageTable,
   TableName extends string,
   CT extends Record<string, { readonly input: unknown }>,
-  FieldInputs extends Record<string, Record<string, unknown>>,
-> = ResolvedInsertValues<C, Table, TableName, CT, FieldInputs>;
+  FieldInputs extends Record<string, Record<string, Record<string, unknown>>>,
+> = ResolvedInsertValues<C, NsId, Table, TableName, CT, FieldInputs>;
 
 type ResolvedUpdateExpressions<Table extends StorageTable> = {
   [K in keyof Table['columns']]?: Expression<{
@@ -116,31 +128,37 @@ type ResolvedUpdateExpressions<Table extends StorageTable> = {
   }>;
 };
 
-export type ContractToQC<C extends TableProxyContract, Name extends string = string> = {
+export type ContractToQC<
+  C extends TableProxyContract,
+  NsId extends string = string,
+  Name extends string = string,
+> = {
   readonly codecTypes: ExtractCodecTypes<C>;
   readonly capabilities: C['capabilities'];
   readonly queryOperationTypes: ExtractQueryOperationTypes<C>;
-  readonly resolvedColumnOutputTypes: ResolvedColumnTypes<C, Name, ExtractFieldOutputTypes<C>>;
+  readonly resolvedColumnOutputTypes: ResolvedColumnTypes<C, NsId, Name>;
 };
 
 export interface TableProxy<
   C extends TableProxyContract,
-  Name extends string & keyof UnboundTables<C>,
+  NsId extends string,
+  Name extends string,
   Alias extends string = Name,
-  AvailableScope extends Scope = DefaultScope<Name, UnboundTables<C>[Name]>,
-  QC extends QueryContext = ContractToQC<C, Name>,
-> extends JoinSource<StorageTableToScopeTable<UnboundTables<C>[Name]>, Alias>,
+  AvailableScope extends Scope = DefaultScope<Name, NamespaceTable<C, NsId, Name>>,
+  QC extends QueryContext = ContractToQC<C, NsId, Name>,
+> extends JoinSource<StorageTableToScopeTable<NamespaceTable<C, NsId, Name>>, Alias>,
     WithSelect<QC, AvailableScope, EmptyRow>,
     WithJoin<QC, AvailableScope, C['capabilities']> {
   as<NewAlias extends string>(
     newAlias: NewAlias,
-  ): TableProxy<C, Name, NewAlias, RebindScope<AvailableScope, Alias, NewAlias>, QC>;
+  ): TableProxy<C, NsId, Name, NewAlias, RebindScope<AvailableScope, Alias, NewAlias>, QC>;
 
   insert(
     rows: ReadonlyArray<
       ResolvedInsertValues<
         C,
-        UnboundTables<C>[Name],
+        NsId,
+        NamespaceTable<C, NsId, Name>,
         Name,
         QC['codecTypes'],
         ExtractFieldInputTypes<C>
@@ -151,7 +169,8 @@ export interface TableProxy<
   update(
     set: ResolvedUpdateValues<
       C,
-      UnboundTables<C>[Name],
+      NsId,
+      NamespaceTable<C, NsId, Name>,
       Name,
       QC['codecTypes'],
       ExtractFieldInputTypes<C>
@@ -162,7 +181,7 @@ export interface TableProxy<
     callback: (
       fields: FieldProxy<AvailableScope>,
       fns: Functions<QC>,
-    ) => ResolvedUpdateExpressions<UnboundTables<C>[Name]>,
+    ) => ResolvedUpdateExpressions<NamespaceTable<C, NsId, Name>>,
   ): UpdateQuery<QC, AvailableScope, EmptyRow>;
 
   delete(): DeleteQuery<QC, AvailableScope, EmptyRow>;