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

package/dist/validators-DY_87pfS.mjs

@@ -0,0 +1,160 @@
+import { type } from "arktype";
+
+//#region src/validators.ts
+const literalKindSchema = type("'literal'");
+const functionKindSchema = type("'function'");
+const generatorKindSchema = type("'generator'");
+const generatorIdSchema = type("'ulid' | 'nanoid' | 'uuidv7' | 'uuidv4' | 'cuid2' | 'ksuid'");
+const ColumnDefaultLiteralSchema = type.declare().type({
+	kind: literalKindSchema,
+	expression: "string"
+});
+const ColumnDefaultFunctionSchema = type.declare().type({
+	kind: functionKindSchema,
+	expression: "string"
+});
+const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
+const ExecutionMutationDefaultValueSchema = type({
+	kind: generatorKindSchema,
+	id: generatorIdSchema,
+	"params?": "Record<string, unknown>"
+});
+const ExecutionSchema = type({ mutations: { defaults: type({
+	ref: {
+		table: "string",
+		column: "string"
+	},
+	"onCreate?": ExecutionMutationDefaultValueSchema,
+	"onUpdate?": ExecutionMutationDefaultValueSchema
+}).array().readonly() } });
+const StorageColumnSchema = type({
+	nativeType: "string",
+	codecId: "string",
+	nullable: "boolean",
+	"typeParams?": "Record<string, unknown>",
+	"typeRef?": "string",
+	"default?": ColumnDefaultSchema
+}).narrow((col, ctx) => {
+	if (col.typeParams !== void 0 && col.typeRef !== void 0) return ctx.mustBe("a column with either typeParams or typeRef, not both");
+	return true;
+});
+const StorageTypeInstanceSchema = type.declare().type({
+	codecId: "string",
+	nativeType: "string",
+	typeParams: "Record<string, unknown>"
+});
+const PrimaryKeySchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const UniqueConstraintSchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const IndexSchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const ForeignKeyReferencesSchema = type.declare().type({
+	table: "string",
+	columns: type.string.array().readonly()
+});
+const ForeignKeySchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	references: ForeignKeyReferencesSchema,
+	"name?": "string"
+});
+const StorageTableSchema = type.declare().type({
+	columns: type({ "[string]": StorageColumnSchema }),
+	"primaryKey?": PrimaryKeySchema,
+	uniques: UniqueConstraintSchema.array().readonly(),
+	indexes: IndexSchema.array().readonly(),
+	foreignKeys: ForeignKeySchema.array().readonly()
+});
+const StorageSchema = type.declare().type({
+	tables: type({ "[string]": StorageTableSchema }),
+	"types?": type({ "[string]": StorageTypeInstanceSchema })
+});
+const ModelFieldSchema = type.declare().type({ column: "string" });
+const ModelStorageSchema = type.declare().type({ table: "string" });
+const ModelSchema = type.declare().type({
+	storage: ModelStorageSchema,
+	fields: type({ "[string]": ModelFieldSchema }),
+	relations: type({ "[string]": "unknown" })
+});
+const SqlContractSchema = type({
+	"schemaVersion?": "'1'",
+	target: "string",
+	targetFamily: "'sql'",
+	storageHash: "string",
+	"executionHash?": "string",
+	"profileHash?": "string",
+	"capabilities?": "Record<string, Record<string, boolean>>",
+	"extensionPacks?": "Record<string, unknown>",
+	"meta?": "Record<string, unknown>",
+	"sources?": "Record<string, unknown>",
+	models: type({ "[string]": ModelSchema }),
+	storage: StorageSchema,
+	"execution?": ExecutionSchema
+});
+/**
+* Validates the structural shape of SqlStorage using Arktype.
+*
+* @param value - The storage value to validate
+* @returns The validated storage if structure is valid
+* @throws Error if the storage structure is invalid
+*/
+function validateStorage(value) {
+	const result = StorageSchema(value);
+	if (result instanceof type.errors) {
+		const messages = result.map((p) => p.message).join("; ");
+		throw new Error(`Storage validation failed: ${messages}`);
+	}
+	return result;
+}
+/**
+* Validates the structural shape of ModelDefinition using Arktype.
+*
+* @param value - The model value to validate
+* @returns The validated model if structure is valid
+* @throws Error if the model structure is invalid
+*/
+function validateModel(value) {
+	const result = ModelSchema(value);
+	if (result instanceof type.errors) {
+		const messages = result.map((p) => p.message).join("; ");
+		throw new Error(`Model validation failed: ${messages}`);
+	}
+	return result;
+}
+/**
+* Validates the structural shape of a SqlContract using Arktype.
+*
+* **Responsibility: Validation Only**
+* This function validates that the contract has the correct structure and types.
+* It does NOT normalize the contract - normalization must happen in the contract builder.
+*
+* The contract passed to this function must already be normalized (all required fields present).
+* If normalization is needed, it should be done by the contract builder before calling this function.
+*
+* This ensures all required fields are present and have the correct types.
+*
+* @param value - The contract value to validate (typically from a JSON import)
+* @returns The validated contract if structure is valid
+* @throws Error if the contract structure is invalid
+*/
+function validateSqlContract(value) {
+	if (typeof value !== "object" || value === null) throw new Error("Contract structural validation failed: value must be an object");
+	const rawValue = value;
+	if (rawValue.targetFamily !== void 0 && rawValue.targetFamily !== "sql") throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);
+	const contractResult = SqlContractSchema(value);
+	if (contractResult instanceof type.errors) {
+		const messages = contractResult.map((p) => p.message).join("; ");
+		throw new Error(`Contract structural validation failed: ${messages}`);
+	}
+	return contractResult;
+}
+
+//#endregion
+export { validateSqlContract as a, validateModel as i, ColumnDefaultLiteralSchema as n, validateStorage as o, ColumnDefaultSchema as r, ColumnDefaultFunctionSchema as t };
+//# sourceMappingURL=validators-DY_87pfS.mjs.map

package/dist/validators-DY_87pfS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators-DY_87pfS.mjs","names":[],"sources":["../src/validators.ts"],"sourcesContent":["import { type } from 'arktype';\nimport type {\n  ForeignKey,\n  ForeignKeyReferences,\n  Index,\n  ModelDefinition,\n  ModelField,\n  ModelStorage,\n  PrimaryKey,\n  SqlContract,\n  SqlStorage,\n  StorageTable,\n  StorageTypeInstance,\n  UniqueConstraint,\n} from './types';\n\ntype ColumnDefaultLiteral = { readonly kind: 'literal'; readonly expression: string };\ntype ColumnDefaultFunction = { readonly kind: 'function'; readonly expression: string };\nconst literalKindSchema = type(\"'literal'\");\nconst functionKindSchema = type(\"'function'\");\nconst generatorKindSchema = type(\"'generator'\");\nconst generatorIdSchema = type(\"'ulid' | 'nanoid' | 'uuidv7' | 'uuidv4' | 'cuid2' | 'ksuid'\");\n\nexport const ColumnDefaultLiteralSchema = type.declare<ColumnDefaultLiteral>().type({\n  kind: literalKindSchema,\n  expression: 'string',\n});\n\nexport const ColumnDefaultFunctionSchema = type.declare<ColumnDefaultFunction>().type({\n  kind: functionKindSchema,\n  expression: 'string',\n});\n\nexport const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);\n\nconst ExecutionMutationDefaultValueSchema = type({\n  kind: generatorKindSchema,\n  id: generatorIdSchema,\n  'params?': 'Record<string, unknown>',\n});\n\nconst ExecutionMutationDefaultSchema = type({\n  ref: {\n    table: 'string',\n    column: 'string',\n  },\n  'onCreate?': ExecutionMutationDefaultValueSchema,\n  'onUpdate?': ExecutionMutationDefaultValueSchema,\n});\n\nconst ExecutionSchema = type({\n  mutations: {\n    defaults: ExecutionMutationDefaultSchema.array().readonly(),\n  },\n});\n\nconst StorageColumnSchema = type({\n  nativeType: 'string',\n  codecId: 'string',\n  nullable: 'boolean',\n  'typeParams?': 'Record<string, unknown>',\n  'typeRef?': 'string',\n  'default?': ColumnDefaultSchema,\n}).narrow((col, ctx) => {\n  if (col.typeParams !== undefined && col.typeRef !== undefined) {\n    return ctx.mustBe('a column with either typeParams or typeRef, not both');\n  }\n  return true;\n});\n\nconst StorageTypeInstanceSchema = type.declare<StorageTypeInstance>().type({\n  codecId: 'string',\n  nativeType: 'string',\n  typeParams: 'Record<string, unknown>',\n});\n\nconst PrimaryKeySchema = type.declare<PrimaryKey>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst UniqueConstraintSchema = type.declare<UniqueConstraint>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst IndexSchema = type.declare<Index>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({\n  table: 'string',\n  columns: type.string.array().readonly(),\n});\n\nconst ForeignKeySchema = type.declare<ForeignKey>().type({\n  columns: type.string.array().readonly(),\n  references: ForeignKeyReferencesSchema,\n  'name?': 'string',\n});\n\nconst StorageTableSchema = type.declare<StorageTable>().type({\n  columns: type({ '[string]': StorageColumnSchema }),\n  'primaryKey?': PrimaryKeySchema,\n  uniques: UniqueConstraintSchema.array().readonly(),\n  indexes: IndexSchema.array().readonly(),\n  foreignKeys: ForeignKeySchema.array().readonly(),\n});\n\nconst StorageSchema = type.declare<SqlStorage>().type({\n  tables: type({ '[string]': StorageTableSchema }),\n  'types?': type({ '[string]': StorageTypeInstanceSchema }),\n});\n\nconst ModelFieldSchema = type.declare<ModelField>().type({\n  column: 'string',\n});\n\nconst ModelStorageSchema = type.declare<ModelStorage>().type({\n  table: 'string',\n});\n\nconst ModelSchema = type.declare<ModelDefinition>().type({\n  storage: ModelStorageSchema,\n  fields: type({ '[string]': ModelFieldSchema }),\n  relations: type({ '[string]': 'unknown' }),\n});\n\nconst SqlContractSchema = type({\n  'schemaVersion?': \"'1'\",\n  target: 'string',\n  targetFamily: \"'sql'\",\n  storageHash: 'string',\n  'executionHash?': 'string',\n  'profileHash?': 'string',\n  'capabilities?': 'Record<string, Record<string, boolean>>',\n  'extensionPacks?': 'Record<string, unknown>',\n  'meta?': 'Record<string, unknown>',\n  'sources?': 'Record<string, unknown>',\n  models: type({ '[string]': ModelSchema }),\n  storage: StorageSchema,\n  'execution?': ExecutionSchema,\n});\n\n/**\n * Validates the structural shape of SqlStorage using Arktype.\n *\n * @param value - The storage value to validate\n * @returns The validated storage if structure is valid\n * @throws Error if the storage structure is invalid\n */\nexport function validateStorage(value: unknown): SqlStorage {\n  const result = StorageSchema(value);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Storage validation failed: ${messages}`);\n  }\n  return result;\n}\n\n/**\n * Validates the structural shape of ModelDefinition using Arktype.\n *\n * @param value - The model value to validate\n * @returns The validated model if structure is valid\n * @throws Error if the model structure is invalid\n */\nexport function validateModel(value: unknown): ModelDefinition {\n  const result = ModelSchema(value);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Model validation failed: ${messages}`);\n  }\n  return result;\n}\n\n/**\n * Validates the structural shape of a SqlContract using Arktype.\n *\n * **Responsibility: Validation Only**\n * This function validates that the contract has the correct structure and types.\n * It does NOT normalize the contract - normalization must happen in the contract builder.\n *\n * The contract passed to this function must already be normalized (all required fields present).\n * If normalization is needed, it should be done by the contract builder before calling this function.\n *\n * This ensures all required fields are present and have the correct types.\n *\n * @param value - The contract value to validate (typically from a JSON import)\n * @returns The validated contract if structure is valid\n * @throws Error if the contract structure is invalid\n */\nexport function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T {\n  if (typeof value !== 'object' || value === null) {\n    throw new Error('Contract structural validation failed: value must be an object');\n  }\n\n  // Check targetFamily first to provide a clear error message for unsupported target families\n  const rawValue = value as { targetFamily?: string };\n  if (rawValue.targetFamily !== undefined && rawValue.targetFamily !== 'sql') {\n    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);\n  }\n\n  const contractResult = SqlContractSchema(value);\n\n  if (contractResult instanceof type.errors) {\n    const messages = contractResult.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Contract structural validation failed: ${messages}`);\n  }\n\n  // After validation, contractResult matches the schema and preserves the input structure\n  // TypeScript needs an assertion here due to exactOptionalPropertyTypes differences\n  // between Arktype's inferred type and the generic T, but runtime-wise they're compatible\n  return contractResult as T;\n}\n"],"mappings":"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"}

package/dist/{validators.d.ts → validators.d.mts}

@@ -1,4 +1,18 @@
-import type { ModelDefinition, SqlContract, SqlStorage } from './types';
+import { f as SqlStorage, o as ModelDefinition, u as SqlContract } from "./types-D3AOQgwo.mjs";
+import * as arktype_internal_variants_object_ts0 from "arktype/internal/variants/object.ts";
+
+//#region src/validators.d.ts
+type ColumnDefaultLiteral = {
+  readonly kind: 'literal';
+  readonly expression: string;
+};
+type ColumnDefaultFunction = {
+  readonly kind: 'function';
+  readonly expression: string;
+};
+declare const ColumnDefaultLiteralSchema: arktype_internal_variants_object_ts0.ObjectType<ColumnDefaultLiteral, {}>;
+declare const ColumnDefaultFunctionSchema: arktype_internal_variants_object_ts0.ObjectType<ColumnDefaultFunction, {}>;
+declare const ColumnDefaultSchema: arktype_internal_variants_object_ts0.ObjectType<ColumnDefaultLiteral | ColumnDefaultFunction, {}>;
 /**
  * Validates the structural shape of SqlStorage using Arktype.
  *
@@ -6,7 +20,7 @@ import type { ModelDefinition, SqlContract, SqlStorage } from './types';
  * @returns The validated storage if structure is valid
  * @throws Error if the storage structure is invalid
  */
-export declare function validateStorage(value: unknown): SqlStorage;
+declare function validateStorage(value: unknown): SqlStorage;
 /**
  * Validates the structural shape of ModelDefinition using Arktype.
  *
@@ -14,7 +28,7 @@ export declare function validateStorage(value: unknown): SqlStorage;
  * @returns The validated model if structure is valid
  * @throws Error if the model structure is invalid
  */
-export declare function validateModel(value: unknown): ModelDefinition;
+declare function validateModel(value: unknown): ModelDefinition;
 /**
  * Validates the structural shape of a SqlContract using Arktype.
  *
@@ -31,5 +45,7 @@ export declare function validateModel(value: unknown): ModelDefinition;
  * @returns The validated contract if structure is valid
  * @throws Error if the contract structure is invalid
  */
-export declare function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T;
-//# sourceMappingURL=validators.d.ts.map
+declare function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T;
+//#endregion
+export { ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, validateModel, validateSqlContract, validateStorage };
+//# sourceMappingURL=validators.d.mts.map

package/dist/validators.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../src/validators.ts"],"sourcesContent":[],"mappings":";;;;KAgBK,oBAAA;;;AAFY,CAAA;AAEQ,KACpB,qBAAA,GAAqB;EAMb,SAAA,IAAA,EAAA,UAAA;EAKA,SAAA,UAAA,EAAA,MAAA;AAKb,CAAA;AAAgC,cAVnB,0BAUmB,EAVO,oCAAA,CAAA,UAUP,CAVO,oBAUP,EAAA,CAAA,CAAA,CAAA;AAAA,cALnB,2BAKmB,EALQ,oCAAA,CAAA,UAKR,CALQ,qBAKR,EAAA,CAAA,CAAA,CAAA;AAAA,cAAnB,mBAAmB,EAAA,oCAAA,CAAA,UAAA,CAAA,oBAAA,GAAA,qBAAA,EAAA,CAAA,CAAA,CAAA;;AAuHhC;AAgBA;AAyBA;;;;AAAyF,iBAzCzE,eAAA,CAyCyE,KAAA,EAAA,OAAA,CAAA,EAzCxC,UAyCwC;;;;;;;;iBAzBzE,aAAA,kBAA+B;;;;;;;;;;;;;;;;;iBAyB/B,8BAA8B,YAAY,8BAA8B"}

package/dist/validators.mjs

@@ -0,0 +1,3 @@
+import { a as validateSqlContract, i as validateModel, n as ColumnDefaultLiteralSchema, o as validateStorage, r as ColumnDefaultSchema, t as ColumnDefaultFunctionSchema } from "./validators-DY_87pfS.mjs";
+
+export { ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, validateModel, validateSqlContract, validateStorage };

package/package.json

@@ -1,44 +1,41 @@
 {
   "name": "@prisma-next/sql-contract",
-  "version": "0.3.0-dev.34",
+  "version": "0.3.0-dev.35",
   "type": "module",
+  "plane": "shared",
   "sideEffects": false,
   "description": "SQL contract types, validators, and IR factories for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.25",
-    "@prisma-next/contract": "0.3.0-dev.34"
+    "@prisma-next/contract": "0.3.0-dev.35"
   },
   "devDependencies": {
-    "tsup": "8.5.1",
+    "tsdown": "0.18.4",
     "typescript": "5.9.3",
-    "vitest": "4.0.16",
+    "vitest": "4.0.17",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsconfig": "0.0.0"
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",
     "src"
   ],
   "exports": {
-    "./types": {
-      "types": "./dist/exports/types.d.ts",
-      "import": "./dist/exports/types.js"
-    },
-    "./validators": {
-      "types": "./dist/exports/validators.d.ts",
-      "import": "./dist/exports/validators.js"
-    },
-    "./factories": {
-      "types": "./dist/exports/factories.d.ts",
-      "import": "./dist/exports/factories.js"
-    },
-    "./pack-types": {
-      "types": "./dist/exports/pack-types.d.ts",
-      "import": "./dist/exports/pack-types.js"
-    }
+    "./factories": "./dist/factories.mjs",
+    "./pack-types": "./dist/pack-types.mjs",
+    "./types": "./dist/types.mjs",
+    "./validate": "./dist/validate.mjs",
+    "./validators": "./dist/validators.mjs",
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/2-sql/1-core/contract"
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
+    "build": "tsdown",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --noEmit",

package/src/exports/validate.ts

@@ -0,0 +1 @@
+export { validateContract } from '../validate';

package/src/exports/validators.ts

@@ -1 +1 @@
-export { validateModel, validateSqlContract, validateStorage } from '../validators';
+export * from '../validators';

package/src/factories.ts

@@ -1,3 +1,8 @@
+import type {
+  ExecutionHashBase,
+  ProfileHashBase,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
 import type {
   ForeignKey,
   ForeignKeyReferences,
@@ -100,26 +105,40 @@ export function storage(tables: Record<string, StorageTable>): SqlStorage {
   return { tables };
 }
 
-export function contract(opts: {
+export function contract<
+  TStorageHash extends StorageHashBase<string> = StorageHashBase<string>,
+  TExecutionHash extends ExecutionHashBase<string> = ExecutionHashBase<string>,
+  TProfileHash extends ProfileHashBase<string> = ProfileHashBase<string>,
+>(opts: {
   target: string;
-  coreHash: string;
+  storageHash: TStorageHash;
+  executionHash?: TExecutionHash;
   storage: SqlStorage;
   models?: Record<string, ModelDefinition>;
   relations?: Record<string, unknown>;
   mappings?: Partial<SqlMappings>;
   schemaVersion?: '1';
   targetFamily?: 'sql';
-  profileHash?: string;
+  profileHash?: TProfileHash;
   capabilities?: Record<string, Record<string, boolean>>;
   extensionPacks?: Record<string, unknown>;
   meta?: Record<string, unknown>;
   sources?: Record<string, unknown>;
-}): SqlContract {
+}): SqlContract<
+  SqlStorage,
+  Record<string, unknown>,
+  Record<string, unknown>,
+  SqlMappings,
+  TStorageHash,
+  TExecutionHash,
+  TProfileHash
+> {
   return {
     schemaVersion: opts.schemaVersion ?? '1',
     target: opts.target,
     targetFamily: opts.targetFamily ?? 'sql',
-    coreHash: opts.coreHash,
+    storageHash: opts.storageHash,
+    ...(opts.executionHash !== undefined && { executionHash: opts.executionHash }),
     storage: opts.storage,
     models: opts.models ?? {},
     relations: opts.relations ?? {},
@@ -129,5 +148,13 @@ export function contract(opts: {
     ...(opts.extensionPacks !== undefined && { extensionPacks: opts.extensionPacks }),
     ...(opts.meta !== undefined && { meta: opts.meta }),
     ...(opts.sources !== undefined && { sources: opts.sources as Record<string, unknown> }),
-  } as SqlContract;
+  } as SqlContract<
+    SqlStorage,
+    Record<string, unknown>,
+    Record<string, unknown>,
+    SqlMappings,
+    TStorageHash,
+    TExecutionHash,
+    TProfileHash
+  >;
 }

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './exports/factories';
 export * from './exports/types';
+export * from './exports/validate';
 export * from './exports/validators';

package/src/types.ts

@@ -1,4 +1,11 @@
-import type { ContractBase } from '@prisma-next/contract/types';
+import type {
+  ColumnDefault,
+  ContractBase,
+  ExecutionHashBase,
+  ExecutionSection,
+  ProfileHashBase,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
 
 /**
  * A column definition in storage.
@@ -22,6 +29,11 @@ export type StorageColumn = {
    * Mutually exclusive with `typeParams`.
    */
   readonly typeRef?: string;
+  /**
+   * Default value for the column.
+   * Can be a literal value or database function.
+   */
+  readonly default?: ColumnDefault;
 };
 
 export type PrimaryKey = {
@@ -111,12 +123,16 @@ export type SqlContract<
   M extends Record<string, unknown> = Record<string, unknown>,
   R extends Record<string, unknown> = Record<string, unknown>,
   Map extends SqlMappings = SqlMappings,
-> = ContractBase & {
+  TStorageHash extends StorageHashBase<string> = StorageHashBase<string>,
+  TExecutionHash extends ExecutionHashBase<string> = ExecutionHashBase<string>,
+  TProfileHash extends ProfileHashBase<string> = ProfileHashBase<string>,
+> = ContractBase<TStorageHash, TExecutionHash, TProfileHash> & {
   readonly targetFamily: string;
   readonly storage: S;
   readonly models: M;
   readonly relations: R;
   readonly mappings: Map;
+  readonly execution?: ExecutionSection;
 };
 
 export type ExtractCodecTypes<TContract extends SqlContract<SqlStorage>> =