@prisma-next/sql-contract-ts 0.3.0-dev.4 → 0.3.0-dev.6

package/src/contract.ts

@@ -0,0 +1,533 @@
+import type {
+  ForeignKey,
+  ForeignKeyReferences,
+  Index,
+  ModelDefinition,
+  ModelField,
+  ModelStorage,
+  PrimaryKey,
+  SqlContract,
+  SqlMappings,
+  SqlStorage,
+  StorageColumn,
+  StorageTable,
+  UniqueConstraint,
+} from '@prisma-next/sql-contract/types';
+import { type } from 'arktype';
+import type { O } from 'ts-toolbelt';
+
+/**
+ * Structural validation schema for SqlContract using Arktype.
+ * This validates the shape and types of the contract structure.
+ */
+const StorageColumnSchema = type.declare<StorageColumn>().type({
+  nativeType: 'string',
+  codecId: 'string',
+  nullable: 'boolean',
+});
+
+const PrimaryKeySchema = type.declare<PrimaryKey>().type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+});
+
+const UniqueConstraintSchema = type.declare<UniqueConstraint>().type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+});
+
+const IndexSchema = type.declare<Index>().type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+});
+
+const ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({
+  table: 'string',
+  columns: type.string.array().readonly(),
+});
+
+const ForeignKeySchema = type.declare<ForeignKey>().type({
+  columns: type.string.array().readonly(),
+  references: ForeignKeyReferencesSchema,
+  'name?': 'string',
+});
+
+const StorageTableSchema = type.declare<StorageTable>().type({
+  columns: type({ '[string]': StorageColumnSchema }),
+  'primaryKey?': PrimaryKeySchema,
+  uniques: UniqueConstraintSchema.array().readonly(),
+  indexes: IndexSchema.array().readonly(),
+  foreignKeys: ForeignKeySchema.array().readonly(),
+});
+
+const StorageSchema = type.declare<SqlStorage>().type({
+  tables: type({ '[string]': StorageTableSchema }),
+});
+
+const ModelFieldSchema = type.declare<ModelField>().type({
+  column: 'string',
+});
+
+const ModelStorageSchema = type.declare<ModelStorage>().type({
+  table: 'string',
+});
+
+const ModelSchema = type.declare<ModelDefinition>().type({
+  storage: ModelStorageSchema,
+  fields: type({ '[string]': ModelFieldSchema }),
+  relations: type({ '[string]': 'unknown' }),
+});
+
+/**
+ * Complete SqlContract schema for structural validation.
+ * This validates the entire contract structure at once.
+ */
+const 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,
+});
+
+/**
+ * Validates the structural shape of a SqlContract using Arktype.
+ *
+ * **Responsibility: Validation Only**
+ * This function validates that the contract has the correct structure and types.
+ * It does NOT normalize the contract - normalization must happen in the contract builder.
+ *
+ * The contract passed to this function must already be normalized (all required fields present).
+ * If normalization is needed, it should be done by the contract builder before calling this function.
+ *
+ * This ensures all required fields are present and have the correct types.
+ *
+ * @param value - The contract value to validate (typically from a JSON import)
+ * @returns The validated contract if structure is valid
+ * @throws Error if the contract structure is invalid
+ */
+function validateContractStructure<T extends SqlContract<SqlStorage>>(
+  value: unknown,
+): O.Overwrite<T, { targetFamily: 'sql' }> {
+  // Check targetFamily first to provide a clear error message for unsupported target families
+  const rawValue = value as { targetFamily?: string };
+  if (rawValue.targetFamily !== undefined && rawValue.targetFamily !== 'sql') {
+    /* c8 ignore next */
+    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);
+  }
+
+  const contractResult = SqlContractSchema(value);
+
+  if (contractResult instanceof type.errors) {
+    const messages = contractResult.map((p: { message: string }) => p.message).join('; ');
+    throw new Error(`Contract structural validation failed: ${messages}`);
+  }
+
+  // After validation, contractResult matches the schema and preserves the input structure
+  // TypeScript needs an assertion here due to exactOptionalPropertyTypes differences
+  // between Arktype's inferred type and the generic T, but runtime-wise they're compatible
+  return contractResult as O.Overwrite<T, { targetFamily: 'sql' }>;
+}
+
+/**
+ * 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
+ */
+export function computeMappings(
+  models: Record<string, ModelDefinition>,
+  _storage: SqlStorage,
+  existingMappings?: Partial<SqlMappings>,
+): SqlMappings {
+  const modelToTable: Record<string, string> = {};
+  const tableToModel: Record<string, string> = {};
+  const fieldToColumn: Record<string, Record<string, string>> = {};
+  const columnToField: Record<string, Record<string, string>> = {};
+
+  for (const [modelName, model] of Object.entries(models)) {
+    const tableName = model.storage.table;
+    modelToTable[modelName] = tableName;
+    tableToModel[tableName] = modelName;
+
+    const modelFieldToColumn: Record<string, string> = {};
+    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;
+  }
+
+  // Preserve existing mappings if provided, otherwise use computed ones
+  return {
+    modelToTable: existingMappings?.modelToTable ?? modelToTable,
+    tableToModel: existingMappings?.tableToModel ?? tableToModel,
+    fieldToColumn: existingMappings?.fieldToColumn ?? fieldToColumn,
+    columnToField: existingMappings?.columnToField ?? columnToField,
+    codecTypes: existingMappings?.codecTypes ?? {},
+    operationTypes: existingMappings?.operationTypes ?? {},
+  };
+}
+
+/**
+ * Validates logical consistency of a **structurally validated** SqlContract.
+ * This checks that references (e.g., foreign keys, primary keys, uniques) point to storage objects that already exist.
+ * Structural validation is expected to have already completed before this helper runs.
+ *
+ * @param structurallyValidatedContract - The contract whose structure has already been validated
+ * @throws Error if logical validation fails
+ */
+function validateContractLogic(structurallyValidatedContract: SqlContract<SqlStorage>): void {
+  const { storage, models } = structurallyValidatedContract;
+  const tableNames = new Set(Object.keys(storage.tables));
+
+  // Validate models
+  for (const [modelName, modelUnknown] of Object.entries(models)) {
+    const model = modelUnknown as ModelDefinition;
+    // Validate model has storage.table
+    if (!model.storage?.table) {
+      /* c8 ignore next */
+      throw new Error(`Model "${modelName}" is missing storage.table`);
+    }
+
+    const tableName = model.storage.table;
+
+    // Validate model's table exists in storage
+    if (!tableNames.has(tableName)) {
+      /* c8 ignore next */
+      throw new Error(`Model "${modelName}" references non-existent table "${tableName}"`);
+    }
+
+    const table = storage.tables[tableName];
+    if (!table) {
+      /* c8 ignore next */
+      throw new Error(`Model "${modelName}" references non-existent table "${tableName}"`);
+    }
+
+    // Validate model's table has a primary key
+    if (!table.primaryKey) {
+      /* c8 ignore next */
+      throw new Error(`Model "${modelName}" table "${tableName}" is missing a primary key`);
+    }
+
+    const columnNames = new Set(Object.keys(table.columns));
+
+    // Validate model fields
+    if (!model.fields) {
+      /* c8 ignore next */
+      throw new Error(`Model "${modelName}" is missing fields`);
+    }
+
+    for (const [fieldName, fieldUnknown] of Object.entries(model.fields)) {
+      const field = fieldUnknown as { column: string };
+      // Validate field has column property
+      if (!field.column) {
+        /* c8 ignore next */
+        throw new Error(`Model "${modelName}" field "${fieldName}" is missing column property`);
+      }
+
+      // Validate field's column exists in the model's backing table
+      if (!columnNames.has(field.column)) {
+        /* c8 ignore next */
+        throw new Error(
+          `Model "${modelName}" field "${fieldName}" references non-existent column "${field.column}" in table "${tableName}"`,
+        );
+      }
+    }
+
+    // Validate model relations have corresponding foreign keys
+    if (model.relations) {
+      for (const [relationName, relation] of Object.entries(model.relations)) {
+        // For now, we'll do basic validation. Full FK validation can be added later
+        // This would require checking that the relation's on.parentCols/childCols match FKs
+        if (
+          typeof relation === 'object' &&
+          relation !== null &&
+          'on' in relation &&
+          'to' in relation
+        ) {
+          const on = relation.on as { parentCols?: string[]; childCols?: string[] };
+          const cardinality = (relation as { cardinality?: string }).cardinality;
+          if (on.parentCols && on.childCols) {
+            // For 1:N relations, the foreign key is on the child table
+            // For N:1 relations, the foreign key is on the parent table (this table)
+            // For now, we'll skip validation for 1:N relations as the FK is on the child table
+            // and we'll validate it when we process the child model
+            if (cardinality === '1:N') {
+              // Foreign key is on the child table, skip validation here
+              // It will be validated when we process the child model
+              continue;
+            }
+
+            // For N:1 relations, check that there's a foreign key matching this relation
+            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) {
+              /* c8 ignore next */
+              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));
+
+    // Validate primaryKey references existing columns
+    if (table.primaryKey) {
+      for (const colName of table.primaryKey.columns) {
+        if (!columnNames.has(colName)) {
+          /* c8 ignore next */
+          throw new Error(
+            `Table "${tableName}" primaryKey references non-existent column "${colName}"`,
+          );
+        }
+      }
+    }
+
+    // Validate unique constraints reference existing columns
+    for (const unique of table.uniques) {
+      for (const colName of unique.columns) {
+        if (!columnNames.has(colName)) {
+          /* c8 ignore next */
+          throw new Error(
+            `Table "${tableName}" unique constraint references non-existent column "${colName}"`,
+          );
+        }
+      }
+    }
+
+    // Validate indexes reference existing columns
+    for (const index of table.indexes) {
+      for (const colName of index.columns) {
+        if (!columnNames.has(colName)) {
+          /* c8 ignore next */
+          throw new Error(`Table "${tableName}" index references non-existent column "${colName}"`);
+        }
+      }
+    }
+
+    // Validate foreignKeys reference existing tables and columns
+    for (const fk of table.foreignKeys) {
+      // Validate FK columns exist in the referencing table
+      for (const colName of fk.columns) {
+        if (!columnNames.has(colName)) {
+          /* c8 ignore next */
+          throw new Error(
+            `Table "${tableName}" foreignKey references non-existent column "${colName}"`,
+          );
+        }
+      }
+
+      // Validate referenced table exists
+      if (!tableNames.has(fk.references.table)) {
+        /* c8 ignore next */
+        throw new Error(
+          `Table "${tableName}" foreignKey references non-existent table "${fk.references.table}"`,
+        );
+      }
+
+      // Validate referenced columns exist in the referenced table
+      const referencedTable = storage.tables[fk.references.table];
+      if (!referencedTable) {
+        /* c8 ignore next */
+        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)) {
+          /* c8 ignore next */
+          throw new Error(
+            `Table "${tableName}" foreignKey references non-existent column "${colName}" in table "${fk.references.table}"`,
+          );
+        }
+      }
+
+      if (fk.columns.length !== fk.references.columns.length) {
+        /* c8 ignore next */
+        throw new Error(
+          `Table "${tableName}" foreignKey column count (${fk.columns.length}) does not match referenced column count (${fk.references.columns.length})`,
+        );
+      }
+    }
+  }
+}
+
+export function normalizeContract(contract: unknown): SqlContract<SqlStorage> {
+  const contractObj = contract as Record<string, unknown>;
+
+  // Only normalize if storage exists (validation will catch if it's missing)
+  let normalizedStorage = contractObj['storage'];
+  if (normalizedStorage && typeof normalizedStorage === 'object' && normalizedStorage !== null) {
+    const storage = normalizedStorage as Record<string, unknown>;
+    const tables = storage['tables'] as Record<string, unknown> | undefined;
+
+    if (tables) {
+      // Normalize storage tables
+      const normalizedTables: Record<string, unknown> = {};
+      for (const [tableName, table] of Object.entries(tables)) {
+        const tableObj = table as Record<string, unknown>;
+        const columns = tableObj['columns'] as Record<string, unknown> | undefined;
+
+        if (columns) {
+          // Normalize columns: add nullable: false if missing
+          const normalizedColumns: Record<string, unknown> = {};
+          for (const [columnName, column] of Object.entries(columns)) {
+            const columnObj = column as Record<string, unknown>;
+            const normalizedColumn: Record<string, unknown> = {
+              ...columnObj,
+              nullable: columnObj['nullable'] ?? false,
+            };
+
+            normalizedColumns[columnName] = normalizedColumn;
+          }
+
+          // Normalize table arrays: add empty arrays if missing
+          normalizedTables[tableName] = {
+            ...tableObj,
+            columns: normalizedColumns,
+            uniques: tableObj['uniques'] ?? [],
+            indexes: tableObj['indexes'] ?? [],
+            foreignKeys: tableObj['foreignKeys'] ?? [],
+          };
+        } else {
+          normalizedTables[tableName] = tableObj;
+        }
+      }
+
+      normalizedStorage = {
+        ...storage,
+        tables: normalizedTables,
+      };
+    }
+  }
+
+  // Only normalize if models exists (validation will catch if it's missing)
+  let normalizedModels = contractObj['models'];
+  if (normalizedModels && typeof normalizedModels === 'object' && normalizedModels !== null) {
+    const models = normalizedModels as Record<string, unknown>;
+    const normalizedModelsObj: Record<string, unknown> = {};
+    for (const [modelName, model] of Object.entries(models)) {
+      const modelObj = model as Record<string, unknown>;
+      normalizedModelsObj[modelName] = {
+        ...modelObj,
+        relations: modelObj['relations'] ?? {},
+      };
+    }
+    normalizedModels = normalizedModelsObj;
+  }
+
+  // Normalize top-level fields: add empty objects if missing
+  return {
+    ...contractObj,
+    models: normalizedModels,
+    relations: contractObj['relations'] ?? {},
+    storage: normalizedStorage,
+    extensionPacks: contractObj['extensionPacks'] ?? {},
+    capabilities: contractObj['capabilities'] ?? {},
+    meta: contractObj['meta'] ?? {},
+    sources: contractObj['sources'] ?? {},
+  } as SqlContract<SqlStorage>;
+}
+
+/**
+ * Validates that a JSON import conforms to the SqlContract structure
+ * and returns a fully typed SqlContract.
+ *
+ * This function is specifically for validating JSON imports (e.g., from contract.json).
+ * Contracts created via the builder API (defineContract) are already valid and should
+ * not be passed to this function - use them directly without validation.
+ *
+ * Performs both structural validation (using Arktype) and logical validation
+ * (ensuring all references are valid).
+ *
+ *
+ * The type parameter `TContract` must be a fully-typed contract type (e.g., from `contract.d.ts`),
+ * NOT a generic `SqlContract<SqlStorage>`.
+ *
+ * **Correct:**
+ * ```typescript
+ * import type { Contract } from './contract.d';
+ * const contract = validateContract<Contract>(contractJson);
+ * ```
+ *
+ * **Incorrect:**
+ * ```typescript
+ * import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+ * const contract = validateContract<SqlContract<SqlStorage>>(contractJson);
+ * // ❌ Types will be inferred as 'unknown' - this won't work!
+ * ```
+ *
+ * The type parameter provides the specific table structure, column types, and model definitions.
+ * This function validates the runtime structure matches the type, but does not infer types
+ * from JSON (as JSON imports lose literal type information).
+ *
+ * @param value - The contract value to validate (must be from a JSON import, not a builder)
+ * @returns A validated contract matching the TContract type
+ * @throws Error if the contract structure or logic is invalid
+ */
+export function validateContract<TContract extends SqlContract<SqlStorage>>(
+  value: unknown,
+): TContract {
+  // Normalize contract first (add defaults for missing fields)
+  const normalized = normalizeContract(value);
+
+  const structurallyValid = validateContractStructure<SqlContract<SqlStorage>>(normalized);
+
+  const contractForValidation = structurallyValid as SqlContract<SqlStorage>;
+
+  // Validate contract logic (contracts must already have fully qualified type IDs)
+  validateContractLogic(contractForValidation);
+
+  // Extract existing mappings (optional - will be computed if missing)
+  const existingMappings = (contractForValidation as { mappings?: Partial<SqlMappings> }).mappings;
+
+  // Compute mappings from models and storage
+  const mappings = computeMappings(
+    contractForValidation.models as Record<string, ModelDefinition>,
+    contractForValidation.storage,
+    existingMappings,
+  );
+
+  // Add default values for optional metadata fields if missing
+  const contractWithMappings = {
+    ...structurallyValid,
+    models: contractForValidation.models,
+    relations: contractForValidation.relations,
+    storage: contractForValidation.storage,
+    mappings,
+  };
+
+  // Type assertion: The caller provides the strict type via TContract.
+  // We validate the structure matches, but the precise types come from contract.d.ts
+  return contractWithMappings as TContract;
+}

package/src/exports/contract-builder.ts

@@ -0,0 +1,2 @@
+export type { ColumnBuilder } from '../contract-builder';
+export { defineContract } from '../contract-builder';

package/src/exports/contract.ts

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

package/dist/exports/chunk-D7LVQQYU.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/contract.ts"],"sourcesContent":["import type {\n  ForeignKey,\n  ForeignKeyReferences,\n  Index,\n  ModelDefinition,\n  ModelField,\n  ModelStorage,\n  PrimaryKey,\n  SqlContract,\n  SqlMappings,\n  SqlStorage,\n  StorageColumn,\n  StorageTable,\n  UniqueConstraint,\n} from '@prisma-next/sql-contract/types';\nimport { type } from 'arktype';\nimport type { O } from 'ts-toolbelt';\n\n/**\n * Structural validation schema for SqlContract using Arktype.\n * This validates the shape and types of the contract structure.\n */\nconst StorageColumnSchema = type.declare<StorageColumn>().type({\n  nativeType: 'string',\n  codecId: 'string',\n  nullable: 'boolean',\n});\n\nconst PrimaryKeySchema = type.declare<PrimaryKey>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst UniqueConstraintSchema = type.declare<UniqueConstraint>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst IndexSchema = type.declare<Index>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({\n  table: 'string',\n  columns: type.string.array().readonly(),\n});\n\nconst ForeignKeySchema = type.declare<ForeignKey>().type({\n  columns: type.string.array().readonly(),\n  references: ForeignKeyReferencesSchema,\n  'name?': 'string',\n});\n\nconst StorageTableSchema = type.declare<StorageTable>().type({\n  columns: type({ '[string]': StorageColumnSchema }),\n  'primaryKey?': PrimaryKeySchema,\n  uniques: UniqueConstraintSchema.array().readonly(),\n  indexes: IndexSchema.array().readonly(),\n  foreignKeys: ForeignKeySchema.array().readonly(),\n});\n\nconst StorageSchema = type.declare<SqlStorage>().type({\n  tables: type({ '[string]': StorageTableSchema }),\n});\n\nconst ModelFieldSchema = type.declare<ModelField>().type({\n  column: 'string',\n});\n\nconst ModelStorageSchema = type.declare<ModelStorage>().type({\n  table: 'string',\n});\n\nconst ModelSchema = type.declare<ModelDefinition>().type({\n  storage: ModelStorageSchema,\n  fields: type({ '[string]': ModelFieldSchema }),\n  relations: type({ '[string]': 'unknown' }),\n});\n\n/**\n * Complete SqlContract schema for structural validation.\n * This validates the entire contract structure at once.\n */\nconst SqlContractSchema = type({\n  'schemaVersion?': \"'1'\",\n  target: 'string',\n  targetFamily: \"'sql'\",\n  coreHash: 'string',\n  'profileHash?': 'string',\n  'capabilities?': 'Record<string, Record<string, boolean>>',\n  'extensionPacks?': 'Record<string, unknown>',\n  'meta?': 'Record<string, unknown>',\n  'sources?': 'Record<string, unknown>',\n  models: type({ '[string]': ModelSchema }),\n  storage: StorageSchema,\n});\n\n/**\n * Validates the structural shape of a SqlContract using Arktype.\n *\n * **Responsibility: Validation Only**\n * This function validates that the contract has the correct structure and types.\n * It does NOT normalize the contract - normalization must happen in the contract builder.\n *\n * The contract passed to this function must already be normalized (all required fields present).\n * If normalization is needed, it should be done by the contract builder before calling this function.\n *\n * This ensures all required fields are present and have the correct types.\n *\n * @param value - The contract value to validate (typically from a JSON import)\n * @returns The validated contract if structure is valid\n * @throws Error if the contract structure is invalid\n */\nfunction validateContractStructure<T extends SqlContract<SqlStorage>>(\n  value: unknown,\n): O.Overwrite<T, { targetFamily: 'sql' }> {\n  // Check targetFamily first to provide a clear error message for unsupported target families\n  const rawValue = value as { targetFamily?: string };\n  if (rawValue.targetFamily !== undefined && rawValue.targetFamily !== 'sql') {\n    /* c8 ignore next */\n    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);\n  }\n\n  const contractResult = SqlContractSchema(value);\n\n  if (contractResult instanceof type.errors) {\n    const messages = contractResult.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Contract structural validation failed: ${messages}`);\n  }\n\n  // After validation, contractResult matches the schema and preserves the input structure\n  // TypeScript needs an assertion here due to exactOptionalPropertyTypes differences\n  // between Arktype's inferred type and the generic T, but runtime-wise they're compatible\n  return contractResult as O.Overwrite<T, { targetFamily: 'sql' }>;\n}\n\n/**\n * Computes mapping dictionaries from models and storage structures.\n * Assumes valid input - validation happens separately in validateContractLogic().\n *\n * @param models - Models object from contract\n * @param storage - Storage object from contract\n * @param existingMappings - Existing mappings from contract input (optional)\n * @returns Computed mappings dictionary\n */\nexport function computeMappings(\n  models: Record<string, ModelDefinition>,\n  _storage: SqlStorage,\n  existingMappings?: Partial<SqlMappings>,\n): SqlMappings {\n  const modelToTable: Record<string, string> = {};\n  const tableToModel: Record<string, string> = {};\n  const fieldToColumn: Record<string, Record<string, string>> = {};\n  const columnToField: Record<string, Record<string, string>> = {};\n\n  for (const [modelName, model] of Object.entries(models)) {\n    const tableName = model.storage.table;\n    modelToTable[modelName] = tableName;\n    tableToModel[tableName] = modelName;\n\n    const modelFieldToColumn: Record<string, string> = {};\n    for (const [fieldName, field] of Object.entries(model.fields)) {\n      const columnName = field.column;\n      modelFieldToColumn[fieldName] = columnName;\n\n      if (!columnToField[tableName]) {\n        columnToField[tableName] = {};\n      }\n      columnToField[tableName][columnName] = fieldName;\n    }\n    fieldToColumn[modelName] = modelFieldToColumn;\n  }\n\n  // Preserve existing mappings if provided, otherwise use computed ones\n  return {\n    modelToTable: existingMappings?.modelToTable ?? modelToTable,\n    tableToModel: existingMappings?.tableToModel ?? tableToModel,\n    fieldToColumn: existingMappings?.fieldToColumn ?? fieldToColumn,\n    columnToField: existingMappings?.columnToField ?? columnToField,\n    codecTypes: existingMappings?.codecTypes ?? {},\n    operationTypes: existingMappings?.operationTypes ?? {},\n  };\n}\n\n/**\n * Validates logical consistency of a **structurally validated** SqlContract.\n * This checks that references (e.g., foreign keys, primary keys, uniques) point to storage objects that already exist.\n * Structural validation is expected to have already completed before this helper runs.\n *\n * @param structurallyValidatedContract - The contract whose structure has already been validated\n * @throws Error if logical validation fails\n */\nfunction validateContractLogic(structurallyValidatedContract: SqlContract<SqlStorage>): void {\n  const { storage, models } = structurallyValidatedContract;\n  const tableNames = new Set(Object.keys(storage.tables));\n\n  // Validate models\n  for (const [modelName, modelUnknown] of Object.entries(models)) {\n    const model = modelUnknown as ModelDefinition;\n    // Validate model has storage.table\n    if (!model.storage?.table) {\n      /* c8 ignore next */\n      throw new Error(`Model \"${modelName}\" is missing storage.table`);\n    }\n\n    const tableName = model.storage.table;\n\n    // Validate model's table exists in storage\n    if (!tableNames.has(tableName)) {\n      /* c8 ignore next */\n      throw new Error(`Model \"${modelName}\" references non-existent table \"${tableName}\"`);\n    }\n\n    const table = storage.tables[tableName];\n    if (!table) {\n      /* c8 ignore next */\n      throw new Error(`Model \"${modelName}\" references non-existent table \"${tableName}\"`);\n    }\n\n    // Validate model's table has a primary key\n    if (!table.primaryKey) {\n      /* c8 ignore next */\n      throw new Error(`Model \"${modelName}\" table \"${tableName}\" is missing a primary key`);\n    }\n\n    const columnNames = new Set(Object.keys(table.columns));\n\n    // Validate model fields\n    if (!model.fields) {\n      /* c8 ignore next */\n      throw new Error(`Model \"${modelName}\" is missing fields`);\n    }\n\n    for (const [fieldName, fieldUnknown] of Object.entries(model.fields)) {\n      const field = fieldUnknown as { column: string };\n      // Validate field has column property\n      if (!field.column) {\n        /* c8 ignore next */\n        throw new Error(`Model \"${modelName}\" field \"${fieldName}\" is missing column property`);\n      }\n\n      // Validate field's column exists in the model's backing table\n      if (!columnNames.has(field.column)) {\n        /* c8 ignore next */\n        throw new Error(\n          `Model \"${modelName}\" field \"${fieldName}\" references non-existent column \"${field.column}\" in table \"${tableName}\"`,\n        );\n      }\n    }\n\n    // Validate model relations have corresponding foreign keys\n    if (model.relations) {\n      for (const [relationName, relation] of Object.entries(model.relations)) {\n        // For now, we'll do basic validation. Full FK validation can be added later\n        // This would require checking that the relation's on.parentCols/childCols match FKs\n        if (\n          typeof relation === 'object' &&\n          relation !== null &&\n          'on' in relation &&\n          'to' in relation\n        ) {\n          const on = relation.on as { parentCols?: string[]; childCols?: string[] };\n          const cardinality = (relation as { cardinality?: string }).cardinality;\n          if (on.parentCols && on.childCols) {\n            // For 1:N relations, the foreign key is on the child table\n            // For N:1 relations, the foreign key is on the parent table (this table)\n            // For now, we'll skip validation for 1:N relations as the FK is on the child table\n            // and we'll validate it when we process the child model\n            if (cardinality === '1:N') {\n              // Foreign key is on the child table, skip validation here\n              // It will be validated when we process the child model\n              continue;\n            }\n\n            // For N:1 relations, check that there's a foreign key matching this relation\n            const hasMatchingFk = table.foreignKeys?.some((fk) => {\n              return (\n                fk.columns.length === on.childCols?.length &&\n                fk.columns.every((col, i) => col === on.childCols?.[i]) &&\n                fk.references.table &&\n                fk.references.columns.length === on.parentCols?.length &&\n                fk.references.columns.every((col, i) => col === on.parentCols?.[i])\n              );\n            });\n\n            if (!hasMatchingFk) {\n              /* c8 ignore next */\n              throw new Error(\n                `Model \"${modelName}\" relation \"${relationName}\" does not have a corresponding foreign key in table \"${tableName}\"`,\n              );\n            }\n          }\n        }\n      }\n    }\n  }\n\n  for (const [tableName, table] of Object.entries(storage.tables)) {\n    const columnNames = new Set(Object.keys(table.columns));\n\n    // Validate primaryKey references existing columns\n    if (table.primaryKey) {\n      for (const colName of table.primaryKey.columns) {\n        if (!columnNames.has(colName)) {\n          /* c8 ignore next */\n          throw new Error(\n            `Table \"${tableName}\" primaryKey references non-existent column \"${colName}\"`,\n          );\n        }\n      }\n    }\n\n    // Validate unique constraints reference existing columns\n    for (const unique of table.uniques) {\n      for (const colName of unique.columns) {\n        if (!columnNames.has(colName)) {\n          /* c8 ignore next */\n          throw new Error(\n            `Table \"${tableName}\" unique constraint references non-existent column \"${colName}\"`,\n          );\n        }\n      }\n    }\n\n    // Validate indexes reference existing columns\n    for (const index of table.indexes) {\n      for (const colName of index.columns) {\n        if (!columnNames.has(colName)) {\n          /* c8 ignore next */\n          throw new Error(`Table \"${tableName}\" index references non-existent column \"${colName}\"`);\n        }\n      }\n    }\n\n    // Validate foreignKeys reference existing tables and columns\n    for (const fk of table.foreignKeys) {\n      // Validate FK columns exist in the referencing table\n      for (const colName of fk.columns) {\n        if (!columnNames.has(colName)) {\n          /* c8 ignore next */\n          throw new Error(\n            `Table \"${tableName}\" foreignKey references non-existent column \"${colName}\"`,\n          );\n        }\n      }\n\n      // Validate referenced table exists\n      if (!tableNames.has(fk.references.table)) {\n        /* c8 ignore next */\n        throw new Error(\n          `Table \"${tableName}\" foreignKey references non-existent table \"${fk.references.table}\"`,\n        );\n      }\n\n      // Validate referenced columns exist in the referenced table\n      const referencedTable = storage.tables[fk.references.table];\n      if (!referencedTable) {\n        /* c8 ignore next */\n        throw new Error(\n          `Table \"${tableName}\" foreignKey references non-existent table \"${fk.references.table}\"`,\n        );\n      }\n      const referencedColumnNames = new Set(Object.keys(referencedTable.columns));\n\n      for (const colName of fk.references.columns) {\n        if (!referencedColumnNames.has(colName)) {\n          /* c8 ignore next */\n          throw new Error(\n            `Table \"${tableName}\" foreignKey references non-existent column \"${colName}\" in table \"${fk.references.table}\"`,\n          );\n        }\n      }\n\n      if (fk.columns.length !== fk.references.columns.length) {\n        /* c8 ignore next */\n        throw new Error(\n          `Table \"${tableName}\" foreignKey column count (${fk.columns.length}) does not match referenced column count (${fk.references.columns.length})`,\n        );\n      }\n    }\n  }\n}\n\nexport function normalizeContract(contract: unknown): SqlContract<SqlStorage> {\n  const contractObj = contract as Record<string, unknown>;\n\n  // Only normalize if storage exists (validation will catch if it's missing)\n  let normalizedStorage = contractObj['storage'];\n  if (normalizedStorage && typeof normalizedStorage === 'object' && normalizedStorage !== null) {\n    const storage = normalizedStorage as Record<string, unknown>;\n    const tables = storage['tables'] as Record<string, unknown> | undefined;\n\n    if (tables) {\n      // Normalize storage tables\n      const normalizedTables: Record<string, unknown> = {};\n      for (const [tableName, table] of Object.entries(tables)) {\n        const tableObj = table as Record<string, unknown>;\n        const columns = tableObj['columns'] as Record<string, unknown> | undefined;\n\n        if (columns) {\n          // Normalize columns: add nullable: false if missing\n          const normalizedColumns: Record<string, unknown> = {};\n          for (const [columnName, column] of Object.entries(columns)) {\n            const columnObj = column as Record<string, unknown>;\n            const normalizedColumn: Record<string, unknown> = {\n              ...columnObj,\n              nullable: columnObj['nullable'] ?? false,\n            };\n\n            normalizedColumns[columnName] = normalizedColumn;\n          }\n\n          // Normalize table arrays: add empty arrays if missing\n          normalizedTables[tableName] = {\n            ...tableObj,\n            columns: normalizedColumns,\n            uniques: tableObj['uniques'] ?? [],\n            indexes: tableObj['indexes'] ?? [],\n            foreignKeys: tableObj['foreignKeys'] ?? [],\n          };\n        } else {\n          normalizedTables[tableName] = tableObj;\n        }\n      }\n\n      normalizedStorage = {\n        ...storage,\n        tables: normalizedTables,\n      };\n    }\n  }\n\n  // Only normalize if models exists (validation will catch if it's missing)\n  let normalizedModels = contractObj['models'];\n  if (normalizedModels && typeof normalizedModels === 'object' && normalizedModels !== null) {\n    const models = normalizedModels as Record<string, unknown>;\n    const normalizedModelsObj: Record<string, unknown> = {};\n    for (const [modelName, model] of Object.entries(models)) {\n      const modelObj = model as Record<string, unknown>;\n      normalizedModelsObj[modelName] = {\n        ...modelObj,\n        relations: modelObj['relations'] ?? {},\n      };\n    }\n    normalizedModels = normalizedModelsObj;\n  }\n\n  // Normalize top-level fields: add empty objects if missing\n  return {\n    ...contractObj,\n    models: normalizedModels,\n    relations: contractObj['relations'] ?? {},\n    storage: normalizedStorage,\n    extensionPacks: contractObj['extensionPacks'] ?? {},\n    capabilities: contractObj['capabilities'] ?? {},\n    meta: contractObj['meta'] ?? {},\n    sources: contractObj['sources'] ?? {},\n  } as SqlContract<SqlStorage>;\n}\n\n/**\n * Validates that a JSON import conforms to the SqlContract structure\n * and returns a fully typed SqlContract.\n *\n * This function is specifically for validating JSON imports (e.g., from contract.json).\n * Contracts created via the builder API (defineContract) are already valid and should\n * not be passed to this function - use them directly without validation.\n *\n * Performs both structural validation (using Arktype) and logical validation\n * (ensuring all references are valid).\n *\n *\n * The type parameter `TContract` must be a fully-typed contract type (e.g., from `contract.d.ts`),\n * NOT a generic `SqlContract<SqlStorage>`.\n *\n * **Correct:**\n * ```typescript\n * import type { Contract } from './contract.d';\n * const contract = validateContract<Contract>(contractJson);\n * ```\n *\n * **Incorrect:**\n * ```typescript\n * import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';\n * const contract = validateContract<SqlContract<SqlStorage>>(contractJson);\n * // ❌ Types will be inferred as 'unknown' - this won't work!\n * ```\n *\n * The type parameter provides the specific table structure, column types, and model definitions.\n * This function validates the runtime structure matches the type, but does not infer types\n * from JSON (as JSON imports lose literal type information).\n *\n * @param value - The contract value to validate (must be from a JSON import, not a builder)\n * @returns A validated contract matching the TContract type\n * @throws Error if the contract structure or logic is invalid\n */\nexport function validateContract<TContract extends SqlContract<SqlStorage>>(\n  value: unknown,\n): TContract {\n  // Normalize contract first (add defaults for missing fields)\n  const normalized = normalizeContract(value);\n\n  const structurallyValid = validateContractStructure<SqlContract<SqlStorage>>(normalized);\n\n  const contractForValidation = structurallyValid as SqlContract<SqlStorage>;\n\n  // Validate contract logic (contracts must already have fully qualified type IDs)\n  validateContractLogic(contractForValidation);\n\n  // Extract existing mappings (optional - will be computed if missing)\n  const existingMappings = (contractForValidation as { mappings?: Partial<SqlMappings> }).mappings;\n\n  // Compute mappings from models and storage\n  const mappings = computeMappings(\n    contractForValidation.models as Record<string, ModelDefinition>,\n    contractForValidation.storage,\n    existingMappings,\n  );\n\n  // Add default values for optional metadata fields if missing\n  const contractWithMappings = {\n    ...structurallyValid,\n    models: contractForValidation.models,\n    relations: contractForValidation.relations,\n    storage: contractForValidation.storage,\n    mappings,\n  };\n\n  // Type assertion: The caller provides the strict type via TContract.\n  // We validate the structure matches, but the precise types come from contract.d.ts\n  return contractWithMappings as TContract;\n}\n"],"mappings":"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","names":[]}