@prisma-next/sql-contract-ts 0.3.0-dev.34 → 0.3.0-dev.36

package/src/contract-builder.ts

@@ -1,6 +1,8 @@
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/contract/framework-components';
+import type { ExecutionMutationDefault } from '@prisma-next/contract/types';
 import type {
   ColumnBuilderState,
+  ContractBuilderState,
   ModelBuilderState,
   RelationDefinition,
   TableBuilderState,
@@ -23,7 +25,9 @@ import type {
   SqlContract,
   SqlMappings,
   SqlStorage,
+  StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { computeMappings } from './contract';
 
 /**
@@ -33,8 +37,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>()`
  */
@@ -80,6 +84,7 @@ type BuildStorage<
       readonly string[] | undefined
     >
   >,
+  Types extends Record<string, StorageTypeInstance>,
 > = {
   readonly tables: {
     readonly [K in keyof Tables]: BuildStorageTable<
@@ -88,6 +93,7 @@ type BuildStorage<
       ExtractPrimaryKey<Tables[K]>
     >;
   };
+  readonly types: Types;
 };
 
 type BuildStorageTables<
@@ -128,10 +134,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:
@@ -152,7 +169,7 @@ class SqlContractBuilder<
    */
   build(): Target extends string
     ? SqlContract<
-        BuildStorage<Tables>,
+        BuildStorage<Tables, Types>,
         BuildModels<Models>,
         BuildRelations<Models>,
         ContractBuilderMappings<CodecTypes>
@@ -160,7 +177,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>) &
@@ -171,7 +188,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>
@@ -179,7 +196,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>) &
@@ -194,6 +211,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];
@@ -215,17 +233,27 @@ class SqlContractBuilder<
         if (!columnState) continue;
         const codecId = columnState.type;
         const nativeType = columnState.nativeType;
+        const typeRef = columnState.typeRef;
 
         columns[columnName as keyof ColumnDefs] = {
           nativeType,
           codecId,
           nullable: (columnState.nullable ?? false) as ColumnDefs[keyof ColumnDefs]['nullable'] &
             boolean,
-          ...(columnState.typeParams ? { typeParams: columnState.typeParams } : {}),
+          ...ifDefined('typeParams', columnState.typeParams),
+          ...ifDefined('default', columnState.default),
+          ...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
@@ -270,7 +298,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>> = {};
@@ -374,11 +421,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: {},
@@ -391,7 +439,8 @@ class SqlContractBuilder<
         Target,
         Tables,
         Models,
-        CoreHash,
+        Types,
+        StorageHash,
         ExtensionPacks,
         Capabilities
       >['build']
@@ -400,13 +449,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
     >({
@@ -422,7 +481,8 @@ class SqlContractBuilder<
     Target,
     Tables,
     Models,
-    CoreHash,
+    Types,
+    StorageHash,
     ExtensionPacks,
     Capabilities
   > {
@@ -461,7 +521,8 @@ class SqlContractBuilder<
       Target,
       Tables,
       Models,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
@@ -472,27 +533,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,
     });
   }
 
@@ -511,7 +591,8 @@ class SqlContractBuilder<
     Target,
     Tables & Record<TableName, ReturnType<T['build']>>,
     Models,
-    CoreHash,
+    Types,
+    StorageHash,
     ExtensionPacks,
     Capabilities
   > {
@@ -525,7 +606,8 @@ class SqlContractBuilder<
       Target,
       Tables & Record<TableName, ReturnType<T['build']>>,
       Models,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
@@ -555,7 +637,8 @@ class SqlContractBuilder<
     Target,
     Tables,
     Models & Record<ModelName, ReturnType<M['build']>>,
-    CoreHash,
+    Types,
+    StorageHash,
     ExtensionPacks,
     Capabilities
   > {
@@ -569,7 +652,8 @@ class SqlContractBuilder<
       Target,
       Tables,
       Models & Record<ModelName, ReturnType<M['build']>>,
-      CoreHash,
+      Types,
+      StorageHash,
       ExtensionPacks,
       Capabilities
     >({
@@ -578,6 +662,37 @@ class SqlContractBuilder<
         Record<ModelName, ReturnType<M['build']>>,
     });
   }
+
+  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<

package/src/contract.ts

@@ -14,6 +14,7 @@ import type {
   StorageTypeInstance,
   UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
+import { ColumnDefaultSchema } from '@prisma-next/sql-contract/validators';
 import { type } from 'arktype';
 import type { O } from 'ts-toolbelt';
 
@@ -21,12 +22,14 @@ import type { O } from 'ts-toolbelt';
  * Structural validation schema for SqlContract using Arktype.
  * This validates the shape and types of the contract structure.
  */
+
 const StorageColumnSchema = type.declare<StorageColumn>().type({
   nativeType: 'string',
   codecId: 'string',
   nullable: 'boolean',
   'typeParams?': 'Record<string, unknown>',
   'typeRef?': 'string',
+  'default?': ColumnDefaultSchema,
 });
 
 const StorageTypeInstanceSchema = type.declare<StorageTypeInstance>().type({
@@ -88,6 +91,27 @@ const ModelSchema = type.declare<ModelDefinition>().type({
   relations: type({ '[string]': 'unknown' }),
 });
 
+const ExecutionMutationDefaultValueSchema = type({
+  kind: "'generator'",
+  id: "'ulid' | 'nanoid' | 'uuidv7' | 'uuidv4' | 'cuid2' | 'ksuid'",
+  'params?': 'Record<string, unknown>',
+});
+
+const ExecutionMutationDefaultSchema = type({
+  ref: {
+    table: 'string',
+    column: 'string',
+  },
+  'onCreate?': ExecutionMutationDefaultValueSchema,
+  'onUpdate?': ExecutionMutationDefaultValueSchema,
+});
+
+const ExecutionSchema = type({
+  mutations: {
+    defaults: ExecutionMutationDefaultSchema.array().readonly(),
+  },
+});
+
 /**
  * Complete SqlContract schema for structural validation.
  * This validates the entire contract structure at once.
@@ -96,7 +120,8 @@ const SqlContractSchema = type({
   'schemaVersion?': "'1'",
   target: 'string',
   targetFamily: "'sql'",
-  coreHash: 'string',
+  storageHash: 'string',
+  'executionHash?': 'string',
   'profileHash?': 'string',
   'capabilities?': 'Record<string, Record<string, boolean>>',
   'extensionPacks?': 'Record<string, unknown>',
@@ -104,6 +129,7 @@ const SqlContractSchema = type({
   'sources?': 'Record<string, unknown>',
   models: type({ '[string]': ModelSchema }),
   storage: StorageSchema,
+  'execution?': ExecutionSchema,
 });
 
 /**
@@ -198,13 +224,15 @@ export function computeMappings(
  * This checks that references (e.g., foreign keys, primary keys, uniques) point to storage objects that already exist.
  * Structural validation is expected to have already completed before this helper runs.
  *
+ * Rule: keep this focused on structural consistency only; capability/feature
+ * gating (e.g., defaults.*) belongs in migration/runtime verification, not here.
+ *
  * @param structurallyValidatedContract - The contract whose structure has already been validated
  * @throws Error if logical validation fails
  */
 function validateContractLogic(structurallyValidatedContract: SqlContract<SqlStorage>): void {
   const { storage, models } = structurallyValidatedContract;
   const tableNames = new Set(Object.keys(storage.tables));
-  const typeInstanceNames = new Set(Object.keys(storage.types ?? {}));
 
   // Validate storage.types if present
   if (storage.types) {
@@ -235,11 +263,26 @@ function validateContractLogic(structurallyValidatedContract: SqlContract<SqlSto
         );
       }
 
-      // Validate typeRef points to an existing storage.types key
-      if (column.typeRef !== undefined && !typeInstanceNames.has(column.typeRef)) {
-        throw new Error(
-          `Column "${columnName}" in table "${tableName}" references non-existent type instance "${column.typeRef}" (not found in storage.types)`,
-        );
+      // Validate typeRef points to an existing storage.types key and matches codecId/nativeType
+      if (column.typeRef !== undefined) {
+        const referencedType = storage.types?.[column.typeRef];
+        if (!referencedType) {
+          throw new Error(
+            `Column "${columnName}" in table "${tableName}" references non-existent type instance "${column.typeRef}" (not found in storage.types)`,
+          );
+        }
+
+        if (column.codecId !== referencedType.codecId) {
+          throw new Error(
+            `Column "${columnName}" in table "${tableName}" has codecId "${column.codecId}" but references type instance "${column.typeRef}" with codecId "${referencedType.codecId}"`,
+          );
+        }
+
+        if (column.nativeType !== referencedType.nativeType) {
+          throw new Error(
+            `Column "${columnName}" in table "${tableName}" has nativeType "${column.nativeType}" but references type instance "${column.typeRef}" with nativeType "${referencedType.nativeType}"`,
+          );
+        }
       }
     }
   }