@prisma-next/sql-contract-ts 0.3.0-dev.9 → 0.3.0-dev.90

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,41 +21,137 @@ 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 ContractWithTypeMaps,
+  type Index,
+  type ModelDefinition,
+  type ModelField,
+  type ReferentialAction,
+  type SqlContract,
+  type SqlMappings,
+  type SqlStorage,
+  type StorageTypeInstance,
+  type TypeMaps,
 } from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { computeMappings } from './contract';
 
-/**
- * Type-level mappings structure for contracts built via `defineContract()`.
- *
- * Compile-time type helper (not a runtime object) that ensures mappings match what the builder
- * 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.
- *
- * @template C - The `CodecTypes` generic parameter passed to `defineContract<CodecTypes>()`
- */
-type ContractBuilderMappings<C extends Record<string, { output: unknown }>> = Omit<
-  SqlMappings,
-  'codecTypes' | 'operationTypes'
-> & {
-  readonly codecTypes: C;
-  readonly operationTypes: Record<string, never>;
+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 ContractBuilderMappings = SqlMappings;
+
+type ExtractCodecTypesFromPack<P> = P extends { __codecTypes?: infer C }
+  ? C extends Record<string, { output: unknown }>
+    ? C
+    : Record<string, never>
+  : Record<string, never>;
+
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never;
+
+type MergeExtensionCodecTypes<Packs extends Record<string, unknown>> = UnionToIntersection<
+  {
+    [K in keyof Packs]: ExtractCodecTypesFromPack<Packs[K]>;
+  }[keyof Packs]
+>;
+
 type BuildStorageTable<
   _TableName extends string,
   Columns extends Record<string, ColumnBuilderState<string, boolean, string>>,
@@ -59,11 +166,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<Index>;
+  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 +190,7 @@ type BuildStorage<
       readonly string[] | undefined
     >
   >,
+  Types extends Record<string, StorageTypeInstance>,
 > = {
   readonly tables: {
     readonly [K in keyof Tables]: BuildStorageTable<
@@ -83,6 +199,7 @@ type BuildStorage<
       ExtractPrimaryKey<Tables[K]>
     >;
   };
+  readonly types: Types;
 };
 
 type BuildStorageTables<
@@ -108,6 +225,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 +286,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:
@@ -146,41 +320,46 @@ class SqlContractBuilder<
    * @returns A normalized SqlContract with all required fields present
    */
   build(): Target extends string
-    ? SqlContract<
-        BuildStorage<Tables>,
-        BuildModels<Models>,
-        BuildRelations<Models>,
-        ContractBuilderMappings<CodecTypes>
-      > & {
-        readonly schemaVersion: '1';
-        readonly target: Target;
-        readonly targetFamily: 'sql';
-        readonly coreHash: CoreHash extends string ? CoreHash : string;
-      } & (ExtensionPacks extends Record<string, unknown>
-          ? { readonly extensionPacks: ExtensionPacks }
-          : Record<string, never>) &
-        (Capabilities extends Record<string, Record<string, boolean>>
-          ? { readonly capabilities: Capabilities }
-          : Record<string, never>)
-    : never {
-    // Type helper to ensure literal types are preserved in return type
-    type BuiltContract = Target extends string
-      ? SqlContract<
-          BuildStorage<Tables>,
+    ? ContractWithTypeMaps<
+        SqlContract<
+          BuildStorage<Tables, Types>,
           BuildModels<Models>,
           BuildRelations<Models>,
-          ContractBuilderMappings<CodecTypes>
+          ContractBuilderMappings
         > & {
           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>) &
           (Capabilities extends Record<string, Record<string, boolean>>
             ? { readonly capabilities: Capabilities }
-            : Record<string, never>)
+            : Record<string, never>),
+        TypeMaps<CodecTypes, Record<string, never>>
+      >
+    : never {
+    type BuiltContract = Target extends string
+      ? ContractWithTypeMaps<
+          SqlContract<
+            BuildStorage<Tables, Types>,
+            BuildModels<Models>,
+            BuildRelations<Models>,
+            ContractBuilderMappings
+          > & {
+            readonly schemaVersion: '1';
+            readonly target: Target;
+            readonly targetFamily: 'sql';
+            readonly storageHash: StorageHash extends string ? StorageHash : string;
+          } & (ExtensionPacks extends Record<string, unknown>
+              ? { readonly extensionPacks: ExtensionPacks }
+              : Record<string, never>) &
+            (Capabilities extends Record<string, Record<string, boolean>>
+              ? { readonly capabilities: Capabilities }
+              : Record<string, never>),
+          TypeMaps<CodecTypes, Record<string, never>>
+        >
       : never;
     if (!this.state.target) {
       throw new Error('target is required. Call .target() before .build()');
@@ -189,6 +368,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 +390,58 @@ 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 } : {}),
+        ...(i.using ? { using: i.using } : {}),
+        ...(i.config ? { config: i.config } : {}),
+      }));
+
+      // 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 +449,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 +465,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>> = {};
@@ -327,11 +567,7 @@ class SqlContractBuilder<
       storage as SqlStorage,
     );
 
-    const mappings = {
-      ...baseMappings,
-      codecTypes: {} as CodecTypes,
-      operationTypes: {} as Record<string, never>,
-    } as ContractBuilderMappings<CodecTypes>;
+    const mappings = baseMappings as ContractBuilderMappings;
 
     const extensionNamespaces = this.state.extensionNamespaces ?? [];
     const extensionPacks: Record<string, unknown> = { ...(this.state.extensionPacks || {}) };
@@ -348,11 +584,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,38 +602,68 @@ class SqlContractBuilder<
         Target,
         Tables,
         Models,
-        CoreHash,
+        Types,
+        StorageHash,
         ExtensionPacks,
         Capabilities
       >['build']
     >;
   }
 
-  override target<T extends string>(
-    packRef: TargetPackRef<'sql', T>,
-  ): SqlContractBuilder<CodecTypes, T, Tables, Models, CoreHash, ExtensionPacks, Capabilities> {
+  override target<
+    T extends string,
+    TPack extends TargetPackRef<string, T> = TargetPackRef<string, T>,
+  >(
+    packRef: TPack & TargetPackRef<string, T>,
+  ): SqlContractBuilder<
+    ExtractCodecTypesFromPack<TPack> extends Record<string, never>
+      ? CodecTypes
+      : ExtractCodecTypesFromPack<TPack>,
+    T,
+    Tables,
+    Models,
+    Types,
+    StorageHash,
+    ExtensionPacks,
+    Capabilities
+  > {
     return new SqlContractBuilder<
-      CodecTypes,
+      ExtractCodecTypesFromPack<TPack> extends Record<string, never>
+        ? CodecTypes
+        : ExtractCodecTypesFromPack<TPack>,
       T,
       Tables,
       Models,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
       ...this.state,
       target: packRef.targetId,
-    });
+    }) as SqlContractBuilder<
+      ExtractCodecTypesFromPack<TPack> extends Record<string, never>
+        ? CodecTypes
+        : ExtractCodecTypesFromPack<TPack>,
+      T,
+      Tables,
+      Models,
+      Types,
+      StorageHash,
+      ExtensionPacks,
+      Capabilities
+    >;
   }
 
-  extensionPacks(
-    packs: Record<string, ExtensionPackRef<'sql', string>>,
+  extensionPacks<const Packs extends Record<string, ExtensionPackRef<'sql', string>>>(
+    packs: Packs,
   ): SqlContractBuilder<
-    CodecTypes,
+    CodecTypes & MergeExtensionCodecTypes<Packs>,
     Target,
     Tables,
     Models,
-    CoreHash,
+    Types,
+    StorageHash,
     ExtensionPacks,
     Capabilities
   > {
@@ -406,24 +673,24 @@ class SqlContractBuilder<
 
     const namespaces = new Set(this.state.extensionNamespaces ?? []);
 
-    for (const packRef of Object.values(packs)) {
+    for (const packRef of Object.values(packs) as ExtensionPackRef<'sql', string>[]) {
       if (!packRef) continue;
 
       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}".`,
         );
       }
 
@@ -431,11 +698,12 @@ class SqlContractBuilder<
     }
 
     return new SqlContractBuilder<
-      CodecTypes,
+      CodecTypes & MergeExtensionCodecTypes<Packs>,
       Target,
       Tables,
       Models,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
@@ -446,27 +714,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 +772,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 +792,8 @@ class SqlContractBuilder<
       Target,
       Tables & Record<TableName, ReturnType<T['build']>>,
       Models,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
@@ -522,14 +816,15 @@ class SqlContractBuilder<
     name: ModelName,
     table: TableName,
     callback: (
-      m: ModelBuilder<ModelName, TableName, Record<string, string>, Record<never, never>>,
+      m: ModelBuilder<ModelName, TableName, Record<never, never>, Record<never, never>>,
     ) => M | undefined,
   ): SqlContractBuilder<
     CodecTypes,
     Target,
     Tables,
     Models & Record<ModelName, ReturnType<M['build']>>,
-    CoreHash,
+    Types,
+    StorageHash,
     ExtensionPacks,
     Capabilities
   > {
@@ -543,7 +838,8 @@ class SqlContractBuilder<
       Target,
       Tables,
       Models & Record<ModelName, ReturnType<M['build']>>,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
@@ -552,6 +848,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<