@prisma-next/sql-contract 0.3.0-dev.135 → 0.3.0-dev.146

package/src/validate.ts

@@ -1,52 +1,63 @@
-import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';
-import { isTaggedBigInt, isTaggedRaw } from '@prisma-next/contract/types';
-import type { DomainContractShape, DomainModelShape } from '@prisma-next/contract/validate-domain';
-import { validateContractDomain } from '@prisma-next/contract/validate-domain';
-import { constructContract } from './construct';
-import type { SqlContract, SqlStorage, StorageColumn, StorageTable } from './types';
-import { applyFkDefaults } from './types';
+import type {
+  ColumnDefaultLiteralInputValue,
+  Contract,
+  ContractField,
+  ContractModel,
+  JsonValue,
+} from '@prisma-next/contract/types';
+import {
+  ContractValidationError,
+  validateContract as frameworkValidateContract,
+} from '@prisma-next/contract/validate-contract';
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type { SqlModelStorage, SqlStorage, StorageColumn, StorageTable } from './types';
 import { validateSqlContract, validateStorageSemantics } from './validators';
 
-function extractDomainShape(contract: SqlContract<SqlStorage>): DomainContractShape {
-  return {
-    roots: contract.roots,
-    models: contract.models as Record<string, DomainModelShape>,
-  };
-}
+type SqlValidationContract = Contract<SqlStorage, Record<string, ContractModel<SqlModelStorage>>>;
 
-function validateModelStorageReferences(contract: SqlContract<SqlStorage>): void {
-  const models = contract.models as Record<
-    string,
-    { storage?: { table?: string; fields?: Record<string, { column?: string }> } }
-  >;
-
-  for (const [modelName, model] of Object.entries(models)) {
-    const storageTable = model.storage?.table;
-    if (!storageTable) continue;
+function validateModelStorageReferences(contract: SqlValidationContract): void {
+  for (const [modelName, model] of Object.entries(contract.models)) {
+    const storageTable = model.storage.table;
 
     const table = contract.storage.tables[storageTable] as
       | (typeof contract.storage.tables)[string]
       | undefined;
     if (!table) {
-      throw new Error(`Model "${modelName}" references non-existent table "${storageTable}"`);
+      throw new ContractValidationError(
+        `Model "${modelName}" references non-existent table "${storageTable}"`,
+        'storage',
+      );
     }
 
-    const storageFields = model.storage?.fields;
-    if (!storageFields) continue;
-
     const columnNames = new Set(Object.keys(table.columns));
-    for (const [fieldName, field] of Object.entries(storageFields)) {
-      const column = field.column;
-      if (column && !columnNames.has(column)) {
-        throw new Error(
-          `Model "${modelName}" field "${fieldName}" references non-existent column "${column}" in table "${storageTable}"`,
+    for (const [fieldName, field] of Object.entries(model.storage.fields)) {
+      if (!columnNames.has(field.column)) {
+        throw new ContractValidationError(
+          `Model "${modelName}" field "${fieldName}" references non-existent column "${field.column}" in table "${storageTable}"`,
+          'storage',
+        );
+      }
+    }
+
+    const JSON_NATIVE_TYPES = new Set(['json', 'jsonb']);
+    for (const [fieldName, domainField] of Object.entries(model.fields)) {
+      const f = domainField as ContractField;
+      if (f.type?.kind !== 'valueObject') continue;
+      const storageField = model.storage.fields[fieldName];
+      if (!storageField) continue;
+      const column = table.columns[storageField.column];
+      if (!column) continue;
+      if (!JSON_NATIVE_TYPES.has(column.nativeType)) {
+        throw new ContractValidationError(
+          `Model "${modelName}" field "${fieldName}" is a value object but storage column "${storageField.column}" has nativeType "${column.nativeType}" (expected json or jsonb)`,
+          'storage',
         );
       }
     }
   }
 }
 
-function validateContractLogic(contract: SqlContract<SqlStorage>): void {
+function validateContractLogic(contract: Contract<SqlStorage>): void {
   const tableNames = new Set(Object.keys(contract.storage.tables));
 
   for (const [tableName, table] of Object.entries(contract.storage.tables)) {
@@ -55,8 +66,9 @@ function validateContractLogic(contract: SqlContract<SqlStorage>): void {
     if (table.primaryKey) {
       for (const colName of table.primaryKey.columns) {
         if (!columnNames.has(colName)) {
-          throw new Error(
+          throw new ContractValidationError(
             `Table "${tableName}" primaryKey references non-existent column "${colName}"`,
+            'storage',
           );
         }
       }
@@ -65,8 +77,9 @@ function validateContractLogic(contract: SqlContract<SqlStorage>): void {
     for (const unique of table.uniques) {
       for (const colName of unique.columns) {
         if (!columnNames.has(colName)) {
-          throw new Error(
+          throw new ContractValidationError(
             `Table "${tableName}" unique constraint references non-existent column "${colName}"`,
+            'storage',
           );
         }
       }
@@ -75,15 +88,19 @@ function validateContractLogic(contract: SqlContract<SqlStorage>): void {
     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}"`);
+          throw new ContractValidationError(
+            `Table "${tableName}" index references non-existent column "${colName}"`,
+            'storage',
+          );
         }
       }
     }
 
     for (const [colName, column] of Object.entries(table.columns)) {
       if (!column.nullable && column.default?.kind === 'literal' && column.default.value === null) {
-        throw new Error(
+        throw new ContractValidationError(
           `Table "${tableName}" column "${colName}" is NOT NULL but has a literal null default`,
+          'storage',
         );
       }
     }
@@ -91,76 +108,59 @@ function validateContractLogic(contract: SqlContract<SqlStorage>): void {
     for (const fk of table.foreignKeys) {
       for (const colName of fk.columns) {
         if (!columnNames.has(colName)) {
-          throw new Error(
+          throw new ContractValidationError(
             `Table "${tableName}" foreignKey references non-existent column "${colName}"`,
+            'storage',
           );
         }
       }
 
       if (!tableNames.has(fk.references.table)) {
-        throw new Error(
+        throw new ContractValidationError(
           `Table "${tableName}" foreignKey references non-existent table "${fk.references.table}"`,
+          'storage',
         );
       }
 
-      const referencedTable = contract.storage.tables[
-        fk.references.table
-      ] as (typeof contract.storage.tables)[string];
+      const referencedTable = contract.storage.tables[fk.references.table];
+      if (!referencedTable) continue;
       const referencedColumnNames = new Set(Object.keys(referencedTable.columns));
       for (const colName of fk.references.columns) {
         if (!referencedColumnNames.has(colName)) {
-          throw new Error(
+          throw new ContractValidationError(
             `Table "${tableName}" foreignKey references non-existent column "${colName}" in table "${fk.references.table}"`,
+            'storage',
           );
         }
       }
 
       if (fk.columns.length !== fk.references.columns.length) {
-        throw new Error(
+        throw new ContractValidationError(
           `Table "${tableName}" foreignKey column count (${fk.columns.length}) does not match referenced column count (${fk.references.columns.length})`,
+          'storage',
         );
       }
     }
   }
 }
 
-const BIGINT_NATIVE_TYPES = new Set(['bigint', 'int8']);
-
-export function isBigIntColumn(column: StorageColumn): boolean {
-  const nativeType = column.nativeType?.toLowerCase() ?? '';
-  if (BIGINT_NATIVE_TYPES.has(nativeType)) return true;
-  const codecId = column.codecId?.toLowerCase() ?? '';
-  return codecId.includes('int8') || codecId.includes('bigint');
-}
-
-export function decodeDefaultLiteralValue(
-  value: ColumnDefaultLiteralInputValue,
-  column: StorageColumn,
-  tableName: string,
-  columnName: string,
-): ColumnDefaultLiteralInputValue {
-  if (value instanceof Date) {
-    return value;
-  }
-  if (isTaggedRaw(value)) {
-    return value.value;
-  }
-  if (isTaggedBigInt(value)) {
-    if (!isBigIntColumn(column)) {
-      return value;
-    }
-    try {
-      return BigInt(value.value);
-    } catch {
-      throw new Error(
-        `Invalid tagged bigint for default value on "${tableName}.${columnName}": "${value.value}" is not a valid integer`,
-      );
-    }
+function validateSqlStorage(contract: Contract): void {
+  const sqlContract = validateSqlContract<SqlValidationContract>(contract);
+  validateContractLogic(sqlContract);
+  validateModelStorageReferences(sqlContract);
+  const semanticErrors = validateStorageSemantics(sqlContract.storage);
+  if (semanticErrors.length > 0) {
+    throw new ContractValidationError(
+      `Contract semantic validation failed: ${semanticErrors.join('; ')}`,
+      'storage',
+    );
   }
-  return value;
 }
 
-export function decodeContractDefaults<T extends SqlContract<SqlStorage>>(contract: T): T {
+function decodeContractDefaults<T extends Contract<SqlStorage>>(
+  contract: T,
+  codecLookup: CodecLookup,
+): T {
   const tables = contract.storage.tables;
   let tablesChanged = false;
   const decodedTables: Record<string, StorageTable> = {};
@@ -171,19 +171,19 @@ export function decodeContractDefaults<T extends SqlContract<SqlStorage>>(contra
 
     for (const [columnName, column] of Object.entries(table.columns)) {
       if (column.default?.kind === 'literal') {
-        const decodedValue = decodeDefaultLiteralValue(
-          column.default.value,
-          column,
-          tableName,
-          columnName,
-        );
-        if (decodedValue !== column.default.value) {
-          columnsChanged = true;
-          decodedColumns[columnName] = {
-            ...column,
-            default: { kind: 'literal', value: decodedValue },
-          };
-          continue;
+        const codec = codecLookup.get(column.codecId);
+        if (codec) {
+          const decodedValue = codec.decodeJson(
+            column.default.value as JsonValue,
+          ) as ColumnDefaultLiteralInputValue;
+          if (decodedValue !== column.default.value) {
+            columnsChanged = true;
+            decodedColumns[columnName] = {
+              ...column,
+              default: { kind: 'literal', value: decodedValue },
+            };
+            continue;
+          }
         }
       }
       decodedColumns[columnName] = column;
@@ -210,122 +210,18 @@ export function decodeContractDefaults<T extends SqlContract<SqlStorage>>(contra
   } as T;
 }
 
-function normalizeStorage(contractObj: Record<string, unknown>): Record<string, unknown> {
-  const normalizedStorage = contractObj['storage'];
-  if (!normalizedStorage || typeof normalizedStorage !== 'object')
-    return normalizedStorage as Record<string, unknown>;
-
-  const storage = normalizedStorage as Record<string, unknown>;
-  const tables = storage['tables'] as Record<string, unknown> | undefined;
-  if (!tables) return storage;
-
-  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) {
-      const normalizedColumns: Record<string, unknown> = {};
-      for (const [columnName, column] of Object.entries(columns)) {
-        const columnObj = column as Record<string, unknown>;
-        normalizedColumns[columnName] = {
-          ...columnObj,
-          nullable: columnObj['nullable'] ?? false,
-        };
-      }
-
-      const rawForeignKeys = (tableObj['foreignKeys'] ?? []) as Array<Record<string, unknown>>;
-      const normalizedForeignKeys = rawForeignKeys.map((fk) => ({
-        ...fk,
-        ...applyFkDefaults({
-          constraint: typeof fk['constraint'] === 'boolean' ? fk['constraint'] : undefined,
-          index: typeof fk['index'] === 'boolean' ? fk['index'] : undefined,
-        }),
-      }));
-
-      normalizedTables[tableName] = {
-        ...tableObj,
-        columns: normalizedColumns,
-        uniques: tableObj['uniques'] ?? [],
-        indexes: tableObj['indexes'] ?? [],
-        foreignKeys: normalizedForeignKeys,
-      };
-    } else {
-      normalizedTables[tableName] = tableObj;
-    }
-  }
-
-  return { ...storage, tables: normalizedTables };
-}
-
-function normalizeModels(
-  models: Record<string, Record<string, unknown>>,
-): Record<string, Record<string, unknown>> {
-  const normalized: Record<string, Record<string, unknown>> = {};
-  for (const [modelName, model] of Object.entries(models)) {
-    normalized[modelName] = {
-      ...model,
-      relations: model['relations'] ?? {},
-    };
-  }
-  return normalized;
-}
-
-export function normalizeContract(contract: unknown): SqlContract<SqlStorage> {
-  if (typeof contract !== 'object' || contract === null) {
-    return contract as SqlContract<SqlStorage>;
-  }
-
-  const contractObj = contract as Record<string, unknown>;
-  const normalizedStorage = normalizeStorage(contractObj);
-
-  const rawModels = contractObj['models'];
-  const models =
-    rawModels && typeof rawModels === 'object' && rawModels !== null
-      ? normalizeModels(rawModels as Record<string, Record<string, unknown>>)
-      : (rawModels ?? {});
-
-  const pick = (key: string) =>
-    key in contractObj && contractObj[key] !== undefined ? { [key]: contractObj[key] } : {};
-
-  return {
-    ...pick('schemaVersion'),
-    target: contractObj['target'],
-    targetFamily: contractObj['targetFamily'],
-    ...pick('coreHash'),
-    storageHash: contractObj['storageHash'],
-    ...pick('executionHash'),
-    ...pick('profileHash'),
-    ...pick('_generated'),
-    roots: contractObj['roots'] ?? {},
-    models,
-    storage: normalizedStorage,
-    extensionPacks: contractObj['extensionPacks'] ?? {},
-    capabilities: contractObj['capabilities'] ?? {},
-    meta: contractObj['meta'] ?? {},
-    sources: contractObj['sources'] ?? {},
-    ...pick('execution'),
-  } as SqlContract<SqlStorage>;
-}
-
-export function validateContract<TContract extends SqlContract<SqlStorage>>(
+export function validateContract<TContract extends Contract<SqlStorage>>(
   value: unknown,
+  codecLookup: CodecLookup,
 ): TContract {
-  const normalized = normalizeContract(value);
-
-  const structurallyValid = validateSqlContract<SqlContract<SqlStorage>>(normalized);
-
-  validateContractDomain(extractDomainShape(structurallyValid));
-
-  validateContractLogic(structurallyValid);
-
-  validateModelStorageReferences(structurallyValid);
-
-  const semanticErrors = validateStorageSemantics(structurallyValid.storage);
-  if (semanticErrors.length > 0) {
-    throw new Error(`Contract semantic validation failed: ${semanticErrors.join('; ')}`);
+  const validated = frameworkValidateContract<TContract>(value, validateSqlStorage);
+  try {
+    return decodeContractDefaults(validated, codecLookup);
+  } catch (error) {
+    if (error instanceof ContractValidationError) throw error;
+    throw new ContractValidationError(
+      error instanceof Error ? error.message : String(error),
+      'storage',
+    );
   }
-
-  const constructed = constructContract<TContract>(structurallyValid);
-  return decodeContractDefaults(constructed) as TContract;
 }

package/src/validators.ts

@@ -1,10 +1,11 @@
+import type { Contract } from '@prisma-next/contract/types';
+import { ContractValidationError } from '@prisma-next/contract/validate-contract';
 import { type } from 'arktype';
 import type {
   ForeignKey,
   ForeignKeyReferences,
   PrimaryKey,
   ReferentialAction,
-  SqlContract,
   SqlStorage,
   StorageTypeInstance,
   UniqueConstraint,
@@ -54,6 +55,7 @@ const ExecutionMutationDefaultSchema = type({
 
 const ExecutionSchema = type({
   '+': 'reject',
+  executionHash: 'string',
   mutations: {
     '+': 'reject',
     defaults: ExecutionMutationDefaultSchema.array().readonly(),
@@ -128,13 +130,45 @@ const StorageTableSchema = type({
 
 const StorageSchema = type({
   '+': 'reject',
+  storageHash: 'string',
   tables: type({ '[string]': StorageTableSchema }),
   'types?': type({ '[string]': StorageTypeInstanceSchema }),
 });
 
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isContractFieldType(value: unknown): boolean {
+  if (!isPlainRecord(value)) return false;
+  const kind = value['kind'];
+  if (kind === 'scalar') {
+    if (typeof value['codecId'] !== 'string') return false;
+    const typeParams = value['typeParams'];
+    if (typeParams !== undefined && !isPlainRecord(typeParams)) return false;
+    return true;
+  }
+  if (kind === 'valueObject') {
+    return typeof value['name'] === 'string';
+  }
+  if (kind === 'union') {
+    const members = value['members'];
+    if (!Array.isArray(members)) return false;
+    return members.every((m) => isContractFieldType(m));
+  }
+  return false;
+}
+
+const ContractFieldTypeSchema = type('unknown').narrow((value, ctx) =>
+  isContractFieldType(value) ? true : ctx.mustBe('scalar, valueObject, or union field type'),
+);
+
 const ModelFieldSchema = type({
-  'nullable?': 'boolean',
-  'codecId?': 'string',
+  '+': 'reject',
+  nullable: 'boolean',
+  type: ContractFieldTypeSchema,
+  'many?': 'true',
+  'dict?': 'true',
 });
 
 const ModelStorageFieldSchema = type({
@@ -164,20 +198,16 @@ const ContractMetaSchema = type({
 
 const SqlContractSchema = type({
   '+': 'reject',
-  'schemaVersion?': "'1'",
   target: 'string',
   targetFamily: "'sql'",
   'coreHash?': 'string',
-  storageHash: 'string',
-  'executionHash?': 'string',
-  'profileHash?': 'string',
-  '_generated?': 'Record<string, unknown>',
+  profileHash: 'string',
   'capabilities?': 'Record<string, Record<string, boolean>>',
   'extensionPacks?': 'Record<string, unknown>',
   'meta?': ContractMetaSchema,
-  'sources?': 'Record<string, unknown>',
   'roots?': 'Record<string, string>',
   models: type({ '[string]': ModelSchema }),
+  'valueObjects?': 'Record<string, unknown>',
   storage: StorageSchema,
   'execution?': ExecutionSchema,
 });
@@ -215,43 +245,44 @@ export function validateModel(value: unknown): unknown {
 }
 
 /**
- * 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.
+ * Validates the structural shape of an SQL contract using Arktype.
  *
- * This ensures all required fields are present and have the correct types.
+ * Ensures all required fields are present and have the correct types,
+ * including SQL-specific storage structure (tables, columns, constraints).
  *
  * @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
+ * @throws ContractValidationError if the contract structure is invalid
  */
-export function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T {
+export function validateSqlContract<T extends Contract<SqlStorage>>(value: unknown): T {
   if (typeof value !== 'object' || value === null) {
-    throw new Error('Contract structural validation failed: value must be an object');
+    throw new ContractValidationError(
+      'Contract structural validation failed: value must be an object',
+      'structural',
+    );
   }
 
-  // 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') {
-    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);
+    throw new ContractValidationError(
+      `Unsupported target family: ${rawValue.targetFamily}`,
+      'structural',
+    );
   }
 
   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}`);
+    throw new ContractValidationError(
+      `Contract structural validation failed: ${messages}`,
+      'structural',
+    );
   }
 
-  // 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 T;
+  // Arktype's inferred output type differs from T due to exactOptionalPropertyTypes
+  // and branded hash types — the runtime value is structurally compatible after validation
+  return contractResult as unknown as T;
 }
 
 /**

package/dist/types-D6K16_9R.d.mts.map

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

package/dist/validators-i9MX9Dti.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"validators-i9MX9Dti.mjs","names":["errors: string[]"],"sources":["../src/validators.ts"],"sourcesContent":["import { type } from 'arktype';\nimport type {\n  ForeignKey,\n  ForeignKeyReferences,\n  PrimaryKey,\n  ReferentialAction,\n  SqlContract,\n  SqlStorage,\n  StorageTypeInstance,\n  UniqueConstraint,\n} from './types';\n\ntype ColumnDefaultLiteral = {\n  readonly kind: 'literal';\n  readonly value: string | number | boolean | Record<string, unknown> | unknown[] | null;\n};\ntype ColumnDefaultFunction = { readonly kind: 'function'; readonly expression: string };\nconst literalKindSchema = type(\"'literal'\");\nconst functionKindSchema = type(\"'function'\");\nconst generatorKindSchema = type(\"'generator'\");\nconst generatorIdSchema = type('string').narrow((value, ctx) => {\n  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(value) ? true : ctx.mustBe('a flat generator id');\n});\n\nexport const ColumnDefaultLiteralSchema = type.declare<ColumnDefaultLiteral>().type({\n  kind: literalKindSchema,\n  value: 'string | number | boolean | null | unknown[] | Record<string, unknown>',\n});\n\nexport const ColumnDefaultFunctionSchema = type.declare<ColumnDefaultFunction>().type({\n  kind: functionKindSchema,\n  expression: 'string',\n});\n\nexport const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);\n\nconst ExecutionMutationDefaultValueSchema = type({\n  '+': 'reject',\n  kind: generatorKindSchema,\n  id: generatorIdSchema,\n  'params?': 'Record<string, unknown>',\n});\n\nconst ExecutionMutationDefaultSchema = type({\n  '+': 'reject',\n  ref: {\n    '+': 'reject',\n    table: 'string',\n    column: 'string',\n  },\n  'onCreate?': ExecutionMutationDefaultValueSchema,\n  'onUpdate?': ExecutionMutationDefaultValueSchema,\n});\n\nconst ExecutionSchema = type({\n  '+': 'reject',\n  mutations: {\n    '+': 'reject',\n    defaults: ExecutionMutationDefaultSchema.array().readonly(),\n  },\n});\n\nconst StorageColumnSchema = type({\n  '+': 'reject',\n  nativeType: 'string',\n  codecId: 'string',\n  nullable: 'boolean',\n  'typeParams?': 'Record<string, unknown>',\n  'typeRef?': 'string',\n  'default?': ColumnDefaultSchema,\n}).narrow((col, ctx) => {\n  if (col.typeParams !== undefined && col.typeRef !== undefined) {\n    return ctx.mustBe('a column with either typeParams or typeRef, not both');\n  }\n  return true;\n});\n\nconst StorageTypeInstanceSchema = type.declare<StorageTypeInstance>().type({\n  codecId: 'string',\n  nativeType: 'string',\n  typeParams: 'Record<string, unknown>',\n});\n\nconst PrimaryKeySchema = type.declare<PrimaryKey>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst UniqueConstraintSchema = type.declare<UniqueConstraint>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nexport const IndexSchema = type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n  'using?': 'string',\n  'config?': 'Record<string, unknown>',\n});\n\nexport const ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({\n  table: 'string',\n  columns: type.string.array().readonly(),\n});\n\nexport const ReferentialActionSchema = type\n  .declare<ReferentialAction>()\n  .type(\"'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'\");\n\nexport const ForeignKeySchema = type.declare<ForeignKey>().type({\n  columns: type.string.array().readonly(),\n  references: ForeignKeyReferencesSchema,\n  'name?': 'string',\n  'onDelete?': ReferentialActionSchema,\n  'onUpdate?': ReferentialActionSchema,\n  constraint: 'boolean',\n  index: 'boolean',\n});\n\nconst StorageTableSchema = type({\n  '+': 'reject',\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({\n  '+': 'reject',\n  tables: type({ '[string]': StorageTableSchema }),\n  'types?': type({ '[string]': StorageTypeInstanceSchema }),\n});\n\nconst ModelFieldSchema = type({\n  'nullable?': 'boolean',\n  'codecId?': 'string',\n});\n\nconst ModelStorageFieldSchema = type({\n  column: 'string',\n  'codecId?': 'string',\n  'nullable?': 'boolean',\n});\n\nconst ModelStorageSchema = type({\n  table: 'string',\n  fields: type({ '[string]': ModelStorageFieldSchema }),\n});\n\nconst ModelSchema = type({\n  storage: ModelStorageSchema,\n  'fields?': type({ '[string]': ModelFieldSchema }),\n  'relations?': type({ '[string]': 'unknown' }),\n  'discriminator?': 'unknown',\n  'variants?': 'unknown',\n  'base?': 'string',\n  'owner?': 'string',\n});\n\nconst ContractMetaSchema = type({\n  '[string]': 'unknown',\n});\n\nconst SqlContractSchema = type({\n  '+': 'reject',\n  'schemaVersion?': \"'1'\",\n  target: 'string',\n  targetFamily: \"'sql'\",\n  'coreHash?': 'string',\n  storageHash: 'string',\n  'executionHash?': 'string',\n  'profileHash?': 'string',\n  '_generated?': 'Record<string, unknown>',\n  'capabilities?': 'Record<string, Record<string, boolean>>',\n  'extensionPacks?': 'Record<string, unknown>',\n  'meta?': ContractMetaSchema,\n  'sources?': 'Record<string, unknown>',\n  'roots?': 'Record<string, string>',\n  models: type({ '[string]': ModelSchema }),\n  storage: StorageSchema,\n  'execution?': ExecutionSchema,\n});\n\n// NOTE: StorageColumnSchema, StorageTableSchema, and StorageSchema use bare type()\n// instead of type.declare<T>().type() because the ColumnDefault union's value field\n// includes bigint | Date (runtime-only types after decoding) which cannot be expressed\n// in Arktype's JSON validation DSL. The `as SqlStorage` cast in validateStorage() bridges\n// the gap between the JSON-safe Arktype output and the runtime TypeScript type.\n// See decodeContractDefaults() in validate.ts for the decoding step.\n\n/**\n * Validates the structural shape of SqlStorage using Arktype.\n *\n * @param value - The storage value to validate\n * @returns The validated storage if structure is valid\n * @throws Error if the storage structure is invalid\n */\nexport function validateStorage(value: unknown): SqlStorage {\n  const result = StorageSchema(value);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Storage validation failed: ${messages}`);\n  }\n  return result as SqlStorage;\n}\n\nexport function validateModel(value: unknown): unknown {\n  const result = ModelSchema(value);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Model validation failed: ${messages}`);\n  }\n  return result;\n}\n\n/**\n * Validates the structural shape of a SqlContract using Arktype.\n *\n * **Responsibility: Validation Only**\n * This function validates that the contract has the correct structure and types.\n * It does NOT normalize the contract - normalization must happen in the contract builder.\n *\n * The contract passed to this function must already be normalized (all required fields present).\n * If normalization is needed, it should be done by the contract builder before calling this function.\n *\n * This ensures all required fields are present and have the correct types.\n *\n * @param value - The contract value to validate (typically from a JSON import)\n * @returns The validated contract if structure is valid\n * @throws Error if the contract structure is invalid\n */\nexport function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T {\n  if (typeof value !== 'object' || value === null) {\n    throw new Error('Contract structural validation failed: value must be an object');\n  }\n\n  // Check targetFamily first to provide a clear error message for unsupported target families\n  const rawValue = value as { targetFamily?: string };\n  if (rawValue.targetFamily !== undefined && rawValue.targetFamily !== 'sql') {\n    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);\n  }\n\n  const contractResult = SqlContractSchema(value);\n\n  if (contractResult instanceof type.errors) {\n    const messages = contractResult.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Contract structural validation failed: ${messages}`);\n  }\n\n  // After validation, contractResult matches the schema and preserves the input structure\n  // TypeScript needs an assertion here due to exactOptionalPropertyTypes differences\n  // between Arktype's inferred type and the generic T, but runtime-wise they're compatible\n  return contractResult as T;\n}\n\n/**\n * Validates semantic constraints on SqlStorage that cannot be expressed in Arktype schemas.\n *\n * Returns an array of human-readable error strings. Empty array = valid.\n *\n * Currently checks:\n * - duplicate named primary key / unique / index / foreign key objects within a table\n * - duplicate unique, index, or foreign key declarations within a table\n * - `setNull` referential action on a non-nullable FK column (would fail at runtime)\n * - `setDefault` referential action on a non-nullable FK column without a DEFAULT (would fail at runtime)\n */\nexport function validateStorageSemantics(storage: SqlStorage): string[] {\n  const errors: string[] = [];\n\n  for (const [tableName, table] of Object.entries(storage.tables)) {\n    const namedObjects = new Map<string, string[]>();\n    const registerNamedObject = (kind: string, name: string | undefined) => {\n      if (!name) return;\n      namedObjects.set(name, [...(namedObjects.get(name) ?? []), kind]);\n    };\n\n    registerNamedObject('primary key', table.primaryKey?.name);\n    for (const unique of table.uniques) {\n      registerNamedObject('unique constraint', unique.name);\n    }\n    for (const index of table.indexes) {\n      registerNamedObject('index', index.name);\n    }\n    for (const fk of table.foreignKeys) {\n      registerNamedObject('foreign key', fk.name);\n    }\n\n    for (const [name, kinds] of namedObjects) {\n      if (kinds.length > 1) {\n        errors.push(\n          `Table \"${tableName}\": named object \"${name}\" is declared multiple times (${kinds.join(', ')})`,\n        );\n      }\n    }\n\n    const seenUniqueDefinitions = new Set<string>();\n    for (const unique of table.uniques) {\n      const signature = JSON.stringify({ columns: unique.columns });\n      if (seenUniqueDefinitions.has(signature)) {\n        errors.push(\n          `Table \"${tableName}\": duplicate unique constraint definition on columns [${unique.columns.join(', ')}]`,\n        );\n        continue;\n      }\n      seenUniqueDefinitions.add(signature);\n    }\n\n    const seenIndexDefinitions = new Set<string>();\n    for (const index of table.indexes) {\n      const signature = JSON.stringify({\n        columns: index.columns,\n        using: index.using ?? null,\n        config: index.config ?? null,\n      });\n      if (seenIndexDefinitions.has(signature)) {\n        errors.push(\n          `Table \"${tableName}\": duplicate index definition on columns [${index.columns.join(', ')}]`,\n        );\n        continue;\n      }\n      seenIndexDefinitions.add(signature);\n    }\n\n    const seenForeignKeyDefinitions = new Set<string>();\n    for (const fk of table.foreignKeys) {\n      const signature = JSON.stringify({\n        columns: fk.columns,\n        references: fk.references,\n        onDelete: fk.onDelete ?? null,\n        onUpdate: fk.onUpdate ?? null,\n        constraint: fk.constraint,\n        index: fk.index,\n      });\n      if (seenForeignKeyDefinitions.has(signature)) {\n        errors.push(\n          `Table \"${tableName}\": duplicate foreign key definition on columns [${fk.columns.join(', ')}]`,\n        );\n        continue;\n      }\n      seenForeignKeyDefinitions.add(signature);\n    }\n\n    for (const fk of table.foreignKeys) {\n      for (const colName of fk.columns) {\n        const column = table.columns[colName];\n        if (!column) continue;\n\n        if (fk.onDelete === 'setNull' && !column.nullable) {\n          errors.push(\n            `Table \"${tableName}\": onDelete setNull on foreign key column \"${colName}\" which is NOT NULL`,\n          );\n        }\n        if (fk.onUpdate === 'setNull' && !column.nullable) {\n          errors.push(\n            `Table \"${tableName}\": onUpdate setNull on foreign key column \"${colName}\" which is NOT NULL`,\n          );\n        }\n        if (fk.onDelete === 'setDefault' && !column.nullable && column.default === undefined) {\n          errors.push(\n            `Table \"${tableName}\": onDelete setDefault on foreign key column \"${colName}\" which is NOT NULL and has no DEFAULT`,\n          );\n        }\n        if (fk.onUpdate === 'setDefault' && !column.nullable && column.default === undefined) {\n          errors.push(\n            `Table \"${tableName}\": onUpdate setDefault on foreign key column \"${colName}\" which is NOT NULL and has no DEFAULT`,\n          );\n        }\n      }\n    }\n  }\n\n  return errors;\n}\n"],"mappings":"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"}

package/src/construct.ts

@@ -1,16 +0,0 @@
-import type { SqlContract, SqlStorage } from './types';
-
-type ValidatedContractInput = SqlContract<SqlStorage> & { _generated?: unknown };
-
-function stripGenerated(obj: ValidatedContractInput): Omit<ValidatedContractInput, '_generated'> {
-  const input = obj as unknown as Record<string, unknown>;
-  const { _generated: _, ...rest } = input;
-  return rest as Omit<ValidatedContractInput, '_generated'>;
-}
-
-export function constructContract<TContract extends SqlContract<SqlStorage>>(
-  input: ValidatedContractInput,
-): TContract {
-  const stripped = stripGenerated(input);
-  return stripped as TContract;
-}