@prisma-next/sql-contract-ts 0.3.0-dev.13 → 0.3.0-dev.130

package/src/contract.ts

@@ -1,7 +1,4 @@
 import type {
-  ForeignKey,
-  ForeignKeyReferences,
-  Index,
   ModelDefinition,
   ModelField,
   ModelStorage,
@@ -9,10 +6,15 @@ import type {
   SqlContract,
   SqlMappings,
   SqlStorage,
-  StorageColumn,
-  StorageTable,
+  StorageTypeInstance,
   UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
+import { decodeContractDefaults } from '@prisma-next/sql-contract/validate';
+import {
+  ColumnDefaultSchema,
+  ForeignKeySchema,
+  IndexSchema,
+} from '@prisma-next/sql-contract/validators';
 import { type } from 'arktype';
 import type { O } from 'ts-toolbelt';
 
@@ -20,39 +22,33 @@ 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({
+
+const StorageColumnSchema = type({
   nativeType: 'string',
   codecId: 'string',
   nullable: 'boolean',
+  'typeParams?': 'Record<string, unknown>',
+  'typeRef?': 'string',
+  'default?': ColumnDefaultSchema,
 });
 
-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 StorageTypeInstanceSchema = type.declare<StorageTypeInstance>().type({
+  codecId: 'string',
+  nativeType: 'string',
+  typeParams: 'Record<string, unknown>',
 });
 
-const IndexSchema = type.declare<Index>().type({
+const PrimaryKeySchema = type.declare<PrimaryKey>().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({
+const UniqueConstraintSchema = type.declare<UniqueConstraint>().type({
   columns: type.string.array().readonly(),
-  references: ForeignKeyReferencesSchema,
   'name?': 'string',
 });
 
-const StorageTableSchema = type.declare<StorageTable>().type({
+const StorageTableSchema = type({
   columns: type({ '[string]': StorageColumnSchema }),
   'primaryKey?': PrimaryKeySchema,
   uniques: UniqueConstraintSchema.array().readonly(),
@@ -60,8 +56,9 @@ const StorageTableSchema = type.declare<StorageTable>().type({
   foreignKeys: ForeignKeySchema.array().readonly(),
 });
 
-const StorageSchema = type.declare<SqlStorage>().type({
+const StorageSchema = type({
   tables: type({ '[string]': StorageTableSchema }),
+  'types?': type({ '[string]': StorageTypeInstanceSchema }),
 });
 
 const ModelFieldSchema = type.declare<ModelField>().type({
@@ -76,6 +73,32 @@ const ModelSchema = type.declare<ModelDefinition>().type({
   storage: ModelStorageSchema,
   fields: type({ '[string]': ModelFieldSchema }),
   relations: type({ '[string]': 'unknown' }),
+  'owner?': 'string',
+});
+
+const GeneratorIdSchema = type('string').narrow((value, ctx) => {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(value) ? true : ctx.mustBe('a flat generator id');
+});
+
+const ExecutionMutationDefaultValueSchema = type({
+  kind: "'generator'",
+  id: GeneratorIdSchema,
+  'params?': 'Record<string, unknown>',
+});
+
+const ExecutionMutationDefaultSchema = type({
+  ref: {
+    table: 'string',
+    column: 'string',
+  },
+  'onCreate?': ExecutionMutationDefaultValueSchema,
+  'onUpdate?': ExecutionMutationDefaultValueSchema,
+});
+
+const ExecutionSchema = type({
+  mutations: {
+    defaults: ExecutionMutationDefaultSchema.array().readonly(),
+  },
 });
 
 /**
@@ -86,14 +109,17 @@ const SqlContractSchema = type({
   'schemaVersion?': "'1'",
   target: 'string',
   targetFamily: "'sql'",
-  coreHash: 'string',
+  storageHash: 'string',
+  'executionHash?': 'string',
   'profileHash?': 'string',
   'capabilities?': 'Record<string, Record<string, boolean>>',
   'extensionPacks?': 'Record<string, unknown>',
   'meta?': 'Record<string, unknown>',
   'sources?': 'Record<string, unknown>',
+  'roots?': 'Record<string, string>',
   models: type({ '[string]': ModelSchema }),
   storage: StorageSchema,
+  'execution?': ExecutionSchema,
 });
 
 /**
@@ -172,14 +198,11 @@ export function computeMappings(
     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 ?? {},
   };
 }
 
@@ -188,6 +211,9 @@ export function computeMappings(
  * 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.
  *
+ * Rule: keep this focused on structural consistency only; capability/feature
+ * gating (e.g., defaults.*) belongs in migration/runtime verification, not here.
+ *
  * @param structurallyValidatedContract - The contract whose structure has already been validated
  * @throws Error if logical validation fails
  */
@@ -195,9 +221,70 @@ function validateContractLogic(structurallyValidatedContract: SqlContract<SqlSto
   const { storage, models } = structurallyValidatedContract;
   const tableNames = new Set(Object.keys(storage.tables));
 
+  // Validate storage.types if present
+  if (storage.types) {
+    for (const [typeName, typeInstance] of Object.entries(storage.types)) {
+      // Validate typeParams is not an array (arrays are objects in JS but not valid here)
+      if (Array.isArray(typeInstance.typeParams)) {
+        throw new Error(
+          `Type instance "${typeName}" has invalid typeParams: must be a plain object, not an array`,
+        );
+      }
+    }
+  }
+
+  // Validate columns in all tables
+  for (const [tableName, table] of Object.entries(storage.tables)) {
+    for (const [columnName, column] of Object.entries(table.columns)) {
+      // Validate typeParams and typeRef are mutually exclusive
+      if (column.typeParams !== undefined && column.typeRef !== undefined) {
+        throw new Error(
+          `Column "${columnName}" in table "${tableName}" has both typeParams and typeRef; these are mutually exclusive`,
+        );
+      }
+
+      // Validate typeParams is not an array (arrays are objects in JS but not valid here)
+      if (column.typeParams !== undefined && Array.isArray(column.typeParams)) {
+        throw new Error(
+          `Column "${columnName}" in table "${tableName}" has invalid typeParams: must be a plain object, not an array`,
+        );
+      }
+
+      // Validate NOT NULL columns do not have literal null defaults
+      if (!column.nullable && column.default?.kind === 'literal' && column.default.value === null) {
+        throw new Error(
+          `Table "${tableName}" column "${columnName}" is NOT NULL but has a literal null default`,
+        );
+      }
+
+      // Validate typeRef points to an existing storage.types key and matches codecId/nativeType
+      if (column.typeRef !== undefined) {
+        const referencedType = storage.types?.[column.typeRef];
+        if (!referencedType) {
+          throw new Error(
+            `Column "${columnName}" in table "${tableName}" references non-existent type instance "${column.typeRef}" (not found in storage.types)`,
+          );
+        }
+
+        if (column.codecId !== referencedType.codecId) {
+          throw new Error(
+            `Column "${columnName}" in table "${tableName}" has codecId "${column.codecId}" but references type instance "${column.typeRef}" with codecId "${referencedType.codecId}"`,
+          );
+        }
+
+        if (column.nativeType !== referencedType.nativeType) {
+          throw new Error(
+            `Column "${columnName}" in table "${tableName}" has nativeType "${column.nativeType}" but references type instance "${column.typeRef}" with nativeType "${referencedType.nativeType}"`,
+          );
+        }
+      }
+    }
+  }
+
   // Validate models
   for (const [modelName, modelUnknown] of Object.entries(models)) {
-    const model = modelUnknown as ModelDefinition;
+    // normalizeContract() ensures models have both domain (DomainModel) and SQL-specific (ModelDefinition) properties
+    const model = modelUnknown as unknown as ModelDefinition;
     // Validate model has storage.table
     if (!model.storage?.table) {
       /* c8 ignore next */
@@ -382,82 +469,8 @@ function validateContractLogic(structurallyValidatedContract: SqlContract<SqlSto
   }
 }
 
-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>;
-}
+import { normalizeContract } from '@prisma-next/sql-contract/validate';
+export { normalizeContract };
 
 /**
  * Validates that a JSON import conforms to the SqlContract structure
@@ -529,5 +542,5 @@ export function validateContract<TContract extends SqlContract<SqlStorage>>(
 
   // 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;
+  return decodeContractDefaults(contractWithMappings) as TContract;
 }

package/src/exports/config-types.ts

@@ -0,0 +1,2 @@
+export type { ContractConfig } from '@prisma-next/config/config-types';
+export { typescriptContract } from '../config-types';

package/dist/chunk-SEOX3AAQ.js

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