@prisma-next/sql-contract-ts 0.3.0-pr.93.5 → 0.3.0-pr.94.2

package/dist/contract-builder.mjs

@@ -0,0 +1,184 @@
+import { t as computeMappings } from "./contract-CbxDA5bF.mjs";
+import { ContractBuilder, ModelBuilder, TableBuilder, createTable } from "@prisma-next/contract-authoring";
+
+//#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 = {};
+		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;
+				columns[columnName] = {
+					nativeType: columnState.nativeType,
+					codecId,
+					nullable: columnState.nullable ?? false
+				};
+			}
+			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 };
+		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",
+			coreHash: this.state.coreHash || "sha256:ts-builder-placeholder",
+			models,
+			relations: relationsPartial,
+			storage,
+			mappings,
+			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
+		});
+	}
+	coreHash(hash) {
+		return new SqlContractBuilder({
+			...this.state,
+			coreHash: 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
+			}
+		});
+	}
+};
+function defineContract() {
+	return new SqlContractBuilder();
+}
+
+//#endregion
+export { defineContract };
+//# sourceMappingURL=contract-builder.mjs.map

package/dist/contract-builder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-builder.mjs","names":["modelsPartial: Partial<BuildModels<Models>>","fields: Partial<Record<string, ModelField>>","relationsPartial: Partial<Record<string, Record<string, RelationDefinition>>>","extensionPacks: Record<string, unknown>"],"sources":["../src/contract-builder.ts"],"sourcesContent":["import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/contract/framework-components';\nimport type {\n  ColumnBuilderState,\n  ModelBuilderState,\n  RelationDefinition,\n  TableBuilderState,\n} from '@prisma-next/contract-authoring';\nimport {\n  type BuildModels,\n  type BuildRelations,\n  type BuildStorageColumn,\n  ContractBuilder,\n  createTable,\n  type ExtractColumns,\n  type ExtractPrimaryKey,\n  ModelBuilder,\n  type Mutable,\n  TableBuilder,\n} from '@prisma-next/contract-authoring';\nimport type {\n  ModelDefinition,\n  ModelField,\n  SqlContract,\n  SqlMappings,\n  SqlStorage,\n} from '@prisma-next/sql-contract/types';\nimport { computeMappings } from './contract';\n\n/**\n * Type-level mappings structure for contracts built via `defineContract()`.\n *\n * Compile-time type helper (not a runtime object) that ensures mappings match what the builder\n * produces. `codecTypes` uses the generic `CodecTypes` parameter; `operationTypes` is always\n * empty since operations are added via extensions at runtime.\n *\n * **Difference from RuntimeContext**: This is a compile-time type for contract construction.\n * `RuntimeContext` is a runtime object with populated registries for query execution.\n *\n * @template C - The `CodecTypes` generic parameter passed to `defineContract<CodecTypes>()`\n */\ntype ContractBuilderMappings<C extends Record<string, { output: unknown }>> = Omit<\n  SqlMappings,\n  'codecTypes' | 'operationTypes'\n> & {\n  readonly codecTypes: C;\n  readonly operationTypes: Record<string, never>;\n};\n\ntype BuildStorageTable<\n  _TableName extends string,\n  Columns extends Record<string, ColumnBuilderState<string, boolean, string>>,\n  PK extends readonly string[] | undefined,\n> = {\n  readonly columns: {\n    readonly [K in keyof Columns]: Columns[K] extends ColumnBuilderState<\n      string,\n      infer Null,\n      infer TType\n    >\n      ? BuildStorageColumn<Null & boolean, TType>\n      : never;\n  };\n  readonly uniques: ReadonlyArray<{ readonly columns: readonly string[]; readonly name?: string }>;\n  readonly indexes: ReadonlyArray<{ readonly columns: readonly string[]; readonly name?: string }>;\n  readonly foreignKeys: ReadonlyArray<{\n    readonly columns: readonly string[];\n    readonly references: { readonly table: string; readonly columns: readonly string[] };\n    readonly name?: string;\n  }>;\n} & (PK extends readonly string[]\n  ? { readonly primaryKey: { readonly columns: PK; readonly name?: string } }\n  : Record<string, never>);\n\ntype BuildStorage<\n  Tables extends Record<\n    string,\n    TableBuilderState<\n      string,\n      Record<string, ColumnBuilderState<string, boolean, string>>,\n      readonly string[] | undefined\n    >\n  >,\n> = {\n  readonly tables: {\n    readonly [K in keyof Tables]: BuildStorageTable<\n      K & string,\n      ExtractColumns<Tables[K]>,\n      ExtractPrimaryKey<Tables[K]>\n    >;\n  };\n};\n\ntype BuildStorageTables<\n  Tables extends Record<\n    string,\n    TableBuilderState<\n      string,\n      Record<string, ColumnBuilderState<string, boolean, string>>,\n      readonly string[] | undefined\n    >\n  >,\n> = {\n  readonly [K in keyof Tables]: BuildStorageTable<\n    K & string,\n    ExtractColumns<Tables[K]>,\n    ExtractPrimaryKey<Tables[K]>\n  >;\n};\n\nexport interface ColumnBuilder<Name extends string, Nullable extends boolean, Type extends string> {\n  nullable<Value extends boolean>(value?: Value): ColumnBuilder<Name, Value, Type>;\n  type<Id extends string>(id: Id): ColumnBuilder<Name, Nullable, Id>;\n  build(): ColumnBuilderState<Name, Nullable, Type>;\n}\n\nclass SqlContractBuilder<\n  CodecTypes extends Record<string, { output: unknown }> = Record<string, never>,\n  Target extends string | undefined = undefined,\n  Tables extends Record<\n    string,\n    TableBuilderState<\n      string,\n      Record<string, ColumnBuilderState<string, boolean, string>>,\n      readonly string[] | undefined\n    >\n  > = Record<never, never>,\n  Models extends Record<\n    string,\n    ModelBuilderState<string, string, Record<string, string>, Record<string, RelationDefinition>>\n  > = Record<never, never>,\n  CoreHash extends string | undefined = undefined,\n  ExtensionPacks extends Record<string, unknown> | undefined = undefined,\n  Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined,\n> extends ContractBuilder<Target, Tables, Models, CoreHash, ExtensionPacks, Capabilities> {\n  /**\n   * This method is responsible for normalizing the contract IR by setting default values\n   * for all required fields:\n   * - `nullable`: defaults to `false` if not provided\n   * - `uniques`: defaults to `[]` (empty array)\n   * - `indexes`: defaults to `[]` (empty array)\n   * - `foreignKeys`: defaults to `[]` (empty array)\n   * - `relations`: defaults to `{}` (empty object) for both model-level and contract-level\n   * - `nativeType`: required field set from column type descriptor when columns are defined\n   *\n   * The contract builder is the **only** place where normalization should occur.\n   * Validators, parsers, and emitters should assume the contract is already normalized.\n   *\n   * **Required**: Use column type descriptors (e.g., `int4Column`, `textColumn`) when defining columns.\n   * This ensures `nativeType` is set correctly at build time.\n   *\n   * @returns A normalized SqlContract with all required fields present\n   */\n  build(): Target extends string\n    ? SqlContract<\n        BuildStorage<Tables>,\n        BuildModels<Models>,\n        BuildRelations<Models>,\n        ContractBuilderMappings<CodecTypes>\n      > & {\n        readonly schemaVersion: '1';\n        readonly target: Target;\n        readonly targetFamily: 'sql';\n        readonly coreHash: CoreHash extends string ? CoreHash : string;\n      } & (ExtensionPacks extends Record<string, unknown>\n          ? { readonly extensionPacks: ExtensionPacks }\n          : Record<string, never>) &\n        (Capabilities extends Record<string, Record<string, boolean>>\n          ? { readonly capabilities: Capabilities }\n          : Record<string, never>)\n    : never {\n    // Type helper to ensure literal types are preserved in return type\n    type BuiltContract = Target extends string\n      ? SqlContract<\n          BuildStorage<Tables>,\n          BuildModels<Models>,\n          BuildRelations<Models>,\n          ContractBuilderMappings<CodecTypes>\n        > & {\n          readonly schemaVersion: '1';\n          readonly target: Target;\n          readonly targetFamily: 'sql';\n          readonly coreHash: CoreHash extends string ? CoreHash : string;\n        } & (ExtensionPacks extends Record<string, unknown>\n            ? { readonly extensionPacks: ExtensionPacks }\n            : Record<string, never>) &\n          (Capabilities extends Record<string, Record<string, boolean>>\n            ? { readonly capabilities: Capabilities }\n            : Record<string, never>)\n      : never;\n    if (!this.state.target) {\n      throw new Error('target is required. Call .target() before .build()');\n    }\n\n    const target = this.state.target as Target & string;\n\n    const storageTables = {} as Partial<Mutable<BuildStorageTables<Tables>>>;\n\n    for (const tableName of Object.keys(this.state.tables) as Array<keyof Tables & string>) {\n      const tableState = this.state.tables[tableName];\n      if (!tableState) continue;\n\n      type TableKey = typeof tableName;\n      type ColumnDefs = ExtractColumns<Tables[TableKey]>;\n      type PrimaryKey = ExtractPrimaryKey<Tables[TableKey]>;\n\n      const columns = {} as Partial<{\n        [K in keyof ColumnDefs]: BuildStorageColumn<\n          ColumnDefs[K]['nullable'] & boolean,\n          ColumnDefs[K]['type']\n        >;\n      }>;\n\n      for (const columnName in tableState.columns) {\n        const columnState = tableState.columns[columnName];\n        if (!columnState) continue;\n        const codecId = columnState.type;\n        const nativeType = columnState.nativeType;\n\n        columns[columnName as keyof ColumnDefs] = {\n          nativeType,\n          codecId,\n          nullable: (columnState.nullable ?? false) as ColumnDefs[keyof ColumnDefs]['nullable'] &\n            boolean,\n        } as BuildStorageColumn<\n          ColumnDefs[keyof ColumnDefs]['nullable'] & boolean,\n          ColumnDefs[keyof ColumnDefs]['type']\n        >;\n      }\n\n      // Build uniques from table state\n      const uniques = (tableState.uniques ?? []).map((u) => ({\n        columns: u.columns,\n        ...(u.name ? { name: u.name } : {}),\n      }));\n\n      // Build indexes from table state\n      const indexes = (tableState.indexes ?? []).map((i) => ({\n        columns: i.columns,\n        ...(i.name ? { name: i.name } : {}),\n      }));\n\n      // Build foreign keys from table state\n      const foreignKeys = (tableState.foreignKeys ?? []).map((fk) => ({\n        columns: fk.columns,\n        references: fk.references,\n        ...(fk.name ? { name: fk.name } : {}),\n      }));\n\n      const table = {\n        columns: columns as {\n          [K in keyof ColumnDefs]: BuildStorageColumn<\n            ColumnDefs[K]['nullable'] & boolean,\n            ColumnDefs[K]['type']\n          >;\n        },\n        uniques,\n        indexes,\n        foreignKeys,\n        ...(tableState.primaryKey\n          ? {\n              primaryKey: {\n                columns: tableState.primaryKey,\n                ...(tableState.primaryKeyName ? { name: tableState.primaryKeyName } : {}),\n              },\n            }\n          : {}),\n      } as unknown as BuildStorageTable<TableKey & string, ColumnDefs, PrimaryKey>;\n\n      (storageTables as Mutable<BuildStorageTables<Tables>>)[tableName] = table;\n    }\n\n    const storage = { tables: storageTables as BuildStorageTables<Tables> } as BuildStorage<Tables>;\n\n    // Build models - construct as partial first, then assert full type\n    const modelsPartial: Partial<BuildModels<Models>> = {};\n\n    // Iterate over models - TypeScript will see keys as string, but type assertion preserves literals\n    for (const modelName in this.state.models) {\n      const modelState = this.state.models[modelName];\n      if (!modelState) continue;\n\n      const modelStateTyped = modelState as unknown as {\n        name: string;\n        table: string;\n        fields: Record<string, string>;\n      };\n\n      // Build fields object\n      const fields: Partial<Record<string, ModelField>> = {};\n\n      // Iterate over fields\n      for (const fieldName in modelStateTyped.fields) {\n        const columnName = modelStateTyped.fields[fieldName];\n        if (columnName) {\n          fields[fieldName] = {\n            column: columnName,\n          };\n        }\n      }\n\n      // Assign to models - type assertion preserves literal keys\n      (modelsPartial as unknown as Record<string, ModelDefinition>)[modelName] = {\n        storage: {\n          table: modelStateTyped.table,\n        },\n        fields: fields as Record<string, ModelField>,\n        relations: {},\n      };\n    }\n\n    // Build relations object - organized by table name\n    const relationsPartial: Partial<Record<string, Record<string, RelationDefinition>>> = {};\n\n    // Iterate over models to collect relations\n    for (const modelName in this.state.models) {\n      const modelState = this.state.models[modelName];\n      if (!modelState) continue;\n\n      const modelStateTyped = modelState as unknown as {\n        name: string;\n        table: string;\n        fields: Record<string, string>;\n        relations: Record<string, RelationDefinition>;\n      };\n\n      const tableName = modelStateTyped.table;\n      if (!tableName) continue;\n\n      // Only initialize relations object for this table if it has relations\n      if (modelStateTyped.relations && Object.keys(modelStateTyped.relations).length > 0) {\n        if (!relationsPartial[tableName]) {\n          relationsPartial[tableName] = {};\n        }\n\n        // Add relations from this model to the table's relations\n        const tableRelations = relationsPartial[tableName];\n        if (tableRelations) {\n          for (const relationName in modelStateTyped.relations) {\n            const relation = modelStateTyped.relations[relationName];\n            if (relation) {\n              tableRelations[relationName] = relation;\n            }\n          }\n        }\n      }\n    }\n\n    const models = modelsPartial as unknown as BuildModels<Models>;\n\n    const baseMappings = computeMappings(\n      models as unknown as Record<string, ModelDefinition>,\n      storage as SqlStorage,\n    );\n\n    const mappings = {\n      ...baseMappings,\n      codecTypes: {} as CodecTypes,\n      operationTypes: {} as Record<string, never>,\n    } as ContractBuilderMappings<CodecTypes>;\n\n    const extensionNamespaces = this.state.extensionNamespaces ?? [];\n    const extensionPacks: Record<string, unknown> = { ...(this.state.extensionPacks || {}) };\n    for (const namespace of extensionNamespaces) {\n      if (!Object.hasOwn(extensionPacks, namespace)) {\n        extensionPacks[namespace] = {};\n      }\n    }\n\n    // Construct contract with explicit type that matches the generic parameters\n    // This ensures TypeScript infers literal types from the generics, not runtime values\n    // Always include relations, even if empty (normalized to empty object)\n    const contract = {\n      schemaVersion: '1' as const,\n      target,\n      targetFamily: 'sql' as const,\n      coreHash: this.state.coreHash || 'sha256:ts-builder-placeholder',\n      models,\n      relations: relationsPartial,\n      storage,\n      mappings,\n      extensionPacks,\n      capabilities: this.state.capabilities || {},\n      meta: {},\n      sources: {},\n    } as unknown as BuiltContract;\n\n    return contract as unknown as ReturnType<\n      SqlContractBuilder<\n        CodecTypes,\n        Target,\n        Tables,\n        Models,\n        CoreHash,\n        ExtensionPacks,\n        Capabilities\n      >['build']\n    >;\n  }\n\n  override target<T extends string>(\n    packRef: TargetPackRef<'sql', T>,\n  ): SqlContractBuilder<CodecTypes, T, Tables, Models, CoreHash, ExtensionPacks, Capabilities> {\n    return new SqlContractBuilder<\n      CodecTypes,\n      T,\n      Tables,\n      Models,\n      CoreHash,\n      ExtensionPacks,\n      Capabilities\n    >({\n      ...this.state,\n      target: packRef.targetId,\n    });\n  }\n\n  extensionPacks(\n    packs: Record<string, ExtensionPackRef<'sql', string>>,\n  ): SqlContractBuilder<\n    CodecTypes,\n    Target,\n    Tables,\n    Models,\n    CoreHash,\n    ExtensionPacks,\n    Capabilities\n  > {\n    if (!this.state.target) {\n      throw new Error('extensionPacks() requires target() to be called first');\n    }\n\n    const namespaces = new Set(this.state.extensionNamespaces ?? []);\n\n    for (const packRef of Object.values(packs)) {\n      if (!packRef) continue;\n\n      if (packRef.kind !== 'extension') {\n        throw new Error(\n          `extensionPacks() only accepts extension pack refs. Received kind \"${packRef.kind}\".`,\n        );\n      }\n\n      if (packRef.familyId !== 'sql') {\n        throw new Error(\n          `extension pack \"${packRef.id}\" targets family \"${packRef.familyId}\" but this builder targets \"sql\".`,\n        );\n      }\n\n      if (packRef.targetId && packRef.targetId !== this.state.target) {\n        throw new Error(\n          `extension pack \"${packRef.id}\" targets \"${packRef.targetId}\" but builder target is \"${this.state.target}\".`,\n        );\n      }\n\n      namespaces.add(packRef.id);\n    }\n\n    return new SqlContractBuilder<\n      CodecTypes,\n      Target,\n      Tables,\n      Models,\n      CoreHash,\n      ExtensionPacks,\n      Capabilities\n    >({\n      ...this.state,\n      extensionNamespaces: [...namespaces],\n    });\n  }\n\n  override capabilities<C extends Record<string, Record<string, boolean>>>(\n    capabilities: C,\n  ): SqlContractBuilder<CodecTypes, Target, Tables, Models, CoreHash, ExtensionPacks, C> {\n    return new SqlContractBuilder<CodecTypes, Target, Tables, Models, CoreHash, ExtensionPacks, C>({\n      ...this.state,\n      capabilities,\n    });\n  }\n\n  override coreHash<H extends string>(\n    hash: H,\n  ): SqlContractBuilder<CodecTypes, Target, Tables, Models, H, ExtensionPacks, Capabilities> {\n    return new SqlContractBuilder<\n      CodecTypes,\n      Target,\n      Tables,\n      Models,\n      H,\n      ExtensionPacks,\n      Capabilities\n    >({\n      ...this.state,\n      coreHash: hash,\n    });\n  }\n\n  override table<\n    TableName extends string,\n    T extends TableBuilder<\n      TableName,\n      Record<string, ColumnBuilderState<string, boolean, string>>,\n      readonly string[] | undefined\n    >,\n  >(\n    name: TableName,\n    callback: (t: TableBuilder<TableName>) => T | undefined,\n  ): SqlContractBuilder<\n    CodecTypes,\n    Target,\n    Tables & Record<TableName, ReturnType<T['build']>>,\n    Models,\n    CoreHash,\n    ExtensionPacks,\n    Capabilities\n  > {\n    const tableBuilder = createTable(name);\n    const result = callback(tableBuilder);\n    const finalBuilder = result instanceof TableBuilder ? result : tableBuilder;\n    const tableState = finalBuilder.build();\n\n    return new SqlContractBuilder<\n      CodecTypes,\n      Target,\n      Tables & Record<TableName, ReturnType<T['build']>>,\n      Models,\n      CoreHash,\n      ExtensionPacks,\n      Capabilities\n    >({\n      ...this.state,\n      tables: { ...this.state.tables, [name]: tableState } as Tables &\n        Record<TableName, ReturnType<T['build']>>,\n    });\n  }\n\n  override model<\n    ModelName extends string,\n    TableName extends string,\n    M extends ModelBuilder<\n      ModelName,\n      TableName,\n      Record<string, string>,\n      Record<string, RelationDefinition>\n    >,\n  >(\n    name: ModelName,\n    table: TableName,\n    callback: (\n      m: ModelBuilder<ModelName, TableName, Record<string, string>, Record<never, never>>,\n    ) => M | undefined,\n  ): SqlContractBuilder<\n    CodecTypes,\n    Target,\n    Tables,\n    Models & Record<ModelName, ReturnType<M['build']>>,\n    CoreHash,\n    ExtensionPacks,\n    Capabilities\n  > {\n    const modelBuilder = new ModelBuilder<ModelName, TableName>(name, table);\n    const result = callback(modelBuilder);\n    const finalBuilder = result instanceof ModelBuilder ? result : modelBuilder;\n    const modelState = finalBuilder.build();\n\n    return new SqlContractBuilder<\n      CodecTypes,\n      Target,\n      Tables,\n      Models & Record<ModelName, ReturnType<M['build']>>,\n      CoreHash,\n      ExtensionPacks,\n      Capabilities\n    >({\n      ...this.state,\n      models: { ...this.state.models, [name]: modelState } as Models &\n        Record<ModelName, ReturnType<M['build']>>,\n    });\n  }\n}\n\nexport function defineContract<\n  CodecTypes extends Record<string, { output: unknown }> = Record<string, never>,\n>(): SqlContractBuilder<CodecTypes> {\n  return new SqlContractBuilder<CodecTypes>();\n}\n"],"mappings":"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"}

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

@@ -1,4 +1,7 @@
-import type { ModelDefinition, SqlContract, SqlMappings, SqlStorage } from '@prisma-next/sql-contract/types';
+import { ModelDefinition, SqlContract, SqlMappings, SqlStorage } from "@prisma-next/sql-contract/types";
+
+//#region src/contract.d.ts
+
 /**
  * Computes mapping dictionaries from models and storage structures.
  * Assumes valid input - validation happens separately in validateContractLogic().
@@ -8,8 +11,7 @@ import type { ModelDefinition, SqlContract, SqlMappings, SqlStorage } from '@pri
  * @param existingMappings - Existing mappings from contract input (optional)
  * @returns Computed mappings dictionary
  */
-export declare function computeMappings(models: Record<string, ModelDefinition>, _storage: SqlStorage, existingMappings?: Partial<SqlMappings>): SqlMappings;
-export declare function normalizeContract(contract: unknown): SqlContract<SqlStorage>;
+declare function computeMappings(models: Record<string, ModelDefinition>, _storage: SqlStorage, existingMappings?: Partial<SqlMappings>): SqlMappings;
 /**
  * Validates that a JSON import conforms to the SqlContract structure
  * and returns a fully typed SqlContract.
@@ -46,5 +48,7 @@ export declare function normalizeContract(contract: unknown): SqlContract<SqlSto
  * @returns A validated contract matching the TContract type
  * @throws Error if the contract structure or logic is invalid
  */
-export declare function validateContract<TContract extends SqlContract<SqlStorage>>(value: unknown): TContract;
-//# sourceMappingURL=contract.d.ts.map
+declare function validateContract<TContract extends SqlContract<SqlStorage>>(value: unknown): TContract;
+//#endregion
+export { computeMappings, validateContract };
+//# sourceMappingURL=contract.d.mts.map

package/dist/contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.mts","names":[],"sources":["../src/contract.ts"],"sourcesContent":[],"mappings":";;;;;;AAkJA;;;;;;;AAIc,iBAJE,eAAA,CAIF,MAAA,EAHJ,MAGI,CAAA,MAAA,EAHW,eAGX,CAAA,EAAA,QAAA,EAFF,UAEE,EAAA,gBAAA,CAAA,EADO,OACP,CADe,WACf,CAAA,CAAA,EAAX,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2VE,mCAAmC,YAAY,8BAE5D"}

package/dist/contract.mjs

@@ -0,0 +1,3 @@
+import { n as validateContract, t as computeMappings } from "./contract-CbxDA5bF.mjs";
+
+export { computeMappings, validateContract };

package/package.json

@@ -1,24 +1,28 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.3.0-pr.93.5",
+  "version": "0.3.0-pr.94.2",
   "type": "module",
   "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
   "description": "SQL-specific TypeScript contract authoring surface for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.25",
     "ts-toolbelt": "^9.6.0",
-    "@prisma-next/contract-authoring": "0.3.0-pr.93.5",
-    "@prisma-next/sql-contract": "0.3.0-pr.93.5",
-    "@prisma-next/contract": "0.3.0-pr.93.5"
+    "@prisma-next/sql-contract": "0.3.0-pr.94.2",
+    "@prisma-next/contract": "0.3.0-pr.94.2",
+    "@prisma-next/contract-authoring": "0.3.0-pr.94.2"
   },
   "devDependencies": {
     "@types/pg": "8.16.0",
     "pg": "8.16.3",
-    "tsup": "8.5.1",
+    "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.16",
     "@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",
@@ -26,18 +30,12 @@
     "schemas"
   ],
   "exports": {
-    "./contract-builder": {
-      "types": "./dist/exports/contract-builder.d.ts",
-      "import": "./dist/exports/contract-builder.js"
-    },
-    "./contract": {
-      "types": "./dist/exports/contract.d.ts",
-      "import": "./dist/exports/contract.js"
-    },
-    "./schema-sql": "./schemas/data-contract-sql-v1.json"
+    "./contract": "./dist/contract.mjs",
+    "./contract-builder": "./dist/contract-builder.mjs",
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "tsup && tsc",
+    "build": "tsdown",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --noEmit",

package/dist/chunk-SEOX3AAQ.js

@@ -1,309 +0,0 @@
-// src/contract.ts
-import { type } from "arktype";
-var StorageColumnSchema = type.declare().type({
-  nativeType: "string",
-  codecId: "string",
-  nullable: "boolean"
-});
-var PrimaryKeySchema = type.declare().type({
-  columns: type.string.array().readonly(),
-  "name?": "string"
-});
-var UniqueConstraintSchema = type.declare().type({
-  columns: type.string.array().readonly(),
-  "name?": "string"
-});
-var IndexSchema = type.declare().type({
-  columns: type.string.array().readonly(),
-  "name?": "string"
-});
-var ForeignKeyReferencesSchema = type.declare().type({
-  table: "string",
-  columns: type.string.array().readonly()
-});
-var ForeignKeySchema = type.declare().type({
-  columns: type.string.array().readonly(),
-  references: ForeignKeyReferencesSchema,
-  "name?": "string"
-});
-var StorageTableSchema = type.declare().type({
-  columns: type({ "[string]": StorageColumnSchema }),
-  "primaryKey?": PrimaryKeySchema,
-  uniques: UniqueConstraintSchema.array().readonly(),
-  indexes: IndexSchema.array().readonly(),
-  foreignKeys: ForeignKeySchema.array().readonly()
-});
-var StorageSchema = type.declare().type({
-  tables: type({ "[string]": StorageTableSchema })
-});
-var ModelFieldSchema = type.declare().type({
-  column: "string"
-});
-var ModelStorageSchema = type.declare().type({
-  table: "string"
-});
-var ModelSchema = type.declare().type({
-  storage: ModelStorageSchema,
-  fields: type({ "[string]": ModelFieldSchema }),
-  relations: type({ "[string]": "unknown" })
-});
-var SqlContractSchema = type({
-  "schemaVersion?": "'1'",
-  target: "string",
-  targetFamily: "'sql'",
-  coreHash: "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
-});
-function validateContractStructure(value) {
-  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;
-}
-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 ?? {}
-  };
-}
-function validateContractLogic(structurallyValidatedContract) {
-  const { storage, models } = structurallyValidatedContract;
-  const tableNames = new Set(Object.keys(storage.tables));
-  for (const [modelName, modelUnknown] of Object.entries(models)) {
-    const model = modelUnknown;
-    if (!model.storage?.table) {
-      throw new Error(`Model "${modelName}" is missing storage.table`);
-    }
-    const tableName = model.storage.table;
-    if (!tableNames.has(tableName)) {
-      throw new Error(`Model "${modelName}" references non-existent table "${tableName}"`);
-    }
-    const table = storage.tables[tableName];
-    if (!table) {
-      throw new Error(`Model "${modelName}" references non-existent table "${tableName}"`);
-    }
-    if (!table.primaryKey) {
-      throw new Error(`Model "${modelName}" table "${tableName}" is missing a primary key`);
-    }
-    const columnNames = new Set(Object.keys(table.columns));
-    if (!model.fields) {
-      throw new Error(`Model "${modelName}" is missing fields`);
-    }
-    for (const [fieldName, fieldUnknown] of Object.entries(model.fields)) {
-      const field = fieldUnknown;
-      if (!field.column) {
-        throw new Error(`Model "${modelName}" field "${fieldName}" is missing column property`);
-      }
-      if (!columnNames.has(field.column)) {
-        throw new Error(
-          `Model "${modelName}" field "${fieldName}" references non-existent column "${field.column}" in table "${tableName}"`
-        );
-      }
-    }
-    if (model.relations) {
-      for (const [relationName, relation] of Object.entries(model.relations)) {
-        if (typeof relation === "object" && relation !== null && "on" in relation && "to" in relation) {
-          const on = relation.on;
-          const cardinality = relation.cardinality;
-          if (on.parentCols && on.childCols) {
-            if (cardinality === "1:N") {
-              continue;
-            }
-            const hasMatchingFk = table.foreignKeys?.some((fk) => {
-              return fk.columns.length === on.childCols?.length && fk.columns.every((col, i) => col === on.childCols?.[i]) && fk.references.table && fk.references.columns.length === on.parentCols?.length && fk.references.columns.every((col, i) => col === on.parentCols?.[i]);
-            });
-            if (!hasMatchingFk) {
-              throw new Error(
-                `Model "${modelName}" relation "${relationName}" does not have a corresponding foreign key in table "${tableName}"`
-              );
-            }
-          }
-        }
-      }
-    }
-  }
-  for (const [tableName, table] of Object.entries(storage.tables)) {
-    const columnNames = new Set(Object.keys(table.columns));
-    if (table.primaryKey) {
-      for (const colName of table.primaryKey.columns) {
-        if (!columnNames.has(colName)) {
-          throw new Error(
-            `Table "${tableName}" primaryKey references non-existent column "${colName}"`
-          );
-        }
-      }
-    }
-    for (const unique of table.uniques) {
-      for (const colName of unique.columns) {
-        if (!columnNames.has(colName)) {
-          throw new Error(
-            `Table "${tableName}" unique constraint references non-existent column "${colName}"`
-          );
-        }
-      }
-    }
-    for (const index of table.indexes) {
-      for (const colName of index.columns) {
-        if (!columnNames.has(colName)) {
-          throw new Error(`Table "${tableName}" index references non-existent column "${colName}"`);
-        }
-      }
-    }
-    for (const fk of table.foreignKeys) {
-      for (const colName of fk.columns) {
-        if (!columnNames.has(colName)) {
-          throw new Error(
-            `Table "${tableName}" foreignKey references non-existent column "${colName}"`
-          );
-        }
-      }
-      if (!tableNames.has(fk.references.table)) {
-        throw new Error(
-          `Table "${tableName}" foreignKey references non-existent table "${fk.references.table}"`
-        );
-      }
-      const referencedTable = storage.tables[fk.references.table];
-      if (!referencedTable) {
-        throw new Error(
-          `Table "${tableName}" foreignKey references non-existent table "${fk.references.table}"`
-        );
-      }
-      const referencedColumnNames = new Set(Object.keys(referencedTable.columns));
-      for (const colName of fk.references.columns) {
-        if (!referencedColumnNames.has(colName)) {
-          throw new Error(
-            `Table "${tableName}" foreignKey references non-existent column "${colName}" in table "${fk.references.table}"`
-          );
-        }
-      }
-      if (fk.columns.length !== fk.references.columns.length) {
-        throw new Error(
-          `Table "${tableName}" foreignKey column count (${fk.columns.length}) does not match referenced column count (${fk.references.columns.length})`
-        );
-      }
-    }
-  }
-}
-function normalizeContract(contract) {
-  const contractObj = contract;
-  let normalizedStorage = contractObj["storage"];
-  if (normalizedStorage && typeof normalizedStorage === "object" && normalizedStorage !== null) {
-    const storage = normalizedStorage;
-    const tables = storage["tables"];
-    if (tables) {
-      const normalizedTables = {};
-      for (const [tableName, table] of Object.entries(tables)) {
-        const tableObj = table;
-        const columns = tableObj["columns"];
-        if (columns) {
-          const normalizedColumns = {};
-          for (const [columnName, column] of Object.entries(columns)) {
-            const columnObj = column;
-            const normalizedColumn = {
-              ...columnObj,
-              nullable: columnObj["nullable"] ?? false
-            };
-            normalizedColumns[columnName] = normalizedColumn;
-          }
-          normalizedTables[tableName] = {
-            ...tableObj,
-            columns: normalizedColumns,
-            uniques: tableObj["uniques"] ?? [],
-            indexes: tableObj["indexes"] ?? [],
-            foreignKeys: tableObj["foreignKeys"] ?? []
-          };
-        } else {
-          normalizedTables[tableName] = tableObj;
-        }
-      }
-      normalizedStorage = {
-        ...storage,
-        tables: normalizedTables
-      };
-    }
-  }
-  let normalizedModels = contractObj["models"];
-  if (normalizedModels && typeof normalizedModels === "object" && normalizedModels !== null) {
-    const models = normalizedModels;
-    const normalizedModelsObj = {};
-    for (const [modelName, model] of Object.entries(models)) {
-      const modelObj = model;
-      normalizedModelsObj[modelName] = {
-        ...modelObj,
-        relations: modelObj["relations"] ?? {}
-      };
-    }
-    normalizedModels = normalizedModelsObj;
-  }
-  return {
-    ...contractObj,
-    models: normalizedModels,
-    relations: contractObj["relations"] ?? {},
-    storage: normalizedStorage,
-    extensionPacks: contractObj["extensionPacks"] ?? {},
-    capabilities: contractObj["capabilities"] ?? {},
-    meta: contractObj["meta"] ?? {},
-    sources: contractObj["sources"] ?? {}
-  };
-}
-function validateContract(value) {
-  const normalized = normalizeContract(value);
-  const structurallyValid = validateContractStructure(normalized);
-  const contractForValidation = structurallyValid;
-  validateContractLogic(contractForValidation);
-  const existingMappings = contractForValidation.mappings;
-  const mappings = computeMappings(
-    contractForValidation.models,
-    contractForValidation.storage,
-    existingMappings
-  );
-  const contractWithMappings = {
-    ...structurallyValid,
-    models: contractForValidation.models,
-    relations: contractForValidation.relations,
-    storage: contractForValidation.storage,
-    mappings
-  };
-  return contractWithMappings;
-}
-
-export {
-  computeMappings,
-  validateContract
-};
-//# sourceMappingURL=chunk-SEOX3AAQ.js.map