@prisma-next/sql-contract 0.3.0-dev.5 → 0.3.0-dev.50

package/src/validate.ts

@@ -0,0 +1,448 @@
+import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';
+import { isTaggedBigInt, isTaggedRaw } from '@prisma-next/contract/types';
+import type {
+  ModelDefinition,
+  SqlContract,
+  SqlMappings,
+  SqlStorage,
+  StorageColumn,
+  StorageTable,
+} from './types';
+import { applyFkDefaults } from './types';
+import { validateSqlContract, validateStorageSemantics } from './validators';
+
+type ResolvedMappings = {
+  modelToTable: Record<string, string>;
+  tableToModel: Record<string, string>;
+  fieldToColumn: Record<string, Record<string, string>>;
+  columnToField: Record<string, Record<string, string>>;
+  codecTypes: Record<string, { readonly output: unknown }>;
+  operationTypes: Record<string, Record<string, unknown>>;
+};
+
+function computeDefaultMappings(models: Record<string, ModelDefinition>): ResolvedMappings {
+  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;
+  }
+
+  return {
+    modelToTable,
+    tableToModel,
+    fieldToColumn,
+    columnToField,
+    codecTypes: {},
+    operationTypes: {},
+  };
+}
+
+function assertInverseModelMappings(
+  modelToTable: Record<string, string>,
+  tableToModel: Record<string, string>,
+) {
+  for (const [model, table] of Object.entries(modelToTable)) {
+    if (tableToModel[table] !== model) {
+      throw new Error(
+        `Mappings override mismatch: modelToTable.${model}="${table}" is not mirrored in tableToModel`,
+      );
+    }
+  }
+  for (const [table, model] of Object.entries(tableToModel)) {
+    if (modelToTable[model] !== table) {
+      throw new Error(
+        `Mappings override mismatch: tableToModel.${table}="${model}" is not mirrored in modelToTable`,
+      );
+    }
+  }
+}
+
+function assertInverseFieldMappings(
+  fieldToColumn: Record<string, Record<string, string>>,
+  columnToField: Record<string, Record<string, string>>,
+  modelToTable: Record<string, string>,
+  tableToModel: Record<string, string>,
+) {
+  for (const [model, fields] of Object.entries(fieldToColumn)) {
+    const table = modelToTable[model];
+    if (!table) {
+      throw new Error(
+        `Mappings override mismatch: fieldToColumn references unknown model "${model}"`,
+      );
+    }
+    const reverseFields = columnToField[table];
+    if (!reverseFields) {
+      throw new Error(
+        `Mappings override mismatch: columnToField is missing table "${table}" for model "${model}"`,
+      );
+    }
+    for (const [field, column] of Object.entries(fields)) {
+      if (reverseFields[column] !== field) {
+        throw new Error(
+          `Mappings override mismatch: fieldToColumn.${model}.${field}="${column}" is not mirrored in columnToField.${table}`,
+        );
+      }
+    }
+  }
+
+  for (const [table, columns] of Object.entries(columnToField)) {
+    const model = tableToModel[table];
+    if (!model) {
+      throw new Error(
+        `Mappings override mismatch: columnToField references unknown table "${table}"`,
+      );
+    }
+    const forwardFields = fieldToColumn[model];
+    if (!forwardFields) {
+      throw new Error(
+        `Mappings override mismatch: fieldToColumn is missing model "${model}" for table "${table}"`,
+      );
+    }
+    for (const [column, field] of Object.entries(columns)) {
+      if (forwardFields[field] !== column) {
+        throw new Error(
+          `Mappings override mismatch: columnToField.${table}.${column}="${field}" is not mirrored in fieldToColumn.${model}`,
+        );
+      }
+    }
+  }
+}
+
+function mergeMappings(
+  defaults: ResolvedMappings,
+  existingMappings?: Partial<SqlMappings>,
+): ResolvedMappings {
+  const hasModelToTable = existingMappings?.modelToTable !== undefined;
+  const hasTableToModel = existingMappings?.tableToModel !== undefined;
+  if (hasModelToTable !== hasTableToModel) {
+    throw new Error(
+      'Mappings override mismatch: modelToTable and tableToModel must be provided together',
+    );
+  }
+
+  const hasFieldToColumn = existingMappings?.fieldToColumn !== undefined;
+  const hasColumnToField = existingMappings?.columnToField !== undefined;
+  if (hasFieldToColumn !== hasColumnToField) {
+    throw new Error(
+      'Mappings override mismatch: fieldToColumn and columnToField must be provided together',
+    );
+  }
+
+  const modelToTable: Record<string, string> = hasModelToTable
+    ? (existingMappings?.modelToTable ?? {})
+    : defaults.modelToTable;
+  const tableToModel: Record<string, string> = hasTableToModel
+    ? (existingMappings?.tableToModel ?? {})
+    : defaults.tableToModel;
+  assertInverseModelMappings(modelToTable, tableToModel);
+
+  const fieldToColumn: Record<string, Record<string, string>> = hasFieldToColumn
+    ? (existingMappings?.fieldToColumn ?? {})
+    : defaults.fieldToColumn;
+  const columnToField: Record<string, Record<string, string>> = hasColumnToField
+    ? (existingMappings?.columnToField ?? {})
+    : defaults.columnToField;
+  assertInverseFieldMappings(fieldToColumn, columnToField, modelToTable, tableToModel);
+
+  return {
+    modelToTable,
+    tableToModel,
+    fieldToColumn,
+    columnToField,
+    codecTypes: { ...defaults.codecTypes, ...(existingMappings?.codecTypes ?? {}) },
+    operationTypes: { ...defaults.operationTypes, ...(existingMappings?.operationTypes ?? {}) },
+  };
+}
+
+function validateContractLogic(contract: SqlContract<SqlStorage>): void {
+  const tableNames = new Set(Object.keys(contract.storage.tables));
+
+  for (const [tableName, table] of Object.entries(contract.storage.tables)) {
+    const columnNames = new Set(Object.keys(table.columns));
+
+    if (table.primaryKey) {
+      for (const colName of table.primaryKey.columns) {
+        if (!columnNames.has(colName)) {
+          throw new Error(
+            `Table "${tableName}" primaryKey references non-existent column "${colName}"`,
+          );
+        }
+      }
+    }
+
+    for (const unique of table.uniques) {
+      for (const colName of unique.columns) {
+        if (!columnNames.has(colName)) {
+          throw new Error(
+            `Table "${tableName}" unique constraint references non-existent column "${colName}"`,
+          );
+        }
+      }
+    }
+
+    for (const index of table.indexes) {
+      for (const colName of index.columns) {
+        if (!columnNames.has(colName)) {
+          throw new Error(`Table "${tableName}" index references non-existent column "${colName}"`);
+        }
+      }
+    }
+
+    for (const [colName, column] of Object.entries(table.columns)) {
+      if (!column.nullable && column.default?.kind === 'literal' && column.default.value === null) {
+        throw new Error(
+          `Table "${tableName}" column "${colName}" is NOT NULL but has a literal null default`,
+        );
+      }
+    }
+
+    for (const fk of table.foreignKeys) {
+      for (const colName of fk.columns) {
+        if (!columnNames.has(colName)) {
+          throw new Error(
+            `Table "${tableName}" foreignKey references non-existent column "${colName}"`,
+          );
+        }
+      }
+
+      if (!tableNames.has(fk.references.table)) {
+        throw new Error(
+          `Table "${tableName}" foreignKey references non-existent table "${fk.references.table}"`,
+        );
+      }
+
+      const referencedTable = contract.storage.tables[
+        fk.references.table
+      ] as (typeof contract.storage.tables)[string];
+      const referencedColumnNames = new Set(Object.keys(referencedTable.columns));
+      for (const colName of fk.references.columns) {
+        if (!referencedColumnNames.has(colName)) {
+          throw new Error(
+            `Table "${tableName}" foreignKey references non-existent column "${colName}" in table "${fk.references.table}"`,
+          );
+        }
+      }
+
+      if (fk.columns.length !== fk.references.columns.length) {
+        throw new Error(
+          `Table "${tableName}" foreignKey column count (${fk.columns.length}) does not match referenced column count (${fk.references.columns.length})`,
+        );
+      }
+    }
+  }
+}
+
+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`,
+      );
+    }
+  }
+  return value;
+}
+
+export function decodeContractDefaults<T extends SqlContract<SqlStorage>>(contract: T): T {
+  const tables = contract.storage.tables;
+  let tablesChanged = false;
+  const decodedTables: Record<string, StorageTable> = {};
+
+  for (const [tableName, table] of Object.entries(tables)) {
+    let columnsChanged = false;
+    const decodedColumns: Record<string, StorageColumn> = {};
+
+    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;
+        }
+      }
+      decodedColumns[columnName] = column;
+    }
+
+    if (columnsChanged) {
+      tablesChanged = true;
+      decodedTables[tableName] = { ...table, columns: decodedColumns };
+    } else {
+      decodedTables[tableName] = table;
+    }
+  }
+
+  if (!tablesChanged) {
+    return contract;
+  }
+
+  // The spread widens to SqlContract<SqlStorage>, but this transformation only
+  // decodes tagged bigint defaults for bigint-like columns and preserves all
+  // other properties of T.
+  return {
+    ...contract,
+    storage: {
+      ...contract.storage,
+      tables: decodedTables,
+    },
+  } as T;
+}
+
+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>;
+
+  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) {
+      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,
+            };
+          }
+
+          // Normalize foreign keys: add constraint/index defaults if missing
+          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;
+        }
+      }
+
+      normalizedStorage = {
+        ...storage,
+        tables: normalizedTables,
+      };
+    }
+  }
+
+  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;
+  }
+
+  return {
+    ...contractObj,
+    models: normalizedModels,
+    relations: contractObj['relations'] ?? {},
+    storage: normalizedStorage,
+    extensionPacks: contractObj['extensionPacks'] ?? {},
+    capabilities: contractObj['capabilities'] ?? {},
+    meta: contractObj['meta'] ?? {},
+    sources: contractObj['sources'] ?? {},
+  } as SqlContract<SqlStorage>;
+}
+
+export function validateContract<TContract extends SqlContract<SqlStorage>>(
+  value: unknown,
+): TContract {
+  const normalized = normalizeContract(value);
+  const structurallyValid = validateSqlContract<SqlContract<SqlStorage>>(normalized);
+  validateContractLogic(structurallyValid);
+
+  const semanticErrors = validateStorageSemantics(structurallyValid.storage);
+  if (semanticErrors.length > 0) {
+    throw new Error(`Contract semantic validation failed: ${semanticErrors.join('; ')}`);
+  }
+
+  const existingMappings = (structurallyValid as { mappings?: Partial<SqlMappings> }).mappings;
+  const defaultMappings = computeDefaultMappings(
+    structurallyValid.models as Record<string, ModelDefinition>,
+  );
+  const mappings = mergeMappings(defaultMappings, existingMappings);
+
+  const contractWithMappings = {
+    ...structurallyValid,
+    mappings,
+  };
+
+  return decodeContractDefaults(contractWithMappings) as TContract;
+}

package/src/validators.ts

@@ -7,17 +7,80 @@ import type {
   ModelField,
   ModelStorage,
   PrimaryKey,
+  ReferentialAction,
   SqlContract,
   SqlStorage,
-  StorageColumn,
-  StorageTable,
+  StorageTypeInstance,
   UniqueConstraint,
 } from './types';
 
-const StorageColumnSchema = type.declare<StorageColumn>().type({
+type ColumnDefaultLiteral = {
+  readonly kind: 'literal';
+  readonly value: string | number | boolean | Record<string, unknown> | unknown[] | null;
+};
+type ColumnDefaultFunction = { readonly kind: 'function'; readonly expression: string };
+const literalKindSchema = type("'literal'");
+const functionKindSchema = type("'function'");
+const generatorKindSchema = type("'generator'");
+const generatorIdSchema = type("'ulid' | 'nanoid' | 'uuidv7' | 'uuidv4' | 'cuid2' | 'ksuid'");
+
+export const ColumnDefaultLiteralSchema = type.declare<ColumnDefaultLiteral>().type({
+  kind: literalKindSchema,
+  value: 'string | number | boolean | null | unknown[] | Record<string, unknown>',
+});
+
+export const ColumnDefaultFunctionSchema = type.declare<ColumnDefaultFunction>().type({
+  kind: functionKindSchema,
+  expression: 'string',
+});
+
+export const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
+
+const ExecutionMutationDefaultValueSchema = type({
+  '+': 'reject',
+  kind: generatorKindSchema,
+  id: generatorIdSchema,
+  'params?': 'Record<string, unknown>',
+});
+
+const ExecutionMutationDefaultSchema = type({
+  '+': 'reject',
+  ref: {
+    '+': 'reject',
+    table: 'string',
+    column: 'string',
+  },
+  'onCreate?': ExecutionMutationDefaultValueSchema,
+  'onUpdate?': ExecutionMutationDefaultValueSchema,
+});
+
+const ExecutionSchema = type({
+  '+': 'reject',
+  mutations: {
+    '+': 'reject',
+    defaults: ExecutionMutationDefaultSchema.array().readonly(),
+  },
+});
+
+const StorageColumnSchema = type({
+  '+': 'reject',
   nativeType: 'string',
   codecId: 'string',
   nullable: 'boolean',
+  'typeParams?': 'Record<string, unknown>',
+  'typeRef?': 'string',
+  'default?': ColumnDefaultSchema,
+}).narrow((col, ctx) => {
+  if (col.typeParams !== undefined && col.typeRef !== undefined) {
+    return ctx.mustBe('a column with either typeParams or typeRef, not both');
+  }
+  return true;
+});
+
+const StorageTypeInstanceSchema = type.declare<StorageTypeInstance>().type({
+  codecId: 'string',
+  nativeType: 'string',
+  typeParams: 'Record<string, unknown>',
 });
 
 const PrimaryKeySchema = type.declare<PrimaryKey>().type({
@@ -35,18 +98,27 @@ const IndexSchema = type.declare<Index>().type({
   'name?': 'string',
 });
 
-const ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({
+export const ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({
   table: 'string',
   columns: type.string.array().readonly(),
 });
 
-const ForeignKeySchema = type.declare<ForeignKey>().type({
+export const ReferentialActionSchema = type
+  .declare<ReferentialAction>()
+  .type("'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'");
+
+export const ForeignKeySchema = type.declare<ForeignKey>().type({
   columns: type.string.array().readonly(),
   references: ForeignKeyReferencesSchema,
   'name?': 'string',
+  'onDelete?': ReferentialActionSchema,
+  'onUpdate?': ReferentialActionSchema,
+  constraint: 'boolean',
+  index: 'boolean',
 });
 
-const StorageTableSchema = type.declare<StorageTable>().type({
+const StorageTableSchema = type({
+  '+': 'reject',
   columns: type({ '[string]': StorageColumnSchema }),
   'primaryKey?': PrimaryKeySchema,
   uniques: UniqueConstraintSchema.array().readonly(),
@@ -54,8 +126,10 @@ const StorageTableSchema = type.declare<StorageTable>().type({
   foreignKeys: ForeignKeySchema.array().readonly(),
 });
 
-const StorageSchema = type.declare<SqlStorage>().type({
+const StorageSchema = type({
+  '+': 'reject',
   tables: type({ '[string]': StorageTableSchema }),
+  'types?': type({ '[string]': StorageTypeInstanceSchema }),
 });
 
 const ModelFieldSchema = type.declare<ModelField>().type({
@@ -72,20 +146,48 @@ const ModelSchema = type.declare<ModelDefinition>().type({
   relations: type({ '[string]': 'unknown' }),
 });
 
+const MappingsSchema = type({
+  '+': 'reject',
+  'modelToTable?': 'null | Record<string, string>',
+  'tableToModel?': 'null | Record<string, string>',
+  'fieldToColumn?': 'null | Record<string, Record<string, string>>',
+  'columnToField?': 'null | Record<string, Record<string, string>>',
+  'codecTypes?': 'null | Record<string, unknown>',
+  'operationTypes?': 'null | Record<string, Record<string, unknown>>',
+});
+
+const ContractMetaSchema = type({
+  '[string]': 'unknown',
+});
+
 const SqlContractSchema = type({
+  '+': 'reject',
   'schemaVersion?': "'1'",
   target: 'string',
   targetFamily: "'sql'",
-  coreHash: 'string',
+  'coreHash?': 'string',
+  storageHash: 'string',
+  'executionHash?': 'string',
   'profileHash?': 'string',
+  '_generated?': 'Record<string, unknown>',
   'capabilities?': 'Record<string, Record<string, boolean>>',
   'extensionPacks?': 'Record<string, unknown>',
-  'meta?': 'Record<string, unknown>',
+  'meta?': ContractMetaSchema,
   'sources?': 'Record<string, unknown>',
+  'relations?': type({ '[string]': 'unknown' }),
+  'mappings?': MappingsSchema,
   models: type({ '[string]': ModelSchema }),
   storage: StorageSchema,
+  'execution?': ExecutionSchema,
 });
 
+// NOTE: StorageColumnSchema, StorageTableSchema, and StorageSchema use bare type()
+// instead of type.declare<T>().type() because the ColumnDefault union's value field
+// includes bigint | Date (runtime-only types after decoding) which cannot be expressed
+// in Arktype's JSON validation DSL. The `as SqlStorage` cast in validateStorage() bridges
+// the gap between the JSON-safe Arktype output and the runtime TypeScript type.
+// See decodeContractDefaults() in validate.ts for the decoding step.
+
 /**
  * Validates the structural shape of SqlStorage using Arktype.
  *
@@ -99,7 +201,7 @@ export function validateStorage(value: unknown): SqlStorage {
     const messages = result.map((p: { message: string }) => p.message).join('; ');
     throw new Error(`Storage validation failed: ${messages}`);
   }
-  return result;
+  return result as SqlStorage;
 }
 
 /**
@@ -135,6 +237,10 @@ export function validateModel(value: unknown): ModelDefinition {
  * @throws Error if the contract structure is invalid
  */
 export function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T {
+  if (typeof value !== 'object' || value === null) {
+    throw new Error('Contract structural validation failed: value must be an object');
+  }
+
   // 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') {
@@ -153,3 +259,48 @@ export function validateSqlContract<T extends SqlContract<SqlStorage>>(value: un
   // between Arktype's inferred type and the generic T, but runtime-wise they're compatible
   return contractResult as T;
 }
+
+/**
+ * Validates semantic constraints on SqlStorage that cannot be expressed in Arktype schemas.
+ *
+ * Returns an array of human-readable error strings. Empty array = valid.
+ *
+ * Currently checks:
+ * - `setNull` referential action on a non-nullable FK column (would fail at runtime)
+ * - `setDefault` referential action on a non-nullable FK column without a DEFAULT (would fail at runtime)
+ */
+export function validateStorageSemantics(storage: SqlStorage): string[] {
+  const errors: string[] = [];
+
+  for (const [tableName, table] of Object.entries(storage.tables)) {
+    for (const fk of table.foreignKeys) {
+      for (const colName of fk.columns) {
+        const column = table.columns[colName];
+        if (!column) continue;
+
+        if (fk.onDelete === 'setNull' && !column.nullable) {
+          errors.push(
+            `Table "${tableName}": onDelete setNull on foreign key column "${colName}" which is NOT NULL`,
+          );
+        }
+        if (fk.onUpdate === 'setNull' && !column.nullable) {
+          errors.push(
+            `Table "${tableName}": onUpdate setNull on foreign key column "${colName}" which is NOT NULL`,
+          );
+        }
+        if (fk.onDelete === 'setDefault' && !column.nullable && column.default === undefined) {
+          errors.push(
+            `Table "${tableName}": onDelete setDefault on foreign key column "${colName}" which is NOT NULL and has no DEFAULT`,
+          );
+        }
+        if (fk.onUpdate === 'setDefault' && !column.nullable && column.default === undefined) {
+          errors.push(
+            `Table "${tableName}": onUpdate setDefault on foreign key column "${colName}" which is NOT NULL and has no DEFAULT`,
+          );
+        }
+      }
+    }
+  }
+
+  return errors;
+}

package/dist/exports/factories.d.ts

@@ -1,2 +0,0 @@
-export { col, contract, fk, index, model, pk, storage, table, unique, } from '../factories';
-//# sourceMappingURL=factories.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../../src/exports/factories.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,QAAQ,EACR,EAAE,EACF,KAAK,EACL,KAAK,EACL,EAAE,EACF,OAAO,EACP,KAAK,EACL,MAAM,GACP,MAAM,cAAc,CAAC"}