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

package/README.md

@@ -16,15 +16,15 @@ This package contains the SQL-specific TypeScript contract authoring surface for
 
 This package is part of the SQL family namespace (`packages/2-sql/2-authoring/contract-ts`) and provides:
 - SQL contract builder (`defineContract`) - TypeScript builder for creating SQL contracts programmatically
-- SQL contract validation (`validateContract`) - Structural and logical validation for SQL contracts
 - SQL contract JSON schema - JSON schema for validating contract structure
 
 ## Responsibilities
 
 - **SQL Contract Builder**: Provides the `defineContract()` builder API for creating SQL contracts programmatically with type safety, including pack-ref based `.target()` and `.extensionPacks()` helpers
-- **SQL Contract Validation**: Implements SQL-specific contract validation (`validateContractStructure`, `validateContractLogic`, `validateContract`) and normalization
+- **Storage Type Authoring**: Supports `storage.types` declarations and `typeRef` columns via the SQL builder
 - **SQL Contract JSON Schema**: Provides JSON schema for validating contract structure in IDEs and tooling
 - **Composition Layer**: Composes the target-agnostic builder core from `@prisma-next/contract-authoring` with SQL-specific types and validation logic
+- **Generated Defaults**: Supports client-generated defaults via `ColumnDefault.kind = 'generated'` in contract authoring
 
 ## Package Status
 
@@ -34,7 +34,6 @@ This package was created in Phase 1 and refactored in Phase 2. It now composes t
 
 - **Composes generic core**: Uses `@prisma-next/contract-authoring` for generic builder state management (`TableBuilder`, `ModelBuilder`, `ContractBuilder` base class)
 - **SQL-specific types**: Provides SQL-specific contract types (`SqlContract`, `SqlStorage`, `SqlMappings`) from `@prisma-next/sql-contract/types`
-- **SQL-specific validation**: Implements SQL-specific contract validation (`validateContractStructure`, `validateContractLogic`, `validateContract`) and normalization (`normalizeContract`)
 - **SQL-specific build()**: Implements SQL-specific `build()` method in `SqlContractBuilder` that constructs `SqlContract` instances with SQL-specific structure (uniques, indexes, foreignKeys arrays)
 
 This package is part of the package layering architecture:
@@ -44,7 +43,6 @@ This package is part of the package layering architecture:
 ## Exports
 
 - `./contract-builder` - Contract builder API (`defineContract`, `ColumnBuilder`)
-- `./contract` - Contract validation (`validateContract`, `computeMappings`)
 - `./schema-sql` - SQL contract JSON schema (`data-contract-sql-v1.json`)
 
 ## Usage
@@ -56,15 +54,17 @@ import { defineContract } from '@prisma-next/sql-contract-ts/contract-builder';
 import type { CodecTypes } from '@prisma-next/adapter-postgres/codec-types';
 import postgresPack from '@prisma-next/target-postgres/pack';
 import pgvector from '@prisma-next/extension-pgvector/pack';
-import { int4Column, textColumn } from '@prisma-next/adapter-postgres/column-types';
+import { enumColumn, enumType, int4Column, textColumn } from '@prisma-next/adapter-postgres/column-types';
 
 const contract = defineContract<CodecTypes>()
   .target(postgresPack)
   .extensionPacks({ pgvector })
+  .storageType('Role', enumType('role', ['USER', 'ADMIN']))
   .table('user', (t) =>
     t
       .column('id', { type: int4Column, nullable: false })
       .column('email', { type: textColumn, nullable: false })
+      .column('role', { type: enumColumn('Role', 'role') })
       .primaryKey(['id'], 'user_pkey')           // Named primary key
       .unique(['email'], 'user_email_unique')    // Named unique constraint
       .index(['email'], 'user_email_idx'),       // Named index
@@ -95,16 +95,13 @@ The table builder supports the following constraint methods:
 
 ### Validating Contracts
 
+Contract JSON validation now lives in `@prisma-next/sql-contract/validate` (shared plane), while this package focuses on authoring/building contracts.
+
 ```typescript
-import { validateContract } from '@prisma-next/sql-contract-ts/contract';
-import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import { validateContract } from '@prisma-next/sql-contract/validate';
 import type { Contract } from './contract.d';
 
-// From JSON import
 const contract = validateContract<Contract>(contractJson);
-
-// Or with generic type (less type-safe)
-const contract = validateContract<SqlContract<SqlStorage>>(contractJson);
 ```
 
 ## Dependencies

package/dist/contract-builder.d.mts

@@ -0,0 +1,105 @@
+import { BuildModels, BuildRelations, BuildStorageColumn, ColumnBuilderState, ContractBuilder, ContractBuilderState, ExtractColumns, ExtractPrimaryKey, ModelBuilder, ModelBuilderState, RelationDefinition, TableBuilder, TableBuilderState } from "@prisma-next/contract-authoring";
+import { ExtensionPackRef, TargetPackRef } from "@prisma-next/contract/framework-components";
+import { SqlContract, SqlMappings, StorageTypeInstance } from "@prisma-next/sql-contract/types";
+
+//#region src/contract-builder.d.ts
+
+/**
+ * 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 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>()`
+ */
+type ContractBuilderMappings<C extends Record<string, {
+  output: unknown;
+}>> = Omit<SqlMappings, 'codecTypes' | 'operationTypes'> & {
+  readonly codecTypes: C;
+  readonly operationTypes: Record<string, never>;
+};
+type BuildStorageTable<_TableName extends string, Columns extends Record<string, ColumnBuilderState<string, boolean, string>>, PK extends readonly string[] | undefined> = {
+  readonly columns: { readonly [K in keyof Columns]: Columns[K] extends ColumnBuilderState<string, infer Null, infer TType> ? BuildStorageColumn<Null & boolean, TType> : 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;
+  }>;
+} & (PK extends readonly string[] ? {
+  readonly primaryKey: {
+    readonly columns: PK;
+    readonly name?: string;
+  };
+} : Record<string, never>);
+type BuildStorage<Tables extends Record<string, TableBuilderState<string, Record<string, ColumnBuilderState<string, boolean, string>>, readonly string[] | undefined>>, Types extends Record<string, StorageTypeInstance>> = {
+  readonly tables: { readonly [K in keyof Tables]: BuildStorageTable<K & string, ExtractColumns<Tables[K]>, ExtractPrimaryKey<Tables[K]>> };
+  readonly types: Types;
+};
+interface ColumnBuilder<Name extends string, Nullable extends boolean, Type extends string> {
+  nullable<Value extends boolean>(value?: Value): ColumnBuilder<Name, Value, Type>;
+  type<Id extends string>(id: Id): ColumnBuilder<Name, Nullable, Id>;
+  build(): ColumnBuilderState<Name, Nullable, Type>;
+}
+declare class SqlContractBuilder<CodecTypes extends Record<string, {
+  output: unknown;
+}> = Record<string, never>, Target extends string | undefined = undefined, Tables extends Record<string, TableBuilderState<string, Record<string, ColumnBuilderState<string, boolean, string>>, readonly string[] | undefined>> = Record<never, never>, Models extends Record<string, ModelBuilderState<string, string, Record<string, string>, Record<string, RelationDefinition>>> = Record<never, never>, 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, StorageHash, ExtensionPacks, Capabilities> {
+  protected 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:
+   * - `nullable`: defaults to `false` if not provided
+   * - `uniques`: defaults to `[]` (empty array)
+   * - `indexes`: defaults to `[]` (empty array)
+   * - `foreignKeys`: defaults to `[]` (empty array)
+   * - `relations`: defaults to `{}` (empty object) for both model-level and contract-level
+   * - `nativeType`: required field set from column type descriptor when columns are defined
+   *
+   * The contract builder is the **only** place where normalization should occur.
+   * Validators, parsers, and emitters should assume the contract is already normalized.
+   *
+   * **Required**: Use column type descriptors (e.g., `int4Column`, `textColumn`) when defining columns.
+   * This ensures `nativeType` is set correctly at build time.
+   *
+   * @returns A normalized SqlContract with all required fields present
+   */
+  build(): Target extends string ? SqlContract<BuildStorage<Tables, Types>, BuildModels<Models>, BuildRelations<Models>, ContractBuilderMappings<CodecTypes>> & {
+    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>) : never;
+  target<T extends string>(packRef: TargetPackRef<'sql', T>): SqlContractBuilder<CodecTypes, T, Tables, Models, Types, StorageHash, ExtensionPacks, Capabilities>;
+  extensionPacks(packs: Record<string, ExtensionPackRef<'sql', string>>): SqlContractBuilder<CodecTypes, Target, Tables, Models, Types, StorageHash, ExtensionPacks, Capabilities>;
+  capabilities<C extends Record<string, Record<string, boolean>>>(capabilities: C): SqlContractBuilder<CodecTypes, Target, Tables, Models, Types, StorageHash, ExtensionPacks, C>;
+  storageHash<H extends string>(hash: H): SqlContractBuilder<CodecTypes, Target, Tables, Models, Types, H, ExtensionPacks, Capabilities>;
+  table<TableName extends string, T extends TableBuilder<TableName, Record<string, ColumnBuilderState<string, boolean, string>>, readonly string[] | undefined>>(name: TableName, callback: (t: TableBuilder<TableName>) => T | undefined): SqlContractBuilder<CodecTypes, Target, Tables & Record<TableName, ReturnType<T['build']>>, Models, Types, StorageHash, ExtensionPacks, Capabilities>;
+  model<ModelName extends string, TableName extends string, M extends ModelBuilder<ModelName, TableName, Record<string, string>, Record<string, RelationDefinition>>>(name: ModelName, table: TableName, callback: (m: ModelBuilder<ModelName, TableName, Record<string, string>, Record<never, never>>) => M | undefined): SqlContractBuilder<CodecTypes, Target, Tables, Models & Record<ModelName, ReturnType<M['build']>>, Types, StorageHash, ExtensionPacks, Capabilities>;
+  storageType<Name extends string, Type extends StorageTypeInstance>(name: Name, typeInstance: Type): SqlContractBuilder<CodecTypes, Target, Tables, Models, Types & Record<Name, Type>, StorageHash, ExtensionPacks, Capabilities>;
+}
+declare function defineContract<CodecTypes extends Record<string, {
+  output: unknown;
+}> = Record<string, never>>(): SqlContractBuilder<CodecTypes>;
+//#endregion
+export { type ColumnBuilder, defineContract };
+//# sourceMappingURL=contract-builder.d.mts.map

package/dist/contract-builder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-builder.d.mts","names":[],"sources":["../src/contract-builder.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/contract-builder.mjs

@@ -0,0 +1,344 @@
+import { ContractBuilder, ModelBuilder, TableBuilder, createTable } from "@prisma-next/contract-authoring";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { ColumnDefaultSchema } from "@prisma-next/sql-contract/validators";
+import { type } from "arktype";
+
+//#region src/contract.ts
+/**
+* Structural validation schema for SqlContract using Arktype.
+* This validates the shape and types of the contract structure.
+*/
+const StorageColumnSchema = type.declare().type({
+	nativeType: "string",
+	codecId: "string",
+	nullable: "boolean",
+	"typeParams?": "Record<string, unknown>",
+	"typeRef?": "string",
+	"default?": ColumnDefaultSchema
+});
+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 ExecutionMutationDefaultValueSchema = type({
+	kind: "'generator'",
+	id: "'ulid' | 'nanoid' | 'uuidv7' | 'uuidv4' | 'cuid2' | 'ksuid'",
+	"params?": "Record<string, unknown>"
+});
+const ExecutionSchema = type({ mutations: { defaults: type({
+	ref: {
+		table: "string",
+		column: "string"
+	},
+	"onCreate?": ExecutionMutationDefaultValueSchema,
+	"onUpdate?": ExecutionMutationDefaultValueSchema
+}).array().readonly() } });
+/**
+* Complete SqlContract schema for structural validation.
+* This validates the entire contract structure at once.
+*/
+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
+});
+/**
+* Computes mapping dictionaries from models and storage structures.
+* Assumes valid input - validation happens separately in validateContractLogic().
+*
+* @param models - Models object from contract
+* @param storage - Storage object from contract
+* @param existingMappings - Existing mappings from contract input (optional)
+* @returns Computed mappings dictionary
+*/
+function computeMappings(models, _storage, existingMappings) {
+	const modelToTable = {};
+	const tableToModel = {};
+	const fieldToColumn = {};
+	const columnToField = {};
+	for (const [modelName, model] of Object.entries(models)) {
+		const tableName = model.storage.table;
+		modelToTable[modelName] = tableName;
+		tableToModel[tableName] = modelName;
+		const modelFieldToColumn = {};
+		for (const [fieldName, field] of Object.entries(model.fields)) {
+			const columnName = field.column;
+			modelFieldToColumn[fieldName] = columnName;
+			if (!columnToField[tableName]) columnToField[tableName] = {};
+			columnToField[tableName][columnName] = fieldName;
+		}
+		fieldToColumn[modelName] = modelFieldToColumn;
+	}
+	return {
+		modelToTable: existingMappings?.modelToTable ?? modelToTable,
+		tableToModel: existingMappings?.tableToModel ?? tableToModel,
+		fieldToColumn: existingMappings?.fieldToColumn ?? fieldToColumn,
+		columnToField: existingMappings?.columnToField ?? columnToField,
+		codecTypes: existingMappings?.codecTypes ?? {},
+		operationTypes: existingMappings?.operationTypes ?? {}
+	};
+}
+
+//#endregion
+//#region src/contract-builder.ts
+var SqlContractBuilder = class SqlContractBuilder extends ContractBuilder {
+	/**
+	* This method is responsible for normalizing the contract IR by setting default values
+	* for all required fields:
+	* - `nullable`: defaults to `false` if not provided
+	* - `uniques`: defaults to `[]` (empty array)
+	* - `indexes`: defaults to `[]` (empty array)
+	* - `foreignKeys`: defaults to `[]` (empty array)
+	* - `relations`: defaults to `{}` (empty object) for both model-level and contract-level
+	* - `nativeType`: required field set from column type descriptor when columns are defined
+	*
+	* The contract builder is the **only** place where normalization should occur.
+	* Validators, parsers, and emitters should assume the contract is already normalized.
+	*
+	* **Required**: Use column type descriptors (e.g., `int4Column`, `textColumn`) when defining columns.
+	* This ensures `nativeType` is set correctly at build time.
+	*
+	* @returns A normalized SqlContract with all required fields present
+	*/
+	build() {
+		if (!this.state.target) throw new Error("target is required. Call .target() before .build()");
+		const target = this.state.target;
+		const storageTables = {};
+		const executionDefaults = [];
+		for (const tableName of Object.keys(this.state.tables)) {
+			const tableState = this.state.tables[tableName];
+			if (!tableState) continue;
+			const columns = {};
+			for (const columnName in tableState.columns) {
+				const columnState = tableState.columns[columnName];
+				if (!columnState) continue;
+				const codecId = columnState.type;
+				const nativeType = columnState.nativeType;
+				const typeRef = columnState.typeRef;
+				columns[columnName] = {
+					nativeType,
+					codecId,
+					nullable: columnState.nullable ?? false,
+					...ifDefined("typeParams", columnState.typeParams),
+					...ifDefined("default", columnState.default),
+					...ifDefined("typeRef", typeRef)
+				};
+				if ("executionDefault" in columnState && columnState.executionDefault) executionDefaults.push({
+					ref: {
+						table: tableName,
+						column: columnName
+					},
+					onCreate: columnState.executionDefault
+				});
+			}
+			storageTables[tableName] = {
+				columns,
+				uniques: (tableState.uniques ?? []).map((u) => ({
+					columns: u.columns,
+					...u.name ? { name: u.name } : {}
+				})),
+				indexes: (tableState.indexes ?? []).map((i) => ({
+					columns: i.columns,
+					...i.name ? { name: i.name } : {}
+				})),
+				foreignKeys: (tableState.foreignKeys ?? []).map((fk) => ({
+					columns: fk.columns,
+					references: fk.references,
+					...fk.name ? { name: fk.name } : {}
+				})),
+				...tableState.primaryKey ? { primaryKey: {
+					columns: tableState.primaryKey,
+					...tableState.primaryKeyName ? { name: tableState.primaryKeyName } : {}
+				} } : {}
+			};
+		}
+		const storage = {
+			tables: storageTables,
+			types: this.state.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);
+		}) } } : void 0;
+		const modelsPartial = {};
+		for (const modelName in this.state.models) {
+			const modelState = this.state.models[modelName];
+			if (!modelState) continue;
+			const modelStateTyped = modelState;
+			const fields = {};
+			for (const fieldName in modelStateTyped.fields) {
+				const columnName = modelStateTyped.fields[fieldName];
+				if (columnName) fields[fieldName] = { column: columnName };
+			}
+			modelsPartial[modelName] = {
+				storage: { table: modelStateTyped.table },
+				fields,
+				relations: {}
+			};
+		}
+		const relationsPartial = {};
+		for (const modelName in this.state.models) {
+			const modelState = this.state.models[modelName];
+			if (!modelState) continue;
+			const modelStateTyped = modelState;
+			const tableName = modelStateTyped.table;
+			if (!tableName) continue;
+			if (modelStateTyped.relations && Object.keys(modelStateTyped.relations).length > 0) {
+				if (!relationsPartial[tableName]) relationsPartial[tableName] = {};
+				const tableRelations = relationsPartial[tableName];
+				if (tableRelations) for (const relationName in modelStateTyped.relations) {
+					const relation = modelStateTyped.relations[relationName];
+					if (relation) tableRelations[relationName] = relation;
+				}
+			}
+		}
+		const models = modelsPartial;
+		const mappings = {
+			...computeMappings(models, storage),
+			codecTypes: {},
+			operationTypes: {}
+		};
+		const extensionNamespaces = this.state.extensionNamespaces ?? [];
+		const extensionPacks = { ...this.state.extensionPacks || {} };
+		for (const namespace of extensionNamespaces) if (!Object.hasOwn(extensionPacks, namespace)) extensionPacks[namespace] = {};
+		return {
+			schemaVersion: "1",
+			target,
+			targetFamily: "sql",
+			storageHash: this.state.storageHash || "sha256:ts-builder-placeholder",
+			models,
+			relations: relationsPartial,
+			storage,
+			mappings,
+			...execution ? { execution } : {},
+			extensionPacks,
+			capabilities: this.state.capabilities || {},
+			meta: {},
+			sources: {}
+		};
+	}
+	target(packRef) {
+		return new SqlContractBuilder({
+			...this.state,
+			target: packRef.targetId
+		});
+	}
+	extensionPacks(packs) {
+		if (!this.state.target) throw new Error("extensionPacks() requires target() to be called first");
+		const namespaces = new Set(this.state.extensionNamespaces ?? []);
+		for (const packRef of Object.values(packs)) {
+			if (!packRef) continue;
+			if (packRef.kind !== "extension") throw new Error(`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".`);
+			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}".`);
+			namespaces.add(packRef.id);
+		}
+		return new SqlContractBuilder({
+			...this.state,
+			extensionNamespaces: [...namespaces]
+		});
+	}
+	capabilities(capabilities) {
+		return new SqlContractBuilder({
+			...this.state,
+			capabilities
+		});
+	}
+	storageHash(hash) {
+		return new SqlContractBuilder({
+			...this.state,
+			storageHash: hash
+		});
+	}
+	table(name, callback) {
+		const tableBuilder = createTable(name);
+		const result = callback(tableBuilder);
+		const tableState = (result instanceof TableBuilder ? result : tableBuilder).build();
+		return new SqlContractBuilder({
+			...this.state,
+			tables: {
+				...this.state.tables,
+				[name]: tableState
+			}
+		});
+	}
+	model(name, table, callback) {
+		const modelBuilder = new ModelBuilder(name, table);
+		const result = callback(modelBuilder);
+		const modelState = (result instanceof ModelBuilder ? result : modelBuilder).build();
+		return new SqlContractBuilder({
+			...this.state,
+			models: {
+				...this.state.models,
+				[name]: modelState
+			}
+		});
+	}
+	storageType(name, typeInstance) {
+		return new SqlContractBuilder({
+			...this.state,
+			storageTypes: {
+				...this.state.storageTypes ?? {},
+				[name]: typeInstance
+			}
+		});
+	}
+};
+function defineContract() {
+	return new SqlContractBuilder();
+}
+
+//#endregion
+export { defineContract };
+//# sourceMappingURL=contract-builder.mjs.map