@prisma-next/sql-contract 0.3.0-dev.123 → 0.3.0-dev.125

package/dist/{validators-DuHeCiKZ.mjs → validators-B1ZW3frd.mjs}

@@ -97,12 +97,23 @@ const StorageSchema = type({
 	tables: type({ "[string]": StorageTableSchema }),
 	"types?": type({ "[string]": StorageTypeInstanceSchema })
 });
-const ModelFieldSchema = type.declare().type({ column: "string" });
-const ModelStorageSchema = type.declare().type({ table: "string" });
-const ModelSchema = type.declare().type({
-	storage: ModelStorageSchema,
+const ModelFieldSchema = type({
+	"column?": "string",
+	"nullable?": "boolean",
+	"codecId?": "string"
+});
+const ModelStorageFieldSchema = type({ column: "string" });
+const ModelSchema = type({
+	storage: type({
+		table: "string",
+		"fields?": type({ "[string]": ModelStorageFieldSchema })
+	}),
 	fields: type({ "[string]": ModelFieldSchema }),
-	relations: type({ "[string]": "unknown" })
+	relations: type({ "[string]": "unknown" }),
+	"discriminator?": "unknown",
+	"variants?": "unknown",
+	"base?": "string",
+	"owner?": "string"
 });
 const MappingsSchema = type({
 	"+": "reject",
@@ -129,6 +140,7 @@ const SqlContractSchema = type({
 	"meta?": ContractMetaSchema,
 	"sources?": "Record<string, unknown>",
 	"relations?": type({ "[string]": "unknown" }),
+	"roots?": "Record<string, string>",
 	"mappings?": MappingsSchema,
 	models: type({ "[string]": ModelSchema }),
 	storage: StorageSchema,
@@ -215,4 +227,4 @@ function validateStorageSemantics(storage) {
 
 //#endregion
 export { ForeignKeySchema as a, validateModel as c, validateStorageSemantics as d, ForeignKeyReferencesSchema as i, validateSqlContract as l, ColumnDefaultLiteralSchema as n, IndexSchema as o, ColumnDefaultSchema as r, ReferentialActionSchema as s, ColumnDefaultFunctionSchema as t, validateStorage as u };
-//# sourceMappingURL=validators-DuHeCiKZ.mjs.map
+//# sourceMappingURL=validators-B1ZW3frd.mjs.map

package/dist/validators-B1ZW3frd.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators-B1ZW3frd.mjs","names":["errors: string[]"],"sources":["../src/validators.ts"],"sourcesContent":["import { type } from 'arktype';\nimport type {\n  ForeignKey,\n  ForeignKeyReferences,\n  ModelDefinition,\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  'column?': 'string',\n  'nullable?': 'boolean',\n  'codecId?': 'string',\n});\n\nconst ModelStorageFieldSchema = type({\n  column: 'string',\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 MappingsSchema = type({\n  '+': 'reject',\n  'modelToTable?': 'null | Record<string, string>',\n  'tableToModel?': 'null | Record<string, string>',\n  'fieldToColumn?': 'null | Record<string, Record<string, string>>',\n  'columnToField?': 'null | Record<string, Record<string, string>>',\n  'codecTypes?': 'null | Record<string, unknown>',\n  'operationTypes?': 'null | Record<string, Record<string, unknown>>',\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  'relations?': type({ '[string]': 'unknown' }),\n  'roots?': 'Record<string, string>',\n  'mappings?': MappingsSchema,\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\n/**\n * Validates the structural shape of ModelDefinition using Arktype.\n *\n * @param value - The model value to validate\n * @returns The validated model if structure is valid\n * @throws Error if the model structure is invalid\n */\nexport function validateModel(value: unknown): ModelDefinition {\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 as ModelDefinition;\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 * - `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    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":";;;AAkBA,MAAM,oBAAoB,KAAK,YAAY;AAC3C,MAAM,qBAAqB,KAAK,aAAa;AAC7C,MAAM,sBAAsB,KAAK,cAAc;AAC/C,MAAM,oBAAoB,KAAK,SAAS,CAAC,QAAQ,OAAO,QAAQ;AAC9D,QAAO,8BAA8B,KAAK,MAAM,GAAG,OAAO,IAAI,OAAO,sBAAsB;EAC3F;AAEF,MAAa,6BAA6B,KAAK,SAA+B,CAAC,KAAK;CAClF,MAAM;CACN,OAAO;CACR,CAAC;AAEF,MAAa,8BAA8B,KAAK,SAAgC,CAAC,KAAK;CACpF,MAAM;CACN,YAAY;CACb,CAAC;AAEF,MAAa,sBAAsB,2BAA2B,GAAG,4BAA4B;AAE7F,MAAM,sCAAsC,KAAK;CAC/C,KAAK;CACL,MAAM;CACN,IAAI;CACJ,WAAW;CACZ,CAAC;AAEF,MAAM,iCAAiC,KAAK;CAC1C,KAAK;CACL,KAAK;EACH,KAAK;EACL,OAAO;EACP,QAAQ;EACT;CACD,aAAa;CACb,aAAa;CACd,CAAC;AAEF,MAAM,kBAAkB,KAAK;CAC3B,KAAK;CACL,WAAW;EACT,KAAK;EACL,UAAU,+BAA+B,OAAO,CAAC,UAAU;EAC5D;CACF,CAAC;AAEF,MAAM,sBAAsB,KAAK;CAC/B,KAAK;CACL,YAAY;CACZ,SAAS;CACT,UAAU;CACV,eAAe;CACf,YAAY;CACZ,YAAY;CACb,CAAC,CAAC,QAAQ,KAAK,QAAQ;AACtB,KAAI,IAAI,eAAe,UAAa,IAAI,YAAY,OAClD,QAAO,IAAI,OAAO,uDAAuD;AAE3E,QAAO;EACP;AAEF,MAAM,4BAA4B,KAAK,SAA8B,CAAC,KAAK;CACzE,SAAS;CACT,YAAY;CACZ,YAAY;CACb,CAAC;AAEF,MAAM,mBAAmB,KAAK,SAAqB,CAAC,KAAK;CACvD,SAAS,KAAK,OAAO,OAAO,CAAC,UAAU;CACvC,SAAS;CACV,CAAC;AAEF,MAAM,yBAAyB,KAAK,SAA2B,CAAC,KAAK;CACnE,SAAS,KAAK,OAAO,OAAO,CAAC,UAAU;CACvC,SAAS;CACV,CAAC;AAEF,MAAa,cAAc,KAAK;CAC9B,SAAS,KAAK,OAAO,OAAO,CAAC,UAAU;CACvC,SAAS;CACT,UAAU;CACV,WAAW;CACZ,CAAC;AAEF,MAAa,6BAA6B,KAAK,SAA+B,CAAC,KAAK;CAClF,OAAO;CACP,SAAS,KAAK,OAAO,OAAO,CAAC,UAAU;CACxC,CAAC;AAEF,MAAa,0BAA0B,KACpC,SAA4B,CAC5B,KAAK,iEAAiE;AAEzE,MAAa,mBAAmB,KAAK,SAAqB,CAAC,KAAK;CAC9D,SAAS,KAAK,OAAO,OAAO,CAAC,UAAU;CACvC,YAAY;CACZ,SAAS;CACT,aAAa;CACb,aAAa;CACb,YAAY;CACZ,OAAO;CACR,CAAC;AAEF,MAAM,qBAAqB,KAAK;CAC9B,KAAK;CACL,SAAS,KAAK,EAAE,YAAY,qBAAqB,CAAC;CAClD,eAAe;CACf,SAAS,uBAAuB,OAAO,CAAC,UAAU;CAClD,SAAS,YAAY,OAAO,CAAC,UAAU;CACvC,aAAa,iBAAiB,OAAO,CAAC,UAAU;CACjD,CAAC;AAEF,MAAM,gBAAgB,KAAK;CACzB,KAAK;CACL,QAAQ,KAAK,EAAE,YAAY,oBAAoB,CAAC;CAChD,UAAU,KAAK,EAAE,YAAY,2BAA2B,CAAC;CAC1D,CAAC;AAEF,MAAM,mBAAmB,KAAK;CAC5B,WAAW;CACX,aAAa;CACb,YAAY;CACb,CAAC;AAEF,MAAM,0BAA0B,KAAK,EACnC,QAAQ,UACT,CAAC;AAOF,MAAM,cAAc,KAAK;CACvB,SANyB,KAAK;EAC9B,OAAO;EACP,WAAW,KAAK,EAAE,YAAY,yBAAyB,CAAC;EACzD,CAAC;CAIA,QAAQ,KAAK,EAAE,YAAY,kBAAkB,CAAC;CAC9C,WAAW,KAAK,EAAE,YAAY,WAAW,CAAC;CAC1C,kBAAkB;CAClB,aAAa;CACb,SAAS;CACT,UAAU;CACX,CAAC;AAEF,MAAM,iBAAiB,KAAK;CAC1B,KAAK;CACL,iBAAiB;CACjB,iBAAiB;CACjB,kBAAkB;CAClB,kBAAkB;CAClB,eAAe;CACf,mBAAmB;CACpB,CAAC;AAEF,MAAM,qBAAqB,KAAK,EAC9B,YAAY,WACb,CAAC;AAEF,MAAM,oBAAoB,KAAK;CAC7B,KAAK;CACL,kBAAkB;CAClB,QAAQ;CACR,cAAc;CACd,aAAa;CACb,aAAa;CACb,kBAAkB;CAClB,gBAAgB;CAChB,eAAe;CACf,iBAAiB;CACjB,mBAAmB;CACnB,SAAS;CACT,YAAY;CACZ,cAAc,KAAK,EAAE,YAAY,WAAW,CAAC;CAC7C,UAAU;CACV,aAAa;CACb,QAAQ,KAAK,EAAE,YAAY,aAAa,CAAC;CACzC,SAAS;CACT,cAAc;CACf,CAAC;;;;;;;;AAgBF,SAAgB,gBAAgB,OAA4B;CAC1D,MAAM,SAAS,cAAc,MAAM;AACnC,KAAI,kBAAkB,KAAK,QAAQ;EACjC,MAAM,WAAW,OAAO,KAAK,MAA2B,EAAE,QAAQ,CAAC,KAAK,KAAK;AAC7E,QAAM,IAAI,MAAM,8BAA8B,WAAW;;AAE3D,QAAO;;;;;;;;;AAUT,SAAgB,cAAc,OAAiC;CAC7D,MAAM,SAAS,YAAY,MAAM;AACjC,KAAI,kBAAkB,KAAK,QAAQ;EACjC,MAAM,WAAW,OAAO,KAAK,MAA2B,EAAE,QAAQ,CAAC,KAAK,KAAK;AAC7E,QAAM,IAAI,MAAM,4BAA4B,WAAW;;AAEzD,QAAO;;;;;;;;;;;;;;;;;;AAmBT,SAAgB,oBAAuD,OAAmB;AACxF,KAAI,OAAO,UAAU,YAAY,UAAU,KACzC,OAAM,IAAI,MAAM,iEAAiE;CAInF,MAAM,WAAW;AACjB,KAAI,SAAS,iBAAiB,UAAa,SAAS,iBAAiB,MACnE,OAAM,IAAI,MAAM,8BAA8B,SAAS,eAAe;CAGxE,MAAM,iBAAiB,kBAAkB,MAAM;AAE/C,KAAI,0BAA0B,KAAK,QAAQ;EACzC,MAAM,WAAW,eAAe,KAAK,MAA2B,EAAE,QAAQ,CAAC,KAAK,KAAK;AACrF,QAAM,IAAI,MAAM,0CAA0C,WAAW;;AAMvE,QAAO;;;;;;;;;;;AAYT,SAAgB,yBAAyB,SAA+B;CACtE,MAAMA,SAAmB,EAAE;AAE3B,MAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,QAAQ,OAAO,CAC7D,MAAK,MAAM,MAAM,MAAM,YACrB,MAAK,MAAM,WAAW,GAAG,SAAS;EAChC,MAAM,SAAS,MAAM,QAAQ;AAC7B,MAAI,CAAC,OAAQ;AAEb,MAAI,GAAG,aAAa,aAAa,CAAC,OAAO,SACvC,QAAO,KACL,UAAU,UAAU,6CAA6C,QAAQ,qBAC1E;AAEH,MAAI,GAAG,aAAa,aAAa,CAAC,OAAO,SACvC,QAAO,KACL,UAAU,UAAU,6CAA6C,QAAQ,qBAC1E;AAEH,MAAI,GAAG,aAAa,gBAAgB,CAAC,OAAO,YAAY,OAAO,YAAY,OACzE,QAAO,KACL,UAAU,UAAU,gDAAgD,QAAQ,wCAC7E;AAEH,MAAI,GAAG,aAAa,gBAAgB,CAAC,OAAO,YAAY,OAAO,YAAY,OACzE,QAAO,KACL,UAAU,UAAU,gDAAgD,QAAQ,wCAC7E;;AAMT,QAAO"}

package/dist/validators.d.mts

@@ -1,4 +1,4 @@
-import { D as SqlStorage, d as ForeignKeyReferences, l as ForeignKey, p as ModelDefinition, w as SqlContract, x as ReferentialAction } from "./types-mnqqP_Au.mjs";
+import { A as SqlStorage, d as ForeignKeyReferences, l as ForeignKey, p as ModelDefinition, w as SqlContract, x as ReferentialAction } from "./types-C7hjlEOo.mjs";
 import * as arktype_internal_variants_object_ts0 from "arktype/internal/variants/object.ts";
 import * as arktype_internal_variants_string_ts0 from "arktype/internal/variants/string.ts";
 

package/dist/validators.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"validators.d.mts","names":[],"sources":["../src/validators.ts"],"sourcesContent":[],"mappings":";;;;;KAeK,oBAAA;;8CAEyC;;AAJ7B,KAMZ,qBAAA,GAJoB;EAIpB,SAAA,IAAA,EAAA,UAAqB;EAQb,SAAA,UAAA,EAAA,MAAA;AAKb,CAAA;AAKa,cAVA,0BAUgF,EAVtD,oCAAA,CAAA,UAUsD,CAVtD,oBAUsD,EAAA,CAAA,CAAA,CAAA;AAA7D,cALnB,2BAKmB,EALQ,oCAAA,CAAA,UAKR,CALQ,qBAKR,EAAA,CAAA,CAAA,CAAA;AAAA,cAAnB,mBAAmB,EAAA,oCAAA,CAAA,UAAA,CAAA,oBAAA,GAAA,qBAAA,EAAA,CAAA,CAAA,CAAA;AAAA,cA2DnB,WA3DmB,EAgE9B,oCAAA,CALsB,UA3DQ,CAAA;EAAA,OAAA,EAAA,SAAA,MAAA,EAAA;EA2DnB,IAAA,CAAA,EAAA,MAAA;EAOA,KAAA,CAAA,EAAA,MAAA;EAKA,MAAA,CAAA,EAPX,MAOW,CAAA,MAAA,EAAA,OAE4D,CAAA;AAEzE,CAAA,EAAA,CAAa,CAAA,CAAA;AAwFG,cAjGH,0BAiG8C,EAjGpB,oCAAA,CAAA,UAiGoB,CAjGpB,oBAiGoB,EAAA,CAAA,CAAA,CAAA;AAgB3C,cA5GH,uBA4GkC,EA5GX,oCAAA,CAAA,UA4G0B,CA5G1B,iBA4G0B,EAAA,CAAA,CAAA,CAAA;AAyB9C,cAjIH,gBAiIsB,EAjIN,oCAAA,CAAA,UAiIM,CAjIN,UAiIM,EAAA,CAAA,CAAA,CAAA;;;;;AAiCnC;;;iBA1EgB,eAAA,kBAAiC;;;;;;;;iBAgBjC,aAAA,kBAA+B;;;;;;;;;;;;;;;;;iBAyB/B,8BAA8B,YAAY,8BAA8B;;;;;;;;;;iBAiCxE,wBAAA,UAAkC"}
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../src/validators.ts"],"sourcesContent":[],"mappings":";;;;;KAaK,oBAAA;;8CAEyC;;AAJ7B,KAMZ,qBAAA,GAJoB;EAIpB,SAAA,IAAA,EAAA,UAAqB;EAQb,SAAA,UAAA,EAAA,MAAA;AAKb,CAAA;AAKa,cAVA,0BAUgF,EAVtD,oCAAA,CAAA,UAUsD,CAVtD,oBAUsD,EAAA,CAAA,CAAA,CAAA;AAA7D,cALnB,2BAKmB,EALQ,oCAAA,CAAA,UAKR,CALQ,qBAKR,EAAA,CAAA,CAAA,CAAA;AAAA,cAAnB,mBAAmB,EAAA,oCAAA,CAAA,UAAA,CAAA,oBAAA,GAAA,qBAAA,EAAA,CAAA,CAAA,CAAA;AAAA,cA2DnB,WA3DmB,EAgE9B,oCAAA,CALsB,UA3DQ,CAAA;EAAA,OAAA,EAAA,SAAA,MAAA,EAAA;EA2DnB,IAAA,CAAA,EAAA,MAAA;EAOA,KAAA,CAAA,EAAA,MAAA;EAKA,MAAA,CAAA,EAPX,MAOW,CAAA,MAAA,EAAA,OAE4D,CAAA;AAEzE,CAAA,EAAA,CAAa,CAAA,CAAA;AAoGG,cA7GH,0BA6G8C,EA7GpB,oCAAA,CAAA,UA6GoB,CA7GpB,oBA6GoB,EAAA,CAAA,CAAA,CAAA;AAgB3C,cAxHH,uBAwHkC,EAxHX,oCAAA,CAAA,UAwH0B,CAxH1B,iBAwH0B,EAAA,CAAA,CAAA,CAAA;AAyB9C,cA7IH,gBA6IsB,EA7IN,oCAAA,CAAA,UA6IM,CA7IN,UA6IM,EAAA,CAAA,CAAA,CAAA;;;;;AAiCnC;;;iBA1EgB,eAAA,kBAAiC;;;;;;;;iBAgBjC,aAAA,kBAA+B;;;;;;;;;;;;;;;;;iBAyB/B,8BAA8B,YAAY,8BAA8B;;;;;;;;;;iBAiCxE,wBAAA,UAAkC"}

package/dist/validators.mjs

@@ -1,3 +1,3 @@
-import { a as ForeignKeySchema, c as validateModel, d as validateStorageSemantics, i as ForeignKeyReferencesSchema, l as validateSqlContract, n as ColumnDefaultLiteralSchema, o as IndexSchema, r as ColumnDefaultSchema, s as ReferentialActionSchema, t as ColumnDefaultFunctionSchema, u as validateStorage } from "./validators-DuHeCiKZ.mjs";
+import { a as ForeignKeySchema, c as validateModel, d as validateStorageSemantics, i as ForeignKeyReferencesSchema, l as validateSqlContract, n as ColumnDefaultLiteralSchema, o as IndexSchema, r as ColumnDefaultSchema, s as ReferentialActionSchema, t as ColumnDefaultFunctionSchema, u as validateStorage } from "./validators-B1ZW3frd.mjs";
 
 export { ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, ForeignKeyReferencesSchema, ForeignKeySchema, IndexSchema, ReferentialActionSchema, validateModel, validateSqlContract, validateStorage, validateStorageSemantics };

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@prisma-next/sql-contract",
-  "version": "0.3.0-dev.123",
+  "version": "0.3.0-dev.125",
   "type": "module",
   "sideEffects": false,
   "description": "SQL contract types, validators, and IR factories for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.25",
-    "@prisma-next/contract": "0.3.0-dev.123"
+    "@prisma-next/contract": "0.3.0-dev.125"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/test-utils": "0.0.1"
   },
   "files": [
     "dist",

package/src/construct.ts

@@ -169,9 +169,12 @@ export function constructContract<TContract extends SqlContract<SqlStorage>>(
   const defaultMappings = computeDefaultMappings(input.models as Record<string, ModelDefinition>);
   const mappings = mergeMappings(defaultMappings, existingMappings);
 
+  const stripped = stripGenerated(input);
+
   const contractWithMappings = {
-    ...stripGenerated(input),
+    ...stripped,
     mappings,
+    roots: stripped.roots,
   };
 
   return contractWithMappings as TContract;

package/src/exports/types.ts

@@ -22,7 +22,10 @@ export type {
   ResolveOperationTypes,
   SqlContract,
   SqlMappings,
+  SqlModelFieldStorage,
+  SqlModelStorage,
   SqlQueryOperationTypes,
+  SqlRelation,
   SqlStorage,
   StorageColumn,
   StorageTable,

package/src/types.ts

@@ -1,6 +1,7 @@
 import type {
   ColumnDefault,
   ContractBase,
+  DomainRelationOn,
   ExecutionHashBase,
   ExecutionSection,
   ProfileHashBase,
@@ -131,6 +132,22 @@ export type ModelDefinition = {
   readonly storage: ModelStorage;
   readonly fields: Record<string, ModelField>;
   readonly relations: Record<string, unknown>;
+  readonly owner?: string;
+};
+
+export type SqlModelFieldStorage = {
+  readonly column: string;
+};
+
+export type SqlModelStorage = {
+  readonly table: string;
+  readonly fields: Record<string, SqlModelFieldStorage>;
+};
+
+export type SqlRelation = {
+  readonly to: string;
+  readonly cardinality: '1:1' | '1:N' | 'N:1';
+  readonly on: DomainRelationOn;
 };
 
 export type SqlMappings = {
@@ -210,10 +227,9 @@ export type SqlContract<
   TStorageHash extends StorageHashBase<string> = StorageHashBase<string>,
   TExecutionHash extends ExecutionHashBase<string> = ExecutionHashBase<string>,
   TProfileHash extends ProfileHashBase<string> = ProfileHashBase<string>,
-> = ContractBase<TStorageHash, TExecutionHash, TProfileHash> & {
+> = ContractBase<TStorageHash, TExecutionHash, TProfileHash, M> & {
   readonly targetFamily: string;
   readonly storage: S;
-  readonly models: M;
   readonly relations: R;
   readonly mappings: Map;
   readonly execution?: ExecutionSection;

package/src/validate.ts

@@ -1,10 +1,19 @@
 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 { validateSqlContract, validateStorageSemantics } from './validators';
 
+function extractDomainShape(contract: SqlContract<SqlStorage>): DomainContractShape {
+  return {
+    roots: contract.roots,
+    models: contract.models as Record<string, DomainModelShape>,
+  };
+}
+
 function validateContractLogic(contract: SqlContract<SqlStorage>): void {
   const tableNames = new Set(Object.keys(contract.storage.tables));
 
@@ -172,81 +181,356 @@ export function decodeContractDefaults<T extends SqlContract<SqlStorage>>(contra
   } as T;
 }
 
-export function normalizeContract(contract: unknown): SqlContract<SqlStorage> {
-  if (typeof contract !== 'object' || contract === null) {
-    return contract as SqlContract<SqlStorage>;
+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;
+    }
   }
 
-  const contractObj = contract as Record<string, unknown>;
+  return { ...storage, tables: normalizedTables };
+}
 
-  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,
-          };
+type RawModel = Record<string, unknown>;
+type RawField = Record<string, unknown>;
+type RawRelation = Record<string, unknown>;
+type RawStorageObj = { tables: Record<string, Record<string, unknown>> };
+
+function detectFormat(models: Record<string, RawModel>): 'old' | 'new' {
+  for (const model of Object.values(models)) {
+    const fields = model['fields'] as Record<string, RawField> | undefined;
+    if (!fields) continue;
+    for (const field of Object.values(fields)) {
+      if ('column' in field) return 'old';
+      if ('codecId' in field) return 'new';
+    }
+  }
+  return 'old';
+}
+
+function buildColumnToFieldMap(
+  fields: Record<string, RawField>,
+  modelName: string,
+): Record<string, string> {
+  const map: Record<string, string> = {};
+  for (const [fieldName, field] of Object.entries(fields)) {
+    const col = field['column'] as string | undefined;
+    if (!col) continue;
+    if (Object.hasOwn(map, col)) {
+      throw new Error(
+        `Model "${modelName}" has duplicate column mapping: fields "${map[col]}" and "${fieldName}" both map to column "${col}"`,
+      );
+    }
+    map[col] = fieldName;
+  }
+  return map;
+}
+
+function enrichOldFormatModels(
+  models: Record<string, RawModel>,
+  storageObj: RawStorageObj,
+  topRelations: Record<string, Record<string, RawRelation>>,
+): { enrichedModels: Record<string, RawModel>; roots: Record<string, string> } {
+  const roots: Record<string, string> = {};
+  const tableToModel: Record<string, string> = {};
+
+  for (const [modelName, model] of Object.entries(models)) {
+    const modelStorage = model['storage'] as Record<string, unknown> | undefined;
+    const tableName = modelStorage?.['table'] as string | undefined;
+    if (tableName) {
+      if (!model['owner']) {
+        roots[modelName] = modelName;
+      }
+      tableToModel[tableName] = modelName;
+    }
+  }
+
+  const enrichedModels: Record<string, RawModel> = {};
+
+  for (const [modelName, model] of Object.entries(models)) {
+    const fields = (model['fields'] ?? {}) as Record<string, RawField>;
+    const modelStorage = model['storage'] as Record<string, unknown> | undefined;
+    const tableName = modelStorage?.['table'] as string | undefined;
+    const storageTable = tableName
+      ? (storageObj.tables[tableName] as Record<string, unknown> | undefined)
+      : undefined;
+    const storageColumns = (storageTable?.['columns'] ?? {}) as Record<
+      string,
+      Record<string, unknown>
+    >;
+
+    const enrichedFields: Record<string, RawField> = {};
+    const modelStorageFields: Record<string, { column: string }> = {};
+
+    const hasStorageColumns = Object.keys(storageColumns).length > 0;
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const colName = field['column'] as string;
+      const storageCol = storageColumns[colName];
+      if (!storageCol && hasStorageColumns && colName) {
+        throw new Error(
+          `Model "${modelName}" field "${fieldName}" references non-existent column "${colName}" in table "${tableName}"`,
+        );
+      }
+      enrichedFields[fieldName] = {
+        ...field,
+        nullable: storageCol?.['nullable'] ?? false,
+        codecId: storageCol?.['codecId'] ?? '',
+      };
+      modelStorageFields[fieldName] = { column: colName };
+    }
+
+    const enrichedStorage = {
+      ...(modelStorage ?? {}),
+      fields: modelStorageFields,
+    };
+
+    enrichedModels[modelName] = {
+      ...model,
+      fields: enrichedFields,
+      storage: enrichedStorage,
+      relations: model['relations'] ?? {},
+    };
+  }
+
+  for (const [tableName, tableRels] of Object.entries(topRelations)) {
+    const modelName = tableToModel[tableName];
+    if (!modelName) continue;
+    const existingModel = enrichedModels[modelName];
+    if (!existingModel) continue;
+
+    const existingRels = (existingModel['relations'] ?? {}) as Record<string, unknown>;
+    const targetColumnToField: Record<string, Record<string, string>> = {};
+
+    const modelRelations: Record<string, unknown> = { ...existingRels };
+    for (const [relName, rel] of Object.entries(tableRels)) {
+      const on = rel['on'] as { childCols?: string[]; parentCols?: string[] } | undefined;
+      const parentCols = on?.['parentCols'] ?? [];
+      const childCols = on?.['childCols'] ?? [];
+
+      const toModel = rel['to'] as string;
+      const sourceFields = (existingModel['fields'] ?? {}) as Record<string, RawField>;
+      const sourceColToField = buildColumnToFieldMap(sourceFields, modelName);
+
+      if (!targetColumnToField[toModel]) {
+        const targetModelObj = enrichedModels[toModel];
+        if (targetModelObj) {
+          targetColumnToField[toModel] = buildColumnToFieldMap(
+            (targetModelObj['fields'] ?? {}) as Record<string, RawField>,
+            toModel,
+          );
         } else {
-          normalizedTables[tableName] = tableObj;
+          targetColumnToField[toModel] = {};
         }
       }
+      const targetColToField = targetColumnToField[toModel] ?? {};
 
-      normalizedStorage = {
-        ...storage,
-        tables: normalizedTables,
+      // Old format: parentCols = columns on FK-holding table (local), childCols = columns on referenced table (target)
+      const localFields = parentCols.map((c: string) => sourceColToField[c] ?? c);
+      const targetFields = childCols.map((c: string) => targetColToField[c] ?? c);
+
+      modelRelations[relName] = {
+        to: toModel,
+        cardinality: rel['cardinality'],
+        on: { localFields, targetFields },
       };
     }
+
+    enrichedModels[modelName] = {
+      ...existingModel,
+      relations: modelRelations,
+    };
   }
 
-  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'] ?? {},
+  return { enrichedModels, roots };
+}
+
+function enrichNewFormatModels(models: Record<string, RawModel>): {
+  enrichedModels: Record<string, RawModel>;
+  topRelations: Record<string, Record<string, unknown>>;
+} {
+  const enrichedModels: Record<string, RawModel> = {};
+  const topRelations: Record<string, Record<string, unknown>> = {};
+  const modelToTable: Record<string, string> = {};
+
+  for (const [modelName, model] of Object.entries(models)) {
+    const modelStorage = model['storage'] as Record<string, unknown> | undefined;
+    const tableName = modelStorage?.['table'] as string | undefined;
+    if (tableName) modelToTable[modelName] = tableName;
+  }
+
+  for (const [modelName, model] of Object.entries(models)) {
+    const fields = (model['fields'] ?? {}) as Record<string, RawField>;
+    const modelStorage = model['storage'] as Record<string, unknown> | undefined;
+    const storageFields = (modelStorage?.['fields'] ?? {}) as Record<
+      string,
+      Record<string, unknown>
+    >;
+
+    const enrichedFields: Record<string, RawField> = {};
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const sfEntry = storageFields[fieldName];
+      const column = sfEntry?.['column'] as string | undefined;
+      enrichedFields[fieldName] = column ? { ...field, column } : { ...field };
+    }
+
+    enrichedModels[modelName] = {
+      ...model,
+      fields: enrichedFields,
+      relations: model['relations'] ?? {},
+    };
+
+    const modelRels = (model['relations'] ?? {}) as Record<string, RawRelation>;
+    const tableName = modelToTable[modelName];
+    if (!tableName) continue;
+
+    for (const [relName, rel] of Object.entries(modelRels)) {
+      const on = rel['on'] as { localFields?: string[]; targetFields?: string[] } | undefined;
+      if (!on) continue;
+      const toModel = rel['to'] as string;
+      const toTable = modelToTable[toModel];
+      if (!toTable) continue;
+
+      const sourceFields = enrichedFields;
+      const targetModelObj = models[toModel];
+      const targetFields = (targetModelObj?.['fields'] ?? {}) as Record<string, RawField>;
+      const targetStorageObj = targetModelObj?.['storage'] as Record<string, unknown> | undefined;
+      const targetStorageFields = (targetStorageObj?.['fields'] ?? {}) as Record<
+        string,
+        Record<string, unknown>
+      >;
+
+      const parentCols = (on.localFields ?? []).map((f: string) => {
+        const sf = storageFields[f];
+        return (
+          (sf?.['column'] as string | undefined) ??
+          (sourceFields[f]?.['column'] as string | undefined) ??
+          f
+        );
+      });
+
+      const childCols = (on.targetFields ?? []).map((f: string) => {
+        const tsf = targetStorageFields[f];
+        return (
+          (tsf?.['column'] as string | undefined) ??
+          (targetFields[f]?.['column'] as string | undefined) ??
+          f
+        );
+      });
+
+      if (!topRelations[tableName]) topRelations[tableName] = {};
+      topRelations[tableName][relName] = {
+        to: toModel,
+        cardinality: rel['cardinality'],
+        on: { parentCols, childCols },
       };
     }
-    normalizedModels = normalizedModelsObj;
+  }
+
+  return { enrichedModels, topRelations };
+}
+
+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'];
+  if (!rawModels || typeof rawModels !== 'object' || rawModels === null) {
+    return {
+      ...contractObj,
+      roots: contractObj['roots'] ?? {},
+      models: rawModels ?? {},
+      relations: contractObj['relations'] ?? {},
+      storage: normalizedStorage,
+      extensionPacks: contractObj['extensionPacks'] ?? {},
+      capabilities: contractObj['capabilities'] ?? {},
+      meta: contractObj['meta'] ?? {},
+      sources: contractObj['sources'] ?? {},
+    } as SqlContract<SqlStorage>;
+  }
+
+  const modelsObj = rawModels as Record<string, RawModel>;
+  const format = detectFormat(modelsObj);
+
+  let normalizedModels: Record<string, RawModel>;
+  let roots: Record<string, string>;
+  let topRelations: Record<string, Record<string, unknown>>;
+
+  if (format === 'new') {
+    const result = enrichNewFormatModels(modelsObj);
+    normalizedModels = result.enrichedModels;
+    topRelations = {
+      ...((contractObj['relations'] ?? {}) as Record<string, Record<string, unknown>>),
+      ...result.topRelations,
+    };
+    roots = (contractObj['roots'] as Record<string, string>) ?? {};
+  } else {
+    const rawStorageObj =
+      normalizedStorage && typeof normalizedStorage === 'object'
+        ? (normalizedStorage as Record<string, unknown>)
+        : {};
+    const storageObj = {
+      tables: ((rawStorageObj as Record<string, unknown>)['tables'] ?? {}) as Record<
+        string,
+        Record<string, unknown>
+      >,
+    };
+    const existingRelations = (contractObj['relations'] ?? {}) as Record<
+      string,
+      Record<string, RawRelation>
+    >;
+    const result = enrichOldFormatModels(modelsObj, storageObj, existingRelations);
+    normalizedModels = result.enrichedModels;
+    roots = result.roots;
+    topRelations = existingRelations;
   }
 
   return {
     ...contractObj,
+    roots,
     models: normalizedModels,
-    relations: contractObj['relations'] ?? {},
+    relations: topRelations,
     storage: normalizedStorage,
     extensionPacks: contractObj['extensionPacks'] ?? {},
     capabilities: contractObj['capabilities'] ?? {},
@@ -259,7 +543,11 @@ export function validateContract<TContract extends SqlContract<SqlStorage>>(
   value: unknown,
 ): TContract {
   const normalized = normalizeContract(value);
+
   const structurallyValid = validateSqlContract<SqlContract<SqlStorage>>(normalized);
+
+  validateContractDomain(extractDomainShape(structurallyValid));
+
   validateContractLogic(structurallyValid);
 
   const semanticErrors = validateStorageSemantics(structurallyValid.storage);