@prisma-next/sql-contract-ts 0.3.0-dev.5 → 0.3.0-dev.50

package/src/contract-builder.ts

@@ -1,6 +1,17 @@
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/contract/framework-components';
+import type {
+  ColumnDefault,
+  ColumnDefaultLiteralInputValue,
+  ColumnDefaultLiteralValue,
+  ExecutionMutationDefault,
+  ExecutionMutationDefaultValue,
+  TaggedRaw,
+} from '@prisma-next/contract/types';
 import type {
   ColumnBuilderState,
+  ColumnTypeDescriptor,
+  ContractBuilderState,
+  ForeignKeyDefaultsState,
   ModelBuilderState,
   RelationDefinition,
   TableBuilderState,
@@ -10,21 +21,114 @@ import {
   type BuildRelations,
   type BuildStorageColumn,
   ContractBuilder,
+  createTable,
   type ExtractColumns,
   type ExtractPrimaryKey,
   ModelBuilder,
   type Mutable,
   TableBuilder,
 } from '@prisma-next/contract-authoring';
-import type {
-  ModelDefinition,
-  ModelField,
-  SqlContract,
-  SqlMappings,
-  SqlStorage,
+import {
+  applyFkDefaults,
+  type ModelDefinition,
+  type ModelField,
+  type ReferentialAction,
+  type SqlContract,
+  type SqlMappings,
+  type SqlStorage,
+  type StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { computeMappings } from './contract';
 
+type ColumnDefaultForCodec<
+  CodecTypes extends Record<string, { output: unknown }>,
+  CodecId extends string,
+> =
+  | {
+      readonly kind: 'literal';
+      readonly value: CodecId extends keyof CodecTypes ? CodecTypes[CodecId]['output'] : unknown;
+    }
+  | { readonly kind: 'function'; readonly expression: string };
+
+type SqlNullableColumnOptions<
+  Descriptor extends ColumnTypeDescriptor,
+  CodecTypes extends Record<string, { output: unknown }>,
+> = {
+  readonly type: Descriptor;
+  readonly nullable: true;
+  readonly typeParams?: Record<string, unknown>;
+  readonly default?: ColumnDefaultForCodec<CodecTypes, Descriptor['codecId']>;
+};
+
+type SqlNonNullableColumnOptions<
+  Descriptor extends ColumnTypeDescriptor,
+  CodecTypes extends Record<string, { output: unknown }>,
+> = {
+  readonly type: Descriptor;
+  readonly nullable?: false;
+  readonly typeParams?: Record<string, unknown>;
+  readonly default?: ColumnDefaultForCodec<CodecTypes, Descriptor['codecId']>;
+};
+
+type SqlGeneratedColumnOptions<
+  Descriptor extends ColumnTypeDescriptor,
+  CodecTypes extends Record<string, { output: unknown }>,
+> = Omit<SqlNonNullableColumnOptions<Descriptor, CodecTypes>, 'default' | 'nullable'> & {
+  readonly nullable?: false;
+  readonly generated: ExecutionMutationDefaultValue;
+};
+
+type SqlColumnOptions<
+  Descriptor extends ColumnTypeDescriptor,
+  CodecTypes extends Record<string, { output: unknown }>,
+> =
+  | SqlNullableColumnOptions<Descriptor, CodecTypes>
+  | SqlNonNullableColumnOptions<Descriptor, CodecTypes>;
+
+export interface SqlTableBuilder<
+  Name extends string,
+  CodecTypes extends Record<string, { output: unknown }>,
+  Columns extends Record<string, ColumnBuilderState<string, boolean, string>> = Record<
+    never,
+    ColumnBuilderState<string, boolean, string>
+  >,
+  PrimaryKey extends readonly string[] | undefined = undefined,
+> extends Omit<TableBuilder<Name, Columns, PrimaryKey>, 'column' | 'generated'> {
+  column<ColName extends string, Descriptor extends ColumnTypeDescriptor>(
+    name: ColName,
+    options: SqlNullableColumnOptions<Descriptor, CodecTypes>,
+  ): TableBuilder<
+    Name,
+    Columns & Record<ColName, ColumnBuilderState<ColName, true, Descriptor['codecId']>>,
+    PrimaryKey
+  >;
+  column<ColName extends string, Descriptor extends ColumnTypeDescriptor>(
+    name: ColName,
+    options: SqlNonNullableColumnOptions<Descriptor, CodecTypes>,
+  ): TableBuilder<
+    Name,
+    Columns & Record<ColName, ColumnBuilderState<ColName, false, Descriptor['codecId']>>,
+    PrimaryKey
+  >;
+  column<ColName extends string, Descriptor extends ColumnTypeDescriptor>(
+    name: ColName,
+    options: SqlColumnOptions<Descriptor, CodecTypes>,
+  ): TableBuilder<
+    Name,
+    Columns & Record<ColName, ColumnBuilderState<ColName, boolean, Descriptor['codecId']>>,
+    PrimaryKey
+  >;
+  generated<ColName extends string, Descriptor extends ColumnTypeDescriptor>(
+    name: ColName,
+    options: SqlGeneratedColumnOptions<Descriptor, CodecTypes>,
+  ): TableBuilder<
+    Name,
+    Columns & Record<ColName, ColumnBuilderState<ColName, false, Descriptor['codecId']>>,
+    PrimaryKey
+  >;
+}
+
 /**
  * Type-level mappings structure for contracts built via `defineContract()`.
  *
@@ -32,8 +136,8 @@ import { computeMappings } from './contract';
  * produces. `codecTypes` uses the generic `CodecTypes` parameter; `operationTypes` is always
  * empty since operations are added via extensions at runtime.
  *
- * **Difference from RuntimeContext**: This is a compile-time type for contract construction.
- * `RuntimeContext` is a runtime object with populated registries for query execution.
+ * **Difference from ExecutionContext**: This is a compile-time type for contract construction.
+ * `ExecutionContext` is a runtime object with populated registries for query execution.
  *
  * @template C - The `CodecTypes` generic parameter passed to `defineContract<CodecTypes>()`
  */
@@ -59,11 +163,19 @@ type BuildStorageTable<
       ? BuildStorageColumn<Null & boolean, TType>
       : never;
   };
-  readonly uniques: ReadonlyArray<never>;
-  readonly indexes: ReadonlyArray<never>;
-  readonly foreignKeys: ReadonlyArray<never>;
+  readonly uniques: ReadonlyArray<{ readonly columns: readonly string[]; readonly name?: string }>;
+  readonly indexes: ReadonlyArray<{ readonly columns: readonly string[]; readonly name?: string }>;
+  readonly foreignKeys: ReadonlyArray<{
+    readonly columns: readonly string[];
+    readonly references: { readonly table: string; readonly columns: readonly string[] };
+    readonly name?: string;
+    readonly onDelete?: ReferentialAction;
+    readonly onUpdate?: ReferentialAction;
+    readonly constraint: boolean;
+    readonly index: boolean;
+  }>;
 } & (PK extends readonly string[]
-  ? { readonly primaryKey: { readonly columns: PK } }
+  ? { readonly primaryKey: { readonly columns: PK; readonly name?: string } }
   : Record<string, never>);
 
 type BuildStorage<
@@ -75,6 +187,7 @@ type BuildStorage<
       readonly string[] | undefined
     >
   >,
+  Types extends Record<string, StorageTypeInstance>,
 > = {
   readonly tables: {
     readonly [K in keyof Tables]: BuildStorageTable<
@@ -83,6 +196,7 @@ type BuildStorage<
       ExtractPrimaryKey<Tables[K]>
     >;
   };
+  readonly types: Types;
 };
 
 type BuildStorageTables<
@@ -108,6 +222,52 @@ export interface ColumnBuilder<Name extends string, Nullable extends boolean, Ty
   build(): ColumnBuilderState<Name, Nullable, Type>;
 }
 
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (typeof value !== 'object' || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+function isJsonValue(value: unknown): value is ColumnDefaultLiteralValue {
+  if (value === null) return true;
+  const valueType = typeof value;
+  if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') return true;
+  if (Array.isArray(value)) {
+    return value.every((item) => isJsonValue(item));
+  }
+  if (isPlainObject(value)) {
+    return Object.values(value).every((item) => isJsonValue(item));
+  }
+  return false;
+}
+
+function encodeDefaultLiteralValue(
+  value: ColumnDefaultLiteralInputValue,
+): ColumnDefaultLiteralValue {
+  if (typeof value === 'bigint') {
+    return { $type: 'bigint', value: value.toString() };
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (isJsonValue(value)) {
+    if (isPlainObject(value) && '$type' in value) {
+      return { $type: 'raw', value } satisfies TaggedRaw;
+    }
+    return value;
+  }
+  throw new Error(
+    'Unsupported column default literal value: expected JSON-safe value, bigint, or Date.',
+  );
+}
+
+function encodeColumnDefault(defaultInput: ColumnDefault): ColumnDefault {
+  if (defaultInput.kind === 'function') {
+    return { kind: 'function', expression: defaultInput.expression };
+  }
+  return { kind: 'literal', value: encodeDefaultLiteralValue(defaultInput.value) };
+}
+
 class SqlContractBuilder<
   CodecTypes extends Record<string, { output: unknown }> = Record<string, never>,
   Target extends string | undefined = undefined,
@@ -123,10 +283,21 @@ class SqlContractBuilder<
     string,
     ModelBuilderState<string, string, Record<string, string>, Record<string, RelationDefinition>>
   > = Record<never, never>,
-  CoreHash extends string | undefined = undefined,
+  Types extends Record<string, StorageTypeInstance> = Record<never, never>,
+  StorageHash extends string | undefined = undefined,
   ExtensionPacks extends Record<string, unknown> | undefined = undefined,
   Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined,
-> extends ContractBuilder<Target, Tables, Models, CoreHash, ExtensionPacks, Capabilities> {
+> extends ContractBuilder<Target, Tables, Models, StorageHash, ExtensionPacks, Capabilities> {
+  protected declare readonly state: ContractBuilderState<
+    Target,
+    Tables,
+    Models,
+    StorageHash,
+    ExtensionPacks,
+    Capabilities
+  > & {
+    readonly storageTypes?: Types;
+  };
   /**
    * This method is responsible for normalizing the contract IR by setting default values
    * for all required fields:
@@ -147,7 +318,7 @@ class SqlContractBuilder<
    */
   build(): Target extends string
     ? SqlContract<
-        BuildStorage<Tables>,
+        BuildStorage<Tables, Types>,
         BuildModels<Models>,
         BuildRelations<Models>,
         ContractBuilderMappings<CodecTypes>
@@ -155,7 +326,7 @@ class SqlContractBuilder<
         readonly schemaVersion: '1';
         readonly target: Target;
         readonly targetFamily: 'sql';
-        readonly coreHash: CoreHash extends string ? CoreHash : string;
+        readonly storageHash: StorageHash extends string ? StorageHash : string;
       } & (ExtensionPacks extends Record<string, unknown>
           ? { readonly extensionPacks: ExtensionPacks }
           : Record<string, never>) &
@@ -166,7 +337,7 @@ class SqlContractBuilder<
     // Type helper to ensure literal types are preserved in return type
     type BuiltContract = Target extends string
       ? SqlContract<
-          BuildStorage<Tables>,
+          BuildStorage<Tables, Types>,
           BuildModels<Models>,
           BuildRelations<Models>,
           ContractBuilderMappings<CodecTypes>
@@ -174,7 +345,7 @@ class SqlContractBuilder<
           readonly schemaVersion: '1';
           readonly target: Target;
           readonly targetFamily: 'sql';
-          readonly coreHash: CoreHash extends string ? CoreHash : string;
+          readonly storageHash: StorageHash extends string ? StorageHash : string;
         } & (ExtensionPacks extends Record<string, unknown>
             ? { readonly extensionPacks: ExtensionPacks }
             : Record<string, never>) &
@@ -189,6 +360,7 @@ class SqlContractBuilder<
     const target = this.state.target as Target & string;
 
     const storageTables = {} as Partial<Mutable<BuildStorageTables<Tables>>>;
+    const executionDefaults: ExecutionMutationDefault[] = [];
 
     for (const tableName of Object.keys(this.state.tables) as Array<keyof Tables & string>) {
       const tableState = this.state.tables[tableName];
@@ -210,18 +382,56 @@ class SqlContractBuilder<
         if (!columnState) continue;
         const codecId = columnState.type;
         const nativeType = columnState.nativeType;
+        const typeRef = columnState.typeRef;
+
+        const encodedDefault =
+          columnState.default !== undefined
+            ? encodeColumnDefault(columnState.default as ColumnDefault)
+            : undefined;
 
         columns[columnName as keyof ColumnDefs] = {
           nativeType,
           codecId,
           nullable: (columnState.nullable ?? false) as ColumnDefs[keyof ColumnDefs]['nullable'] &
             boolean,
+          ...ifDefined('typeParams', columnState.typeParams),
+          ...ifDefined('default', encodedDefault),
+          ...ifDefined('typeRef', typeRef),
         } as BuildStorageColumn<
           ColumnDefs[keyof ColumnDefs]['nullable'] & boolean,
           ColumnDefs[keyof ColumnDefs]['type']
         >;
+
+        if ('executionDefault' in columnState && columnState.executionDefault) {
+          executionDefaults.push({
+            ref: { table: tableName, column: columnName },
+            onCreate: columnState.executionDefault,
+          });
+        }
       }
 
+      // Build uniques from table state
+      const uniques = (tableState.uniques ?? []).map((u) => ({
+        columns: u.columns,
+        ...(u.name ? { name: u.name } : {}),
+      }));
+
+      // Build indexes from table state
+      const indexes = (tableState.indexes ?? []).map((i) => ({
+        columns: i.columns,
+        ...(i.name ? { name: i.name } : {}),
+      }));
+
+      // Build foreign keys from table state, materializing defaults
+      const foreignKeys = (tableState.foreignKeys ?? []).map((fk) => ({
+        columns: fk.columns,
+        references: fk.references,
+        ...applyFkDefaults(fk, this.state.foreignKeyDefaults),
+        ...(fk.name ? { name: fk.name } : {}),
+        ...(fk.onDelete !== undefined ? { onDelete: fk.onDelete } : {}),
+        ...(fk.onUpdate !== undefined ? { onUpdate: fk.onUpdate } : {}),
+      }));
+
       const table = {
         columns: columns as {
           [K in keyof ColumnDefs]: BuildStorageColumn<
@@ -229,13 +439,14 @@ class SqlContractBuilder<
             ColumnDefs[K]['type']
           >;
         },
-        uniques: [],
-        indexes: [],
-        foreignKeys: [],
+        uniques,
+        indexes,
+        foreignKeys,
         ...(tableState.primaryKey
           ? {
               primaryKey: {
                 columns: tableState.primaryKey,
+                ...(tableState.primaryKeyName ? { name: tableState.primaryKeyName } : {}),
               },
             }
           : {}),
@@ -244,7 +455,26 @@ class SqlContractBuilder<
       (storageTables as Mutable<BuildStorageTables<Tables>>)[tableName] = table;
     }
 
-    const storage = { tables: storageTables as BuildStorageTables<Tables> } as BuildStorage<Tables>;
+    const storageTypes = (this.state.storageTypes ?? {}) as Types;
+    const storage: BuildStorage<Tables, Types> = {
+      tables: storageTables as BuildStorageTables<Tables>,
+      types: storageTypes,
+    };
+
+    const execution =
+      executionDefaults.length > 0
+        ? {
+            mutations: {
+              defaults: executionDefaults.sort((a, b) => {
+                const tableCompare = a.ref.table.localeCompare(b.ref.table);
+                if (tableCompare !== 0) {
+                  return tableCompare;
+                }
+                return a.ref.column.localeCompare(b.ref.column);
+              }),
+            },
+          }
+        : undefined;
 
     // Build models - construct as partial first, then assert full type
     const modelsPartial: Partial<BuildModels<Models>> = {};
@@ -348,11 +578,12 @@ class SqlContractBuilder<
       schemaVersion: '1' as const,
       target,
       targetFamily: 'sql' as const,
-      coreHash: this.state.coreHash || 'sha256:ts-builder-placeholder',
+      storageHash: this.state.storageHash || 'sha256:ts-builder-placeholder',
       models,
       relations: relationsPartial,
       storage,
       mappings,
+      ...(execution ? { execution } : {}),
       extensionPacks,
       capabilities: this.state.capabilities || {},
       meta: {},
@@ -365,7 +596,8 @@ class SqlContractBuilder<
         Target,
         Tables,
         Models,
-        CoreHash,
+        Types,
+        StorageHash,
         ExtensionPacks,
         Capabilities
       >['build']
@@ -374,13 +606,23 @@ class SqlContractBuilder<
 
   override target<T extends string>(
     packRef: TargetPackRef<'sql', T>,
-  ): SqlContractBuilder<CodecTypes, T, Tables, Models, CoreHash, ExtensionPacks, Capabilities> {
+  ): SqlContractBuilder<
+    CodecTypes,
+    T,
+    Tables,
+    Models,
+    Types,
+    StorageHash,
+    ExtensionPacks,
+    Capabilities
+  > {
     return new SqlContractBuilder<
       CodecTypes,
       T,
       Tables,
       Models,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
@@ -396,7 +638,8 @@ class SqlContractBuilder<
     Target,
     Tables,
     Models,
-    CoreHash,
+    Types,
+    StorageHash,
     ExtensionPacks,
     Capabilities
   > {
@@ -411,19 +654,19 @@ class SqlContractBuilder<
 
       if (packRef.kind !== 'extension') {
         throw new Error(
-          `extensionPacks() only accepts extension pack refs. Received kind \"${packRef.kind}\".`,
+          `extensionPacks() only accepts extension pack refs. Received kind "${packRef.kind}".`,
         );
       }
 
       if (packRef.familyId !== 'sql') {
         throw new Error(
-          `extension pack \"${packRef.id}\" targets family \"${packRef.familyId}\" but this builder targets \"sql\".`,
+          `extension pack "${packRef.id}" targets family "${packRef.familyId}" but this builder targets "sql".`,
         );
       }
 
       if (packRef.targetId && packRef.targetId !== this.state.target) {
         throw new Error(
-          `extension pack \"${packRef.id}\" targets \"${packRef.targetId}\" but builder target is \"${this.state.target}\".`,
+          `extension pack "${packRef.id}" targets "${packRef.targetId}" but builder target is "${this.state.target}".`,
         );
       }
 
@@ -435,7 +678,8 @@ class SqlContractBuilder<
       Target,
       Tables,
       Models,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
@@ -446,27 +690,46 @@ class SqlContractBuilder<
 
   override capabilities<C extends Record<string, Record<string, boolean>>>(
     capabilities: C,
-  ): SqlContractBuilder<CodecTypes, Target, Tables, Models, CoreHash, ExtensionPacks, C> {
-    return new SqlContractBuilder<CodecTypes, Target, Tables, Models, CoreHash, ExtensionPacks, C>({
+  ): SqlContractBuilder<CodecTypes, Target, Tables, Models, Types, StorageHash, ExtensionPacks, C> {
+    return new SqlContractBuilder<
+      CodecTypes,
+      Target,
+      Tables,
+      Models,
+      Types,
+      StorageHash,
+      ExtensionPacks,
+      C
+    >({
       ...this.state,
       capabilities,
     });
   }
 
-  override coreHash<H extends string>(
+  override storageHash<H extends string>(
     hash: H,
-  ): SqlContractBuilder<CodecTypes, Target, Tables, Models, H, ExtensionPacks, Capabilities> {
+  ): SqlContractBuilder<
+    CodecTypes,
+    Target,
+    Tables,
+    Models,
+    Types,
+    H,
+    ExtensionPacks,
+    Capabilities
+  > {
     return new SqlContractBuilder<
       CodecTypes,
       Target,
       Tables,
       Models,
+      Types,
       H,
       ExtensionPacks,
       Capabilities
     >({
       ...this.state,
-      coreHash: hash,
+      storageHash: hash,
     });
   }
 
@@ -485,12 +748,18 @@ class SqlContractBuilder<
     Target,
     Tables & Record<TableName, ReturnType<T['build']>>,
     Models,
-    CoreHash,
+    Types,
+    StorageHash,
     ExtensionPacks,
     Capabilities
   > {
-    const tableBuilder = new TableBuilder<TableName>(name);
-    const result = callback(tableBuilder);
+    const tableBuilder = createTable(name);
+    const result = callback(
+      tableBuilder as unknown as SqlTableBuilder<
+        TableName,
+        CodecTypes
+      > as unknown as TableBuilder<TableName>,
+    );
     const finalBuilder = result instanceof TableBuilder ? result : tableBuilder;
     const tableState = finalBuilder.build();
 
@@ -499,7 +768,8 @@ class SqlContractBuilder<
       Target,
       Tables & Record<TableName, ReturnType<T['build']>>,
       Models,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
@@ -529,7 +799,8 @@ class SqlContractBuilder<
     Target,
     Tables,
     Models & Record<ModelName, ReturnType<M['build']>>,
-    CoreHash,
+    Types,
+    StorageHash,
     ExtensionPacks,
     Capabilities
   > {
@@ -543,7 +814,8 @@ class SqlContractBuilder<
       Target,
       Tables,
       Models & Record<ModelName, ReturnType<M['build']>>,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
@@ -552,6 +824,64 @@ class SqlContractBuilder<
         Record<ModelName, ReturnType<M['build']>>,
     });
   }
+
+  override foreignKeyDefaults(
+    config: ForeignKeyDefaultsState,
+  ): SqlContractBuilder<
+    CodecTypes,
+    Target,
+    Tables,
+    Models,
+    Types,
+    StorageHash,
+    ExtensionPacks,
+    Capabilities
+  > {
+    return new SqlContractBuilder<
+      CodecTypes,
+      Target,
+      Tables,
+      Models,
+      Types,
+      StorageHash,
+      ExtensionPacks,
+      Capabilities
+    >({
+      ...this.state,
+      foreignKeyDefaults: config,
+    });
+  }
+
+  storageType<Name extends string, Type extends StorageTypeInstance>(
+    name: Name,
+    typeInstance: Type,
+  ): SqlContractBuilder<
+    CodecTypes,
+    Target,
+    Tables,
+    Models,
+    Types & Record<Name, Type>,
+    StorageHash,
+    ExtensionPacks,
+    Capabilities
+  > {
+    return new SqlContractBuilder<
+      CodecTypes,
+      Target,
+      Tables,
+      Models,
+      Types & Record<Name, Type>,
+      StorageHash,
+      ExtensionPacks,
+      Capabilities
+    >({
+      ...this.state,
+      storageTypes: {
+        ...(this.state.storageTypes ?? {}),
+        [name]: typeInstance,
+      },
+    });
+  }
 }
 
 export function defineContract<