@prisma-next/sql-contract 0.13.0 → 0.14.0-dev.10

package/src/ir/sql-unbound-namespace.ts

@@ -3,6 +3,8 @@ import {
   NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
+import { blindCast } from '@prisma-next/utils/casts';
+import type { SqlNamespaceEntries } from './sql-storage';
 import type { StorageTable } from './storage-table';
 
 /**
@@ -40,9 +42,12 @@ export class SqlUnboundNamespace extends NamespaceBase {
   static readonly instance: SqlUnboundNamespace = new SqlUnboundNamespace();
 
   readonly id = UNBOUND_NAMESPACE_ID;
-  readonly entries: Readonly<{
-    readonly table: Readonly<Record<string, StorageTable>>;
-  }> = Object.freeze({ table: Object.freeze({}) });
+  readonly entries: SqlNamespaceEntries = Object.freeze({
+    table: blindCast<
+      Readonly<Record<string, StorageTable>>,
+      'empty frozen map is a valid Readonly<Record<string, StorageTable>>'
+    >(Object.freeze({})),
+  });
   declare readonly kind: string;
 
   private constructor() {
@@ -56,6 +61,13 @@ export class SqlUnboundNamespace extends NamespaceBase {
     freezeNode(this);
   }
 
+  get table(): Readonly<Record<string, StorageTable>> {
+    return blindCast<
+      Readonly<Record<string, StorageTable>>,
+      'entries[table] holds only StorageTable by construction'
+    >(this.entries['table']);
+  }
+
   qualifyTable(tableName: string): string {
     return `"${tableName}"`;
   }

package/src/ir/storage-entry-schemas.ts

@@ -0,0 +1,128 @@
+import { type Type, type } from 'arktype';
+import type { ForeignKeyInput, ReferentialAction } from './foreign-key';
+import type { ForeignKeyReferenceInput } from './foreign-key-reference';
+import type { PrimaryKeyInput } from './primary-key';
+import type { UniqueConstraintInput } from './unique-constraint';
+
+type ColumnDefaultLiteral = {
+  readonly kind: 'literal';
+  readonly value: string | number | boolean | Record<string, unknown> | unknown[] | null;
+};
+type ColumnDefaultFunction = { readonly kind: 'function'; readonly expression: string };
+
+const literalKindSchema = type("'literal'");
+const functionKindSchema = type("'function'");
+const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
+
+export const ColumnDefaultLiteralSchema = type.declare<ColumnDefaultLiteral>().type({
+  kind: literalKindSchema,
+  value: 'string | number | boolean | null | unknown[] | Record<string, unknown>',
+});
+
+export const ColumnDefaultFunctionSchema = type.declare<ColumnDefaultFunction>().type({
+  kind: functionKindSchema,
+  expression: 'string',
+});
+
+export const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
+
+const StorageValueSetRefSchema = type({
+  plane: "'storage'",
+  namespaceId: 'string',
+  entityKind: "'valueSet'",
+  entityName: 'string',
+  'spaceId?': 'string',
+});
+
+const StorageColumnSchema = type({
+  '+': 'reject',
+  nativeType: 'string',
+  codecId: 'string',
+  nullable: 'boolean',
+  'typeParams?': 'Record<string, unknown>',
+  'typeRef?': 'string',
+  'default?': ColumnDefaultSchema,
+  'control?': ControlPolicySchema,
+  'valueSet?': StorageValueSetRefSchema,
+}).narrow((col, ctx) => {
+  if (col.typeParams !== undefined && col.typeRef !== undefined) {
+    return ctx.mustBe('a column with either typeParams or typeRef, not both');
+  }
+  return true;
+});
+
+/**
+ * Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.
+ * Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an
+ * ordered `values` array of codec-encoded permitted values.
+ */
+export const StorageValueSetSchema = type({
+  kind: "'valueSet'",
+  values: type('string | number | boolean | null | unknown[] | Record<string, unknown>')
+    .array()
+    .readonly(),
+});
+
+const PrimaryKeySchema = type.declare<PrimaryKeyInput>().type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+});
+
+const UniqueConstraintSchema = type.declare<UniqueConstraintInput>().type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+});
+
+export const IndexSchema = type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+  'type?': 'string',
+  'options?': 'Record<string, unknown>',
+});
+
+export const ForeignKeyReferenceSchema = type({
+  '+': 'reject',
+  namespaceId: 'string',
+  tableName: 'string',
+  columns: type.string.array().readonly(),
+  'spaceId?': 'string',
+}) satisfies Type<ForeignKeyReferenceInput>;
+
+export const ForeignKeySourceSchema = type({
+  '+': 'reject',
+  namespaceId: 'string',
+  tableName: 'string',
+  columns: type.string.array().readonly(),
+}) satisfies Type<ForeignKeyReferenceInput>;
+
+export const ReferentialActionSchema = type
+  .declare<ReferentialAction>()
+  .type("'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'");
+
+export const ForeignKeySchema = type.declare<ForeignKeyInput>().type({
+  source: ForeignKeySourceSchema,
+  target: ForeignKeyReferenceSchema,
+  'name?': 'string',
+  'onDelete?': ReferentialActionSchema,
+  'onUpdate?': ReferentialActionSchema,
+  constraint: 'boolean',
+  index: 'boolean',
+});
+
+export const CheckConstraintSchema = type({
+  '+': 'reject',
+  name: 'string',
+  column: 'string',
+  valueSet: StorageValueSetRefSchema,
+});
+
+export const StorageTableSchema = type({
+  '+': 'reject',
+  columns: type({ '[string]': StorageColumnSchema }),
+  'primaryKey?': PrimaryKeySchema,
+  uniques: UniqueConstraintSchema.array().readonly(),
+  indexes: IndexSchema.array().readonly(),
+  foreignKeys: ForeignKeySchema.array().readonly(),
+  'control?': ControlPolicySchema,
+  'checks?': CheckConstraintSchema.array().readonly(),
+});

package/src/ir/storage-type-instance.ts

@@ -14,8 +14,8 @@ export const CODEC_INSTANCE_KIND = 'codec-instance' as const;
  * in `SqlStorage.types`. These are plain object literals — there is no
  * runtime IR class, the JSON envelope round-trips through the slot
  * unchanged. The `kind: 'codec-instance'` discriminator is the dispatch
- * key that distinguishes codec-typed entries from class-instance entries
- * (e.g. `PostgresEnumType`) sharing the polymorphic slot.
+ * key that distinguishes codec-typed entries from any class-instance
+ * kinds a target pack contributes to the polymorphic slot.
  */
 export interface StorageTypeInstance extends StorageType {
   readonly kind: typeof CODEC_INSTANCE_KIND;
@@ -54,7 +54,7 @@ export function toStorageTypeInstance(input: StorageTypeInstanceInput): StorageT
 /**
  * Type-guard for codec-typed entries on the polymorphic
  * `SqlStorage.types` slot. Distinguishes `StorageTypeInstance` from
- * class-instance kinds (e.g. `PostgresEnumType`).
+ * any class-instance kinds a target pack contributes.
  */
 export function isStorageTypeInstance(value: unknown): value is StorageTypeInstance {
   if (typeof value !== 'object' || value === null) return false;

package/src/ir/storage-value-set.ts

@@ -1,3 +1,4 @@
+import type { JsonValue } from '@prisma-next/contract/types';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from './sql-node';
 
@@ -7,9 +8,9 @@ import { SqlNode } from './sql-node';
  * walker can hand a validated literal straight to `new`.
  */
 export interface StorageValueSetInput {
-  readonly kind: 'value-set';
+  readonly kind: 'valueSet';
   /** Ordered permitted values, codec-encoded. Declaration order is preserved. */
-  readonly values: readonly string[];
+  readonly values: readonly JsonValue[];
 }
 
 /**
@@ -21,7 +22,7 @@ export interface StorageValueSetInput {
  * column that references it already holds the codec; the value-set holds
  * only the permitted values.
  *
- * The node's `kind` is enumerable (`'value-set'`) so the JSON envelope
+ * The node's `kind` is enumerable (`'valueSet'`) so the JSON envelope
  * carries the discriminator and the serializer hydration walker can
  * dispatch on it. This follows the per-leaf enumerable-kind convention
  * established in the SQL-node comment (future polymorphic dispatch on
@@ -31,8 +32,8 @@ export interface StorageValueSetInput {
  * the parent namespace's `valueSet: Record<string, StorageValueSet>` map.
  */
 export class StorageValueSet extends SqlNode {
-  override readonly kind = 'value-set' as const;
-  readonly values: readonly string[];
+  override readonly kind = 'valueSet' as const;
+  readonly values: readonly JsonValue[];
 
   constructor(input: StorageValueSetInput) {
     super();

package/src/resolve-storage-table.ts

@@ -1,4 +1,5 @@
-import type { SqlNamespace, SqlStorage } from './ir/sql-storage';
+import { entityAt } from '@prisma-next/framework-components/ir';
+import type { SqlStorage } from './ir/sql-storage';
 import type { StorageTable } from './ir/storage-table';
 
 export interface ResolvedStorageTable {
@@ -6,20 +7,6 @@ export interface ResolvedStorageTable {
   readonly table: StorageTable;
 }
 
-function tableInNamespace(
-  namespace: SqlNamespace | undefined,
-  tableName: string,
-): StorageTable | undefined {
-  if (namespace === undefined) {
-    return undefined;
-  }
-  const tables = namespace.entries.table;
-  if (!Object.hasOwn(tables, tableName)) {
-    return undefined;
-  }
-  return tables[tableName];
-}
-
 /**
  * Resolve a bare storage table name to its namespace coordinate and table IR.
  *
@@ -35,13 +22,21 @@ export function resolveStorageTable(
   namespaceId?: string,
 ): ResolvedStorageTable | undefined {
   if (namespaceId !== undefined) {
-    const table = tableInNamespace(storage.namespaces[namespaceId], tableName);
+    const table = entityAt<StorageTable>(storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: tableName,
+    });
     return table === undefined ? undefined : { namespaceId, table };
   }
 
   const matches: ResolvedStorageTable[] = [];
   for (const candidateNamespaceId of Object.keys(storage.namespaces)) {
-    const table = tableInNamespace(storage.namespaces[candidateNamespaceId], tableName);
+    const table = entityAt<StorageTable>(storage, {
+      namespaceId: candidateNamespaceId,
+      entityKind: 'table',
+      entityName: tableName,
+    });
     if (table !== undefined) {
       matches.push({ namespaceId: candidateNamespaceId, table });
     }

package/src/types.ts

@@ -21,20 +21,16 @@ export {
   ForeignKeyReference,
   type ForeignKeyReferenceInput,
 } from './ir/foreign-key-reference';
-export {
-  isPostgresEnumStorageEntry,
-  POSTGRES_ENUM_KIND,
-  type PostgresEnumStorageEntry,
-} from './ir/postgres-enum-storage-entry';
 export { PrimaryKey, type PrimaryKeyInput } from './ir/primary-key';
 export { Index, type IndexInput } from './ir/sql-index';
 export { SqlNode } from './ir/sql-node';
 export {
+  type SqlNamespace,
+  type SqlNamespaceEntries,
   type SqlNamespaceTablesInput,
   SqlStorage,
   type SqlStorageInput,
   type SqlStorageTypeEntry,
-  storageTableAt,
 } from './ir/sql-storage';
 export { SqlUnboundNamespace } from './ir/sql-unbound-namespace';
 export { StorageColumn, type StorageColumnInput } from './ir/storage-column';
@@ -83,11 +79,15 @@ export function applyFkDefaults(
   };
 }
 
+// Field-type maps nested by namespace coordinate: `[namespaceId][model][field]`.
+// Shared by the output and input field-type maps and their extractors.
+export type NamespacedFieldTypeMap = Record<string, Record<string, Record<string, unknown>>>;
+
 export type TypeMaps<
   TCodecTypes extends Record<string, { output: unknown }> = Record<string, never>,
   TQueryOperationTypes extends Record<string, unknown> = Record<string, never>,
-  TFieldOutputTypes extends Record<string, Record<string, unknown>> = Record<string, never>,
-  TFieldInputTypes extends Record<string, Record<string, unknown>> = Record<string, never>,
+  TFieldOutputTypes extends NamespacedFieldTypeMap = Record<string, never>,
+  TFieldInputTypes extends NamespacedFieldTypeMap = Record<string, never>,
 > = {
   readonly codecTypes: TCodecTypes;
   readonly queryOperationTypes: TQueryOperationTypes;
@@ -159,7 +159,7 @@ export type ExtractTypeMapsFromContract<T> = TypeMapsPhantomKey extends keyof T
 export type FieldOutputTypesOf<T> = [T] extends [never]
   ? Record<string, never>
   : T extends { readonly fieldOutputTypes: infer F }
-    ? F extends Record<string, Record<string, unknown>>
+    ? F extends NamespacedFieldTypeMap
       ? F
       : Record<string, never>
     : Record<string, never>;
@@ -167,7 +167,7 @@ export type FieldOutputTypesOf<T> = [T] extends [never]
 export type FieldInputTypesOf<T> = [T] extends [never]
   ? Record<string, never>
   : T extends { readonly fieldInputTypes: infer F }
-    ? F extends Record<string, Record<string, unknown>>
+    ? F extends NamespacedFieldTypeMap
       ? F
       : Record<string, never>
     : Record<string, never>;