@prisma-next/sql-contract-ts 0.3.0-pr.94.3 → 0.3.0-pr.95.2

package/dist/exports/contract-builder.js

@@ -0,0 +1,231 @@
+import {
+  computeMappings
+} from "../chunk-HTNUNGA2.js";
+
+// src/contract-builder.ts
+import {
+  ContractBuilder,
+  createTable,
+  ModelBuilder,
+  TableBuilder
+} from "@prisma-next/contract-authoring";
+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;
+        const nativeType = columnState.nativeType;
+        columns[columnName] = {
+          nativeType,
+          codecId,
+          nullable: columnState.nullable ?? false
+        };
+      }
+      const uniques = (tableState.uniques ?? []).map((u) => ({
+        columns: u.columns,
+        ...u.name ? { name: u.name } : {}
+      }));
+      const indexes = (tableState.indexes ?? []).map((i) => ({
+        columns: i.columns,
+        ...i.name ? { name: i.name } : {}
+      }));
+      const foreignKeys = (tableState.foreignKeys ?? []).map((fk) => ({
+        columns: fk.columns,
+        references: fk.references,
+        ...fk.name ? { name: fk.name } : {}
+      }));
+      const table = {
+        columns,
+        uniques,
+        indexes,
+        foreignKeys,
+        ...tableState.primaryKey ? {
+          primaryKey: {
+            columns: tableState.primaryKey,
+            ...tableState.primaryKeyName ? { name: tableState.primaryKeyName } : {}
+          }
+        } : {}
+      };
+      storageTables[tableName] = table;
+    }
+    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 baseMappings = computeMappings(
+      models,
+      storage
+    );
+    const mappings = {
+      ...baseMappings,
+      codecTypes: {},
+      operationTypes: {}
+    };
+    const extensionNamespaces = this.state.extensionNamespaces ?? [];
+    const extensionPacks = { ...this.state.extensionPacks || {} };
+    for (const namespace of extensionNamespaces) {
+      if (!Object.hasOwn(extensionPacks, namespace)) {
+        extensionPacks[namespace] = {};
+      }
+    }
+    const contract = {
+      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: {}
+    };
+    return contract;
+  }
+  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 finalBuilder = result instanceof TableBuilder ? result : tableBuilder;
+    const tableState = finalBuilder.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 finalBuilder = result instanceof ModelBuilder ? result : modelBuilder;
+    const modelState = finalBuilder.build();
+    return new _SqlContractBuilder({
+      ...this.state,
+      models: { ...this.state.models, [name]: modelState }
+    });
+  }
+};
+function defineContract() {
+  return new SqlContractBuilder();
+}
+export {
+  defineContract
+};
+//# sourceMappingURL=contract-builder.js.map

package/dist/exports/contract-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"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":";;;;;AAOA;AAAA,EAIE;AAAA,EACA;AAAA,EAGA;AAAA,EAEA;AAAA,OACK;AAiGP,IAAM,qBAAN,MAAM,4BAkBI,gBAAgF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBxF,QAiBU;AAoBR,QAAI,CAAC,KAAK,MAAM,QAAQ;AACtB,YAAM,IAAI,MAAM,oDAAoD;AAAA,IACtE;AAEA,UAAM,SAAS,KAAK,MAAM;AAE1B,UAAM,gBAAgB,CAAC;AAEvB,eAAW,aAAa,OAAO,KAAK,KAAK,MAAM,MAAM,GAAmC;AACtF,YAAM,aAAa,KAAK,MAAM,OAAO,SAAS;AAC9C,UAAI,CAAC,WAAY;AAMjB,YAAM,UAAU,CAAC;AAOjB,iBAAW,cAAc,WAAW,SAAS;AAC3C,cAAM,cAAc,WAAW,QAAQ,UAAU;AACjD,YAAI,CAAC,YAAa;AAClB,cAAM,UAAU,YAAY;AAC5B,cAAM,aAAa,YAAY;AAE/B,gBAAQ,UAA8B,IAAI;AAAA,UACxC;AAAA,UACA;AAAA,UACA,UAAW,YAAY,YAAY;AAAA,QAErC;AAAA,MAIF;AAGA,YAAM,WAAW,WAAW,WAAW,CAAC,GAAG,IAAI,CAAC,OAAO;AAAA,QACrD,SAAS,EAAE;AAAA,QACX,GAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;AAAA,MACnC,EAAE;AAGF,YAAM,WAAW,WAAW,WAAW,CAAC,GAAG,IAAI,CAAC,OAAO;AAAA,QACrD,SAAS,EAAE;AAAA,QACX,GAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;AAAA,MACnC,EAAE;AAGF,YAAM,eAAe,WAAW,eAAe,CAAC,GAAG,IAAI,CAAC,QAAQ;AAAA,QAC9D,SAAS,GAAG;AAAA,QACZ,YAAY,GAAG;AAAA,QACf,GAAI,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK,IAAI,CAAC;AAAA,MACrC,EAAE;AAEF,YAAM,QAAQ;AAAA,QACZ;AAAA,QAMA;AAAA,QACA;AAAA,QACA;AAAA,QACA,GAAI,WAAW,aACX;AAAA,UACE,YAAY;AAAA,YACV,SAAS,WAAW;AAAA,YACpB,GAAI,WAAW,iBAAiB,EAAE,MAAM,WAAW,eAAe,IAAI,CAAC;AAAA,UACzE;AAAA,QACF,IACA,CAAC;AAAA,MACP;AAEA,MAAC,cAAsD,SAAS,IAAI;AAAA,IACtE;AAEA,UAAM,UAAU,EAAE,QAAQ,cAA4C;AAGtE,UAAM,gBAA8C,CAAC;AAGrD,eAAW,aAAa,KAAK,MAAM,QAAQ;AACzC,YAAM,aAAa,KAAK,MAAM,OAAO,SAAS;AAC9C,UAAI,CAAC,WAAY;AAEjB,YAAM,kBAAkB;AAOxB,YAAM,SAA8C,CAAC;AAGrD,iBAAW,aAAa,gBAAgB,QAAQ;AAC9C,cAAM,aAAa,gBAAgB,OAAO,SAAS;AACnD,YAAI,YAAY;AACd,iBAAO,SAAS,IAAI;AAAA,YAClB,QAAQ;AAAA,UACV;AAAA,QACF;AAAA,MACF;AAGA,MAAC,cAA6D,SAAS,IAAI;AAAA,QACzE,SAAS;AAAA,UACP,OAAO,gBAAgB;AAAA,QACzB;AAAA,QACA;AAAA,QACA,WAAW,CAAC;AAAA,MACd;AAAA,IACF;AAGA,UAAM,mBAAgF,CAAC;AAGvF,eAAW,aAAa,KAAK,MAAM,QAAQ;AACzC,YAAM,aAAa,KAAK,MAAM,OAAO,SAAS;AAC9C,UAAI,CAAC,WAAY;AAEjB,YAAM,kBAAkB;AAOxB,YAAM,YAAY,gBAAgB;AAClC,UAAI,CAAC,UAAW;AAGhB,UAAI,gBAAgB,aAAa,OAAO,KAAK,gBAAgB,SAAS,EAAE,SAAS,GAAG;AAClF,YAAI,CAAC,iBAAiB,SAAS,GAAG;AAChC,2BAAiB,SAAS,IAAI,CAAC;AAAA,QACjC;AAGA,cAAM,iBAAiB,iBAAiB,SAAS;AACjD,YAAI,gBAAgB;AAClB,qBAAW,gBAAgB,gBAAgB,WAAW;AACpD,kBAAM,WAAW,gBAAgB,UAAU,YAAY;AACvD,gBAAI,UAAU;AACZ,6BAAe,YAAY,IAAI;AAAA,YACjC;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,UAAM,SAAS;AAEf,UAAM,eAAe;AAAA,MACnB;AAAA,MACA;AAAA,IACF;AAEA,UAAM,WAAW;AAAA,MACf,GAAG;AAAA,MACH,YAAY,CAAC;AAAA,MACb,gBAAgB,CAAC;AAAA,IACnB;AAEA,UAAM,sBAAsB,KAAK,MAAM,uBAAuB,CAAC;AAC/D,UAAM,iBAA0C,EAAE,GAAI,KAAK,MAAM,kBAAkB,CAAC,EAAG;AACvF,eAAW,aAAa,qBAAqB;AAC3C,UAAI,CAAC,OAAO,OAAO,gBAAgB,SAAS,GAAG;AAC7C,uBAAe,SAAS,IAAI,CAAC;AAAA,MAC/B;AAAA,IACF;AAKA,UAAM,WAAW;AAAA,MACf,eAAe;AAAA,MACf;AAAA,MACA,cAAc;AAAA,MACd,UAAU,KAAK,MAAM,YAAY;AAAA,MACjC;AAAA,MACA,WAAW;AAAA,MACX;AAAA,MACA;AAAA,MACA;AAAA,MACA,cAAc,KAAK,MAAM,gBAAgB,CAAC;AAAA,MAC1C,MAAM,CAAC;AAAA,MACP,SAAS,CAAC;AAAA,IACZ;AAEA,WAAO;AAAA,EAWT;AAAA,EAES,OACP,SAC2F;AAC3F,WAAO,IAAI,oBAQT;AAAA,MACA,GAAG,KAAK;AAAA,MACR,QAAQ,QAAQ;AAAA,IAClB,CAAC;AAAA,EACH;AAAA,EAEA,eACE,OASA;AACA,QAAI,CAAC,KAAK,MAAM,QAAQ;AACtB,YAAM,IAAI,MAAM,uDAAuD;AAAA,IACzE;AAEA,UAAM,aAAa,IAAI,IAAI,KAAK,MAAM,uBAAuB,CAAC,CAAC;AAE/D,eAAW,WAAW,OAAO,OAAO,KAAK,GAAG;AAC1C,UAAI,CAAC,QAAS;AAEd,UAAI,QAAQ,SAAS,aAAa;AAChC,cAAM,IAAI;AAAA,UACR,qEAAqE,QAAQ,IAAI;AAAA,QACnF;AAAA,MACF;AAEA,UAAI,QAAQ,aAAa,OAAO;AAC9B,cAAM,IAAI;AAAA,UACR,mBAAmB,QAAQ,EAAE,qBAAqB,QAAQ,QAAQ;AAAA,QACpE;AAAA,MACF;AAEA,UAAI,QAAQ,YAAY,QAAQ,aAAa,KAAK,MAAM,QAAQ;AAC9D,cAAM,IAAI;AAAA,UACR,mBAAmB,QAAQ,EAAE,cAAc,QAAQ,QAAQ,4BAA4B,KAAK,MAAM,MAAM;AAAA,QAC1G;AAAA,MACF;AAEA,iBAAW,IAAI,QAAQ,EAAE;AAAA,IAC3B;AAEA,WAAO,IAAI,oBAQT;AAAA,MACA,GAAG,KAAK;AAAA,MACR,qBAAqB,CAAC,GAAG,UAAU;AAAA,IACrC,CAAC;AAAA,EACH;AAAA,EAES,aACP,cACqF;AACrF,WAAO,IAAI,oBAAoF;AAAA,MAC7F,GAAG,KAAK;AAAA,MACR;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAES,SACP,MACyF;AACzF,WAAO,IAAI,oBAQT;AAAA,MACA,GAAG,KAAK;AAAA,MACR,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AAAA,EAES,MAQP,MACA,UASA;AACA,UAAM,eAAe,YAAY,IAAI;AACrC,UAAM,SAAS,SAAS,YAAY;AACpC,UAAM,eAAe,kBAAkB,eAAe,SAAS;AAC/D,UAAM,aAAa,aAAa,MAAM;AAEtC,WAAO,IAAI,oBAQT;AAAA,MACA,GAAG,KAAK;AAAA,MACR,QAAQ,EAAE,GAAG,KAAK,MAAM,QAAQ,CAAC,IAAI,GAAG,WAAW;AAAA,IAErD,CAAC;AAAA,EACH;AAAA,EAES,MAUP,MACA,OACA,UAWA;AACA,UAAM,eAAe,IAAI,aAAmC,MAAM,KAAK;AACvE,UAAM,SAAS,SAAS,YAAY;AACpC,UAAM,eAAe,kBAAkB,eAAe,SAAS;AAC/D,UAAM,aAAa,aAAa,MAAM;AAEtC,WAAO,IAAI,oBAQT;AAAA,MACA,GAAG,KAAK;AAAA,MACR,QAAQ,EAAE,GAAG,KAAK,MAAM,QAAQ,CAAC,IAAI,GAAG,WAAW;AAAA,IAErD,CAAC;AAAA,EACH;AACF;AAEO,SAAS,iBAEoB;AAClC,SAAO,IAAI,mBAA+B;AAC5C;","names":[]}

package/dist/exports/contract.d.ts

@@ -0,0 +1,2 @@
+export { computeMappings, validateContract } from '../contract';
+//# sourceMappingURL=contract.d.ts.map

package/dist/exports/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/exports/contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC"}

package/dist/exports/contract.js

@@ -0,0 +1,9 @@
+import {
+  computeMappings,
+  validateContract
+} from "../chunk-HTNUNGA2.js";
+export {
+  computeMappings,
+  validateContract
+};
+//# sourceMappingURL=contract.js.map

package/dist/exports/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,28 +1,24 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.3.0-pr.94.3",
+  "version": "0.3.0-pr.95.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": "0.3.0-pr.94.3",
-    "@prisma-next/contract-authoring": "0.3.0-pr.94.3",
-    "@prisma-next/sql-contract": "0.3.0-pr.94.3"
+    "@prisma-next/contract": "0.3.0-pr.95.2",
+    "@prisma-next/contract-authoring": "0.3.0-pr.95.2",
+    "@prisma-next/sql-contract": "0.3.0-pr.95.2"
   },
   "devDependencies": {
     "@types/pg": "8.16.0",
     "pg": "8.16.3",
-    "tsdown": "0.18.4",
+    "tsup": "8.5.1",
     "typescript": "5.9.3",
     "vitest": "4.0.16",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [
     "dist",
@@ -30,15 +26,21 @@
     "schemas"
   ],
   "exports": {
-    "./contract": "./dist/contract.mjs",
-    "./contract-builder": "./dist/contract-builder.mjs",
-    "./package.json": "./package.json"
+    "./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"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
     "lint": "biome check . --error-on-warnings",
     "lint:fix": "biome check --write .",
     "lint:fix:unsafe": "biome check --write --unsafe .",

package/schemas/data-contract-sql-v1.json

@@ -79,6 +79,13 @@
           "additionalProperties": {
             "$ref": "#/$defs/StorageTable"
           }
+        },
+        "types": {
+          "type": "object",
+          "description": "Named type instances for parameterized/custom types (e.g., vectors, enums)",
+          "additionalProperties": {
+            "$ref": "#/$defs/StorageTypeInstance"
+          }
         }
       },
       "required": ["tables"]
@@ -128,19 +135,54 @@
     },
     "StorageColumn": {
       "type": "object",
-      "description": "Column definition with type and nullability",
+      "description": "Column definition with type, nullability, and optional parameterized type info",
       "additionalProperties": false,
       "properties": {
-        "type": {
+        "nativeType": {
+          "type": "string",
+          "description": "Database-native type (e.g., 'text', 'int4', 'timestamptz', 'vector(1536)')"
+        },
+        "codecId": {
           "type": "string",
-          "description": "Column type (e.g., 'text', 'int4', 'timestamptz', 'bool')"
+          "description": "Codec identifier for encoding/decoding (e.g., 'pg/text@1', 'pg/vector@1')"
         },
         "nullable": {
           "type": "boolean",
           "default": false,
           "description": "Whether the column allows NULL values"
+        },
+        "typeParams": {
+          "type": "object",
+          "description": "Opaque, codec-owned JS/type parameters (e.g., { length: 1536 } for vectors)",
+          "additionalProperties": true
+        },
+        "typeRef": {
+          "type": "string",
+          "description": "Reference to a named type instance in storage.types"
         }
-      }
+      },
+      "required": ["nativeType", "codecId", "nullable"]
+    },
+    "StorageTypeInstance": {
+      "type": "object",
+      "description": "Named, parameterized type instance for reuse across columns",
+      "additionalProperties": false,
+      "properties": {
+        "codecId": {
+          "type": "string",
+          "description": "Codec identifier for encoding/decoding"
+        },
+        "nativeType": {
+          "type": "string",
+          "description": "Database-native type"
+        },
+        "typeParams": {
+          "type": "object",
+          "description": "Codec-owned type parameters",
+          "additionalProperties": true
+        }
+      },
+      "required": ["codecId", "nativeType", "typeParams"]
     },
     "PrimaryKey": {
       "type": "object",

package/src/contract.ts

@@ -11,6 +11,7 @@ import type {
   SqlStorage,
   StorageColumn,
   StorageTable,
+  StorageTypeInstance,
   UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
 import { type } from 'arktype';
@@ -24,6 +25,14 @@ const StorageColumnSchema = type.declare<StorageColumn>().type({
   nativeType: 'string',
   codecId: 'string',
   nullable: 'boolean',
+  'typeParams?': 'Record<string, unknown>',
+  'typeRef?': 'string',
+});
+
+const StorageTypeInstanceSchema = type.declare<StorageTypeInstance>().type({
+  codecId: 'string',
+  nativeType: 'string',
+  typeParams: 'Record<string, unknown>',
 });
 
 const PrimaryKeySchema = type.declare<PrimaryKey>().type({
@@ -62,6 +71,7 @@ const StorageTableSchema = type.declare<StorageTable>().type({
 
 const StorageSchema = type.declare<SqlStorage>().type({
   tables: type({ '[string]': StorageTableSchema }),
+  'types?': type({ '[string]': StorageTypeInstanceSchema }),
 });
 
 const ModelFieldSchema = type.declare<ModelField>().type({
@@ -194,6 +204,45 @@ export function computeMappings(
 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) {
+    for (const [typeName, typeInstance] of Object.entries(storage.types)) {
+      // Validate typeParams is not an array (arrays are objects in JS but not valid here)
+      if (Array.isArray(typeInstance.typeParams)) {
+        throw new Error(
+          `Type instance "${typeName}" has invalid typeParams: must be a plain object, not an array`,
+        );
+      }
+    }
+  }
+
+  // Validate columns in all tables
+  for (const [tableName, table] of Object.entries(storage.tables)) {
+    for (const [columnName, column] of Object.entries(table.columns)) {
+      // Validate typeParams and typeRef are mutually exclusive
+      if (column.typeParams !== undefined && column.typeRef !== undefined) {
+        throw new Error(
+          `Column "${columnName}" in table "${tableName}" has both typeParams and typeRef; these are mutually exclusive`,
+        );
+      }
+
+      // Validate typeParams is not an array (arrays are objects in JS but not valid here)
+      if (column.typeParams !== undefined && Array.isArray(column.typeParams)) {
+        throw new Error(
+          `Column "${columnName}" in table "${tableName}" has invalid typeParams: must be a plain object, not an array`,
+        );
+      }
+
+      // 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 models
   for (const [modelName, modelUnknown] of Object.entries(models)) {