@prisma-next/contract 0.3.0-pr.99.5 → 0.3.0

package/dist/testing.mjs

@@ -0,0 +1,58 @@
+import { t as coreHash } from "./types-aMyNgejf.mjs";
+import { n as computeProfileHash, r as computeStorageHash, t as computeExecutionHash } from "./hashing-CyaA_Qvf.mjs";
+import { ifDefined } from "@prisma-next/utils/defined";
+
+//#region src/testing-factories.ts
+const DUMMY_HASH = coreHash("sha256:test");
+function createContract(overrides = {}) {
+	const target = overrides.target ?? "postgres";
+	const targetFamily = overrides.targetFamily ?? "sql";
+	const capabilities = overrides.capabilities ?? {};
+	const rawStorage = overrides.storage ?? { tables: {} };
+	const storageHash = computeStorageHash({
+		target,
+		targetFamily,
+		storage: rawStorage
+	});
+	const storage = {
+		...rawStorage,
+		storageHash
+	};
+	const computedProfileHash = overrides.profileHash ?? computeProfileHash({
+		target,
+		targetFamily,
+		capabilities
+	});
+	return {
+		target,
+		targetFamily,
+		roots: overrides.roots ?? {},
+		models: overrides.models ?? {},
+		...ifDefined("valueObjects", overrides.valueObjects),
+		storage,
+		capabilities,
+		extensionPacks: overrides.extensionPacks ?? {},
+		...overrides.execution !== void 0 ? { execution: {
+			...overrides.execution,
+			executionHash: computeExecutionHash({
+				target,
+				targetFamily,
+				execution: overrides.execution
+			})
+		} } : {},
+		profileHash: computedProfileHash,
+		meta: overrides.meta ?? {}
+	};
+}
+function createSqlContract(overrides = {}) {
+	return createContract({
+		target: "postgres",
+		targetFamily: "sql",
+		storage: overrides.storage ?? { tables: {} },
+		...overrides
+	});
+}
+
+//#endregion
+export { DUMMY_HASH, createContract, createSqlContract };
+//# sourceMappingURL=testing.mjs.map

package/dist/testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.mjs","names":[],"sources":["../src/testing-factories.ts"],"sourcesContent":["import { ifDefined } from '@prisma-next/utils/defined';\nimport type { Contract } from './contract-types';\nimport type {\n  ContractModel,\n  ContractModelBase,\n  ContractValueObject,\n  ModelStorageBase,\n} from './domain-types';\nimport { computeExecutionHash, computeProfileHash, computeStorageHash } from './hashing';\nimport type { ExecutionSection, ProfileHashBase, StorageBase } from './types';\nimport { coreHash } from './types';\n\ntype ContractOverrides<\n  TStorage extends StorageBase = StorageBase,\n  TModels extends Record<string, ContractModelBase> = Record<string, ContractModel>,\n> = {\n  target?: string;\n  targetFamily?: string;\n  roots?: Record<string, string>;\n  models?: TModels;\n  storage?: Omit<TStorage, 'storageHash'>;\n  valueObjects?: Record<string, ContractValueObject>;\n  capabilities?: Record<string, Record<string, boolean>>;\n  extensionPacks?: Record<string, unknown>;\n  execution?: Omit<ExecutionSection, 'executionHash'>;\n  profileHash?: ProfileHashBase<string>;\n  meta?: Record<string, unknown>;\n};\n\nconst DUMMY_HASH = coreHash('sha256:test');\n\nexport function createContract<\n  TStorage extends StorageBase = StorageBase,\n  TModels extends Record<string, ContractModelBase> = Record<string, ContractModel>,\n>(overrides: ContractOverrides<TStorage, TModels> = {}): Contract<TStorage, TModels> {\n  const target = overrides.target ?? 'postgres';\n  const targetFamily = overrides.targetFamily ?? 'sql';\n  const capabilities = overrides.capabilities ?? {};\n\n  const rawStorage =\n    overrides.storage ?? ({ tables: {} } as unknown as Omit<TStorage, 'storageHash'>);\n\n  const storageHash = computeStorageHash({\n    target,\n    targetFamily,\n    storage: rawStorage as Record<string, unknown>,\n  });\n\n  const storage = {\n    ...rawStorage,\n    storageHash,\n  } as TStorage;\n\n  const computedProfileHash =\n    overrides.profileHash ?? computeProfileHash({ target, targetFamily, capabilities });\n\n  return {\n    target,\n    targetFamily,\n    roots: overrides.roots ?? {},\n    models: (overrides.models ?? {}) as TModels,\n    ...ifDefined('valueObjects', overrides.valueObjects),\n    storage,\n    capabilities,\n    extensionPacks: overrides.extensionPacks ?? {},\n    ...(overrides.execution !== undefined\n      ? {\n          execution: {\n            ...overrides.execution,\n            executionHash: computeExecutionHash({\n              target,\n              targetFamily,\n              execution: overrides.execution,\n            }),\n          },\n        }\n      : {}),\n    profileHash: computedProfileHash,\n    meta: overrides.meta ?? {},\n  };\n}\n\ntype SqlStorageLike = StorageBase & {\n  readonly tables: Record<string, unknown>;\n  readonly types?: Record<string, unknown>;\n};\n\ntype SqlModelLike = ContractModel<ModelStorageBase & { table: string }>;\n\nexport function createSqlContract(\n  overrides: ContractOverrides<SqlStorageLike, Record<string, SqlModelLike>> = {},\n): Contract<SqlStorageLike, Record<string, SqlModelLike>> {\n  return createContract<SqlStorageLike, Record<string, SqlModelLike>>({\n    target: 'postgres',\n    targetFamily: 'sql',\n    storage: overrides.storage ?? { tables: {} },\n    ...overrides,\n  });\n}\n\nexport { DUMMY_HASH };\n"],"mappings":";;;;;AA6BA,MAAM,aAAa,SAAS,cAAc;AAE1C,SAAgB,eAGd,YAAkD,EAAE,EAA+B;CACnF,MAAM,SAAS,UAAU,UAAU;CACnC,MAAM,eAAe,UAAU,gBAAgB;CAC/C,MAAM,eAAe,UAAU,gBAAgB,EAAE;CAEjD,MAAM,aACJ,UAAU,WAAY,EAAE,QAAQ,EAAE,EAAE;CAEtC,MAAM,cAAc,mBAAmB;EACrC;EACA;EACA,SAAS;EACV,CAAC;CAEF,MAAM,UAAU;EACd,GAAG;EACH;EACD;CAED,MAAM,sBACJ,UAAU,eAAe,mBAAmB;EAAE;EAAQ;EAAc;EAAc,CAAC;AAErF,QAAO;EACL;EACA;EACA,OAAO,UAAU,SAAS,EAAE;EAC5B,QAAS,UAAU,UAAU,EAAE;EAC/B,GAAG,UAAU,gBAAgB,UAAU,aAAa;EACpD;EACA;EACA,gBAAgB,UAAU,kBAAkB,EAAE;EAC9C,GAAI,UAAU,cAAc,SACxB,EACE,WAAW;GACT,GAAG,UAAU;GACb,eAAe,qBAAqB;IAClC;IACA;IACA,WAAW,UAAU;IACtB,CAAC;GACH,EACF,GACD,EAAE;EACN,aAAa;EACb,MAAM,UAAU,QAAQ,EAAE;EAC3B;;AAUH,SAAgB,kBACd,YAA6E,EAAE,EACvB;AACxD,QAAO,eAA6D;EAClE,QAAQ;EACR,cAAc;EACd,SAAS,UAAU,WAAW,EAAE,QAAQ,EAAE,EAAE;EAC5C,GAAG;EACJ,CAAC"}

package/dist/types-aMyNgejf.mjs

@@ -0,0 +1,14 @@
+//#region src/types.ts
+function executionHash(value) {
+	return value;
+}
+function coreHash(value) {
+	return value;
+}
+function profileHash(value) {
+	return value;
+}
+
+//#endregion
+export { executionHash as n, profileHash as r, coreHash as t };
+//# sourceMappingURL=types-aMyNgejf.mjs.map

package/dist/types-aMyNgejf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-aMyNgejf.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["/**\n * Unique symbol used as the key for branding types.\n */\nexport const $: unique symbol = Symbol('__prisma_next_brand__');\n\n/**\n * A helper type to brand a given type with a unique identifier.\n *\n * @template TKey Text used as the brand key.\n * @template TValue Optional value associated with the brand key. Defaults to `true`.\n */\nexport type Brand<TKey extends string | number | symbol, TValue = true> = {\n  [$]: {\n    [K in TKey]: TValue;\n  };\n};\n\n/**\n * Base type for storage contract hashes.\n * Emitted contract.d.ts files use this with the hash value as a type parameter:\n * `type StorageHash = StorageHashBase<'sha256:abc123...'>`\n */\nexport type StorageHashBase<THash extends string> = THash & Brand<'StorageHash'>;\n\n/**\n * Base type for execution contract hashes.\n * Emitted contract.d.ts files use this with the hash value as a type parameter:\n * `type ExecutionHash = ExecutionHashBase<'sha256:def456...'>`\n */\nexport type ExecutionHashBase<THash extends string> = THash & Brand<'ExecutionHash'>;\n\nexport function executionHash<const T extends string>(value: T): ExecutionHashBase<T> {\n  return value as ExecutionHashBase<T>;\n}\n\nexport function coreHash<const T extends string>(value: T): StorageHashBase<T> {\n  return value as StorageHashBase<T>;\n}\n\n/**\n * Base type for profile contract hashes.\n * Emitted contract.d.ts files use this with the hash value as a type parameter:\n * `type ProfileHash = ProfileHashBase<'sha256:def456...'>`\n */\nexport type ProfileHashBase<THash extends string> = THash & Brand<'ProfileHash'>;\n\nexport function profileHash<const T extends string>(value: T): ProfileHashBase<T> {\n  return value as ProfileHashBase<T>;\n}\n\n/**\n * Base type for family-specific storage blocks.\n * Family storage types (SqlStorage, MongoStorage, etc.) extend this to carry the\n * storage hash alongside family-specific data (tables, collections, etc.).\n */\nexport interface StorageBase<THash extends string = string> {\n  readonly storageHash: StorageHashBase<THash>;\n}\n\nexport interface FieldType {\n  readonly type: string;\n  readonly nullable: boolean;\n  readonly items?: FieldType;\n  readonly properties?: Record<string, FieldType>;\n}\n\nexport type GeneratedValueSpec = {\n  readonly id: string;\n  readonly params?: Record<string, unknown>;\n};\n\nexport type JsonPrimitive = string | number | boolean | null;\n\nexport type JsonValue =\n  | JsonPrimitive\n  | { readonly [key: string]: JsonValue }\n  | readonly JsonValue[];\n\nexport type ColumnDefaultLiteralValue = JsonValue;\n\nexport type ColumnDefaultLiteralInputValue = ColumnDefaultLiteralValue | Date;\n\nexport type ColumnDefault =\n  | {\n      readonly kind: 'literal';\n      readonly value: ColumnDefaultLiteralInputValue;\n    }\n  | { readonly kind: 'function'; readonly expression: string };\n\nexport type ExecutionMutationDefaultValue = {\n  readonly kind: 'generator';\n  readonly id: GeneratedValueSpec['id'];\n  readonly params?: Record<string, unknown>;\n};\n\nexport type ExecutionMutationDefault = {\n  readonly ref: { readonly table: string; readonly column: string };\n  readonly onCreate?: ExecutionMutationDefaultValue;\n  readonly onUpdate?: ExecutionMutationDefaultValue;\n};\n\nexport type ExecutionSection<THash extends string = string> = {\n  readonly executionHash: ExecutionHashBase<THash>;\n  readonly mutations: {\n    readonly defaults: ReadonlyArray<ExecutionMutationDefault>;\n  };\n};\n\nexport interface Source {\n  readonly readOnly: boolean;\n  readonly projection: Record<string, FieldType>;\n  readonly origin?: Record<string, unknown>;\n  readonly capabilities?: Record<string, boolean>;\n}\n\n// Document family types\nexport interface DocIndex {\n  readonly name: string;\n  readonly keys: Record<string, 'asc' | 'desc'>;\n  readonly unique?: boolean;\n  readonly where?: Expr;\n}\n\nexport type Expr =\n  | { readonly kind: 'eq'; readonly path: ReadonlyArray<string>; readonly value: unknown }\n  | { readonly kind: 'exists'; readonly path: ReadonlyArray<string> };\n\nexport interface DocCollection {\n  readonly name: string;\n  readonly id?: {\n    readonly strategy: 'auto' | 'client' | 'uuid' | 'objectId';\n  };\n  readonly fields: Record<string, FieldType>;\n  readonly indexes?: ReadonlyArray<DocIndex>;\n  readonly readOnly?: boolean;\n}\n\n// Plan types - target-family agnostic execution types\nexport interface ParamDescriptor {\n  readonly index?: number;\n  readonly name?: string;\n  readonly codecId?: string;\n  readonly nativeType?: string;\n  readonly nullable?: boolean;\n  readonly source: 'dsl' | 'raw' | 'lane';\n  readonly refs?: { table: string; column: string };\n}\n\nexport interface PlanRefs {\n  readonly tables?: readonly string[];\n  readonly columns?: ReadonlyArray<{ table: string; column: string }>;\n  readonly indexes?: ReadonlyArray<{\n    readonly table: string;\n    readonly columns: ReadonlyArray<string>;\n    readonly name?: string;\n  }>;\n}\n\nexport interface PlanMeta {\n  readonly target: string;\n  readonly targetFamily?: string;\n  readonly storageHash: string;\n  readonly profileHash?: string;\n  readonly lane: string;\n  readonly annotations?: {\n    codecs?: Record<string, string>; // alias/param → codec id ('ns/name@v')\n    [key: string]: unknown;\n  };\n  readonly paramDescriptors: ReadonlyArray<ParamDescriptor>;\n  readonly refs?: PlanRefs;\n  readonly projection?: Record<string, string> | ReadonlyArray<string>;\n  /**\n   * Optional mapping of projection alias → column type ID (fully qualified ns/name@version).\n   * Used for codec resolution when AST+refs don't provide enough type info.\n   */\n  readonly projectionTypes?: Record<string, string>;\n}\n\n/**\n * Canonical execution plan shape used by runtimes.\n *\n * - Row is the inferred result row type (TypeScript-only).\n * - Ast is the optional, family-specific AST type (e.g. SQL QueryAst).\n *\n * The payload executed by the runtime is represented by the sql + params pair\n * for now; future families can specialize this via Ast or additional metadata.\n */\nexport interface ExecutionPlan<Row = unknown, Ast = unknown> {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n  readonly ast?: Ast;\n  readonly meta: PlanMeta;\n  /**\n   * Phantom property to carry the Row generic for type-level utilities.\n   * Not set at runtime; used only for ResultType extraction.\n   */\n  readonly _row?: Row;\n}\n\n/**\n * Utility type to extract the Row type from an ExecutionPlan.\n * Example: `type Row = ResultType<typeof plan>`\n *\n * Works with both ExecutionPlan and SqlQueryPlan (SQL query plans before lowering).\n * SqlQueryPlan includes a phantom `_Row` property to preserve the generic parameter\n * for type extraction.\n */\nexport type ResultType<P> =\n  P extends ExecutionPlan<infer R, unknown> ? R : P extends { readonly _Row?: infer R } ? R : never;\n\n/**\n * Contract marker record stored in the database.\n * Represents the current contract identity for a database.\n */\nexport interface ContractMarkerRecord {\n  readonly storageHash: string;\n  readonly profileHash: string;\n  readonly contractJson: unknown | null;\n  readonly canonicalVersion: number | null;\n  readonly updatedAt: Date;\n  readonly appTag: string | null;\n  readonly meta: Record<string, unknown>;\n}\n"],"mappings":";AA+BA,SAAgB,cAAsC,OAAgC;AACpF,QAAO;;AAGT,SAAgB,SAAiC,OAA8B;AAC7E,QAAO;;AAUT,SAAgB,YAAoC,OAA8B;AAChF,QAAO"}

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { $ as TypesImportSpec, A as ContractBase, F as DocumentStorage, G as PlanRefs, H as ParamDescriptor, I as ExecutionPlan, J as Source, K as ResultType, L as Expr, M as DocCollection, N as DocIndex, P as DocumentContract, Q as TypeRenderer, R as FieldType, U as ParameterizedCodecDescriptor, V as OperationManifest, W as PlanMeta, X as TypeRenderContext, Y as TargetFamilyHook, Z as TypeRenderEntry, et as ValidationContext, j as ContractMarkerRecord, tt as isDocumentContract, z as GenerateContractTypesOptions } from "./framework-components-B-XOtXw3.mjs";
-export { type ContractBase, type ContractMarkerRecord, type DocCollection, type DocIndex, type DocumentContract, type DocumentStorage, type ExecutionPlan, type Expr, type FieldType, type GenerateContractTypesOptions, type OperationManifest, type ParamDescriptor, type ParameterizedCodecDescriptor, type PlanMeta, type PlanRefs, type ResultType, type Source, type TargetFamilyHook, type TypeRenderContext, type TypeRenderEntry, type TypeRenderer, type TypesImportSpec, type ValidationContext, isDocumentContract };
+import { A as executionHash, B as ContractRelationOn, C as PlanRefs, D as StorageBase, E as Source, F as ContractFieldType, G as ReferenceRelationKeys, H as ContractVariantEntry, I as ContractModel, J as ValueObjectFieldType, K as ScalarFieldType, L as ContractModelBase, M as ContractDiscriminator, N as ContractEmbedRelation, O as StorageHashBase, P as ContractField, R as ContractReferenceRelation, S as PlanMeta, T as ResultType, U as EmbedRelationKeys, V as ContractValueObject, W as ModelStorageBase, _ as FieldType, a as ColumnDefault, b as JsonValue, c as ContractMarkerRecord, d as ExecutionHashBase, f as ExecutionMutationDefault, g as Expr, h as ExecutionSection, i as Brand, j as profileHash, k as coreHash, l as DocCollection, m as ExecutionPlan, n as ContractExecutionSection, o as ColumnDefaultLiteralInputValue, p as ExecutionMutationDefaultValue, q as UnionFieldType, r as $, s as ColumnDefaultLiteralValue, t as Contract, u as DocIndex, v as GeneratedValueSpec, w as ProfileHashBase, x as ParamDescriptor, y as JsonPrimitive, z as ContractRelation } from "./contract-types-MYdoYIIh.mjs";
+export { type $, type Brand, type ColumnDefault, type ColumnDefaultLiteralInputValue, type ColumnDefaultLiteralValue, type Contract, type ContractDiscriminator, type ContractEmbedRelation, type ContractExecutionSection, type ContractField, type ContractFieldType, type ContractMarkerRecord, type ContractModel, type ContractModelBase, type ContractReferenceRelation, type ContractRelation, type ContractRelationOn, type ContractValueObject, type ContractVariantEntry, type DocCollection, type DocIndex, type EmbedRelationKeys, type ExecutionHashBase, type ExecutionMutationDefault, type ExecutionMutationDefaultValue, type ExecutionPlan, type ExecutionSection, type Expr, type FieldType, type GeneratedValueSpec, type JsonPrimitive, type JsonValue, type ModelStorageBase, type ParamDescriptor, type PlanMeta, type PlanRefs, type ProfileHashBase, type ReferenceRelationKeys, type ResultType, type ScalarFieldType, type Source, type StorageBase, type StorageHashBase, type UnionFieldType, type ValueObjectFieldType, coreHash, executionHash, profileHash };

package/dist/types.mjs

@@ -1,11 +1,3 @@
-//#region src/types.ts
-/**
-* Type guard to check if a contract is a Document contract
-*/
-function isDocumentContract(contract) {
-	return typeof contract === "object" && contract !== null && "targetFamily" in contract && contract.targetFamily === "document";
-}
+import { n as executionHash, r as profileHash, t as coreHash } from "./types-aMyNgejf.mjs";
 
-//#endregion
-export { isDocumentContract };
-//# sourceMappingURL=types.mjs.map
+export { coreHash, executionHash, profileHash };

package/dist/validate-contract.d.mts

@@ -0,0 +1,37 @@
+import { t as Contract } from "./contract-types-MYdoYIIh.mjs";
+
+//#region src/validate-contract.d.ts
+type ContractValidationPhase = 'structural' | 'domain' | 'storage';
+declare class ContractValidationError extends Error {
+  readonly code = "CONTRACT.VALIDATION_FAILED";
+  readonly phase: ContractValidationPhase;
+  constructor(message: string, phase: ContractValidationPhase);
+}
+/**
+ * Family-provided storage validator.
+ * SQL validates tables/columns/FKs; Mongo validates collections/embedding.
+ */
+type StorageValidator = (contract: Contract) => void;
+/**
+ * Framework-level contract validation (ADR 182).
+ *
+ * Three-pass validation:
+ * 1. **Structural validation** (arktype): verifies required fields exist with
+ *    correct base types.
+ * 2. **Domain validation** (framework-owned): roots, relation targets,
+ *    variant/base consistency, discriminators, ownership, orphans.
+ * 3. **Storage validation** (family-provided): SQL validates tables/columns/FKs;
+ *    Mongo validates collections/embedding.
+ *
+ * JSON persistence fields (`schemaVersion`, `_generated`) are stripped before
+ * validation — they are not part of the in-memory contract representation.
+ *
+ * @template TContract  The fully-typed contract type (preserves literal types).
+ * @param value           Raw contract value (e.g. parsed from JSON).
+ * @param storageValidator  Family-specific storage validation function.
+ * @returns The validated contract with full literal types.
+ */
+declare function validateContract<TContract extends Contract>(value: unknown, storageValidator: StorageValidator): TContract;
+//#endregion
+export { ContractValidationError, type ContractValidationPhase, type StorageValidator, validateContract };
+//# sourceMappingURL=validate-contract.d.mts.map

package/dist/validate-contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-contract.d.mts","names":[],"sources":["../src/validate-contract.ts"],"sourcesContent":[],"mappings":";;;KAKY,uBAAA;cAEC,uBAAA,SAAgC,KAAA;EAFjC,SAAA,IAAA,GAAA,4BAAuB;EAEtB,SAAA,KAAA,EAEK,uBAFmB;EAEnB,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,KAAA,EAEoB,uBAFpB;;;;AAalB;AAqDA;AAAmD,KArDvC,gBAAA,GAqDuC,CAAA,QAAA,EArDT,QAqDS,EAAA,GAAA,IAAA;;;;;;;;;;;;;;;;;;;;iBAAnC,mCAAmC,4CAE/B,mBACjB"}

package/dist/validate-contract.mjs

@@ -0,0 +1,3 @@
+import { n as ContractValidationError, r as validateContract } from "./validate-domain-CpCcTlqJ.mjs";
+
+export { ContractValidationError, validateContract };

package/dist/validate-domain-CpCcTlqJ.mjs

@@ -0,0 +1,165 @@
+import { type } from "arktype";
+
+//#region src/validate-contract.ts
+var ContractValidationError = class extends Error {
+	code = "CONTRACT.VALIDATION_FAILED";
+	phase;
+	constructor(message, phase) {
+		super(message);
+		this.name = "ContractValidationError";
+		this.phase = phase;
+	}
+};
+const ContractSchema = type({
+	target: "string",
+	targetFamily: "string",
+	roots: "Record<string, string>",
+	models: "Record<string, unknown>",
+	"valueObjects?": "Record<string, unknown>",
+	storage: "Record<string, unknown>",
+	capabilities: "Record<string, Record<string, boolean>>",
+	extensionPacks: "Record<string, unknown>",
+	meta: "Record<string, unknown>",
+	"execution?": {
+		"executionHash?": "string",
+		mutations: { defaults: "unknown[]" }
+	},
+	profileHash: "string"
+});
+function stripPersistenceFields(raw) {
+	const { schemaVersion: _, _generated: _g, ...rest } = raw;
+	return rest;
+}
+function extractDomainShape(contract) {
+	return {
+		roots: contract.roots,
+		models: contract.models,
+		...contract.valueObjects ? { valueObjects: contract.valueObjects } : {}
+	};
+}
+/**
+* Framework-level contract validation (ADR 182).
+*
+* Three-pass validation:
+* 1. **Structural validation** (arktype): verifies required fields exist with
+*    correct base types.
+* 2. **Domain validation** (framework-owned): roots, relation targets,
+*    variant/base consistency, discriminators, ownership, orphans.
+* 3. **Storage validation** (family-provided): SQL validates tables/columns/FKs;
+*    Mongo validates collections/embedding.
+*
+* JSON persistence fields (`schemaVersion`, `_generated`) are stripped before
+* validation — they are not part of the in-memory contract representation.
+*
+* @template TContract  The fully-typed contract type (preserves literal types).
+* @param value           Raw contract value (e.g. parsed from JSON).
+* @param storageValidator  Family-specific storage validation function.
+* @returns The validated contract with full literal types.
+*/
+function validateContract(value, storageValidator) {
+	if (typeof value !== "object" || value === null) throw new ContractValidationError("Contract must be a non-null object", "structural");
+	const parsed = ContractSchema(stripPersistenceFields(value));
+	if (parsed instanceof type.errors) throw new ContractValidationError(`Invalid contract structure: ${parsed.summary}`, "structural");
+	const contract = parsed;
+	validateContractDomain(extractDomainShape(contract));
+	storageValidator(contract);
+	return contract;
+}
+
+//#endregion
+//#region src/validate-domain.ts
+function validateContractDomain(contract) {
+	const errors = [];
+	const modelNames = new Set(Object.keys(contract.models));
+	validateRoots(contract, modelNames, errors);
+	validateVariantsAndBases(contract, modelNames, errors);
+	validateRelationTargets(contract, modelNames, errors);
+	validateDiscriminators(contract, errors);
+	validateOwnership(contract, modelNames, errors);
+	validateValueObjectReferences(contract, errors);
+	validateFieldModifiers(contract, errors);
+	if (errors.length > 0) throw new ContractValidationError(`Contract domain validation failed:\n- ${errors.join("\n- ")}`, "domain");
+}
+function validateRoots(contract, modelNames, errors) {
+	const seenValues = /* @__PURE__ */ new Set();
+	for (const [rootKey, modelName] of Object.entries(contract.roots)) {
+		if (seenValues.has(modelName)) errors.push(`Duplicate root value: "${modelName}" is mapped by multiple root keys`);
+		seenValues.add(modelName);
+		if (!modelNames.has(modelName)) errors.push(`Root "${rootKey}" references model "${modelName}" which does not exist in models`);
+	}
+}
+function validateVariantsAndBases(contract, modelNames, errors) {
+	const models = new Map(Object.entries(contract.models));
+	for (const [modelName, model] of models) {
+		if (model.variants) for (const variantName of Object.keys(model.variants)) {
+			if (!modelNames.has(variantName)) {
+				errors.push(`Model "${modelName}" lists variant "${variantName}" which does not exist in models`);
+				continue;
+			}
+			const variantModel = models.get(variantName);
+			if (!variantModel) continue;
+			if (variantModel.base !== modelName) errors.push(`Variant "${variantName}" has base "${variantModel.base ?? "(none)"}" but expected "${modelName}"`);
+		}
+		if (model.base) {
+			if (!modelNames.has(model.base)) {
+				errors.push(`Model "${modelName}" has base "${model.base}" which does not exist in models`);
+				continue;
+			}
+			const baseModel = models.get(model.base);
+			if (!baseModel) continue;
+			if (!baseModel.variants || !Object.hasOwn(baseModel.variants, modelName)) errors.push(`Model "${modelName}" has base "${model.base}" which does not list it as a variant`);
+		}
+	}
+}
+function validateRelationTargets(contract, modelNames, errors) {
+	for (const [modelName, model] of Object.entries(contract.models)) for (const [relName, relation] of Object.entries(model.relations ?? {})) if (!modelNames.has(relation.to)) errors.push(`Relation "${relName}" on model "${modelName}" targets "${relation.to}" which does not exist in models`);
+}
+function validateDiscriminators(contract, errors) {
+	for (const [modelName, model] of Object.entries(contract.models)) {
+		if (model.discriminator) {
+			if (!model.variants || Object.keys(model.variants).length === 0) errors.push(`Model "${modelName}" has discriminator but no variants`);
+			if (!Object.hasOwn(model.fields, model.discriminator.field)) errors.push(`Discriminator field "${model.discriminator.field}" is not a field on model "${modelName}"`);
+		}
+		if (model.variants && Object.keys(model.variants).length > 0 && !model.discriminator) errors.push(`Model "${modelName}" has variants but no discriminator`);
+		if (model.base) {
+			if (model.discriminator) errors.push(`Model "${modelName}" has base and must not have discriminator`);
+			if (model.variants && Object.keys(model.variants).length > 0) errors.push(`Model "${modelName}" has base and must not have variants`);
+		}
+	}
+}
+function validateOwnership(contract, modelNames, errors) {
+	for (const [modelName, model] of Object.entries(contract.models)) {
+		if (!model.owner) continue;
+		if (model.owner === modelName) errors.push(`Model "${modelName}" cannot own itself`);
+		if (!modelNames.has(model.owner)) errors.push(`Model "${modelName}" has owner "${model.owner}" which does not exist in models`);
+		for (const [rootKey, rootModel] of Object.entries(contract.roots)) if (rootModel === modelName) errors.push(`Owned model "${modelName}" must not appear in roots (found as root "${rootKey}")`);
+	}
+}
+function forEachContractField(contract, callback) {
+	for (const [modelName, model] of Object.entries(contract.models)) for (const [fieldName, field] of Object.entries(model.fields)) callback(field, `Model "${modelName}" field "${fieldName}"`);
+	for (const [voName, vo] of Object.entries(contract.valueObjects ?? {})) for (const [fieldName, field] of Object.entries(vo.fields)) callback(field, `Value object "${voName}" field "${fieldName}"`);
+}
+function validateValueObjectReferences(contract, errors) {
+	const voNames = new Set(Object.keys(contract.valueObjects ?? {}));
+	function checkType(type$1, location) {
+		if (!type$1) return;
+		if (type$1.kind === "valueObject" && type$1.name && !voNames.has(type$1.name)) {
+			errors.push(`${location} references value object "${type$1.name}" which does not exist in valueObjects`);
+			return;
+		}
+		if (type$1.kind === "union") for (const member of type$1.members ?? []) checkType(member, location);
+	}
+	forEachContractField(contract, (field, location) => {
+		checkType(field?.type, location);
+	});
+}
+function validateFieldModifiers(contract, errors) {
+	forEachContractField(contract, (field, location) => {
+		const f = field;
+		if (f?.many && f?.dict) errors.push(`${location} cannot have both "many" and "dict" modifiers`);
+	});
+}
+
+//#endregion
+export { ContractValidationError as n, validateContract as r, validateContractDomain as t };
+//# sourceMappingURL=validate-domain-CpCcTlqJ.mjs.map

package/dist/validate-domain-CpCcTlqJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-domain-CpCcTlqJ.mjs","names":["errors: string[]","type"],"sources":["../src/validate-contract.ts","../src/validate-domain.ts"],"sourcesContent":["import { type } from 'arktype';\nimport type { Contract } from './contract-types';\nimport type { DomainContractShape } from './validate-domain';\nimport { validateContractDomain } from './validate-domain';\n\nexport type ContractValidationPhase = 'structural' | 'domain' | 'storage';\n\nexport class ContractValidationError extends Error {\n  readonly code = 'CONTRACT.VALIDATION_FAILED';\n  readonly phase: ContractValidationPhase;\n\n  constructor(message: string, phase: ContractValidationPhase) {\n    super(message);\n    this.name = 'ContractValidationError';\n    this.phase = phase;\n  }\n}\n\n/**\n * Family-provided storage validator.\n * SQL validates tables/columns/FKs; Mongo validates collections/embedding.\n */\nexport type StorageValidator = (contract: Contract) => void;\n\nconst ContractSchema = type({\n  target: 'string',\n  targetFamily: 'string',\n  roots: 'Record<string, string>',\n  models: 'Record<string, unknown>',\n  'valueObjects?': 'Record<string, unknown>',\n  storage: 'Record<string, unknown>',\n  capabilities: 'Record<string, Record<string, boolean>>',\n  extensionPacks: 'Record<string, unknown>',\n  meta: 'Record<string, unknown>',\n  'execution?': {\n    'executionHash?': 'string',\n    mutations: {\n      defaults: 'unknown[]',\n    },\n  },\n  profileHash: 'string',\n});\n\nfunction stripPersistenceFields(raw: Record<string, unknown>): Record<string, unknown> {\n  const { schemaVersion: _, _generated: _g, ...rest } = raw;\n  return rest;\n}\n\nfunction extractDomainShape(contract: Contract): DomainContractShape {\n  return {\n    roots: contract.roots,\n    models: contract.models,\n    ...(contract.valueObjects ? { valueObjects: contract.valueObjects } : {}),\n  };\n}\n\n/**\n * Framework-level contract validation (ADR 182).\n *\n * Three-pass validation:\n * 1. **Structural validation** (arktype): verifies required fields exist with\n *    correct base types.\n * 2. **Domain validation** (framework-owned): roots, relation targets,\n *    variant/base consistency, discriminators, ownership, orphans.\n * 3. **Storage validation** (family-provided): SQL validates tables/columns/FKs;\n *    Mongo validates collections/embedding.\n *\n * JSON persistence fields (`schemaVersion`, `_generated`) are stripped before\n * validation — they are not part of the in-memory contract representation.\n *\n * @template TContract  The fully-typed contract type (preserves literal types).\n * @param value           Raw contract value (e.g. parsed from JSON).\n * @param storageValidator  Family-specific storage validation function.\n * @returns The validated contract with full literal types.\n */\nexport function validateContract<TContract extends Contract>(\n  value: unknown,\n  storageValidator: StorageValidator,\n): TContract {\n  if (typeof value !== 'object' || value === null) {\n    throw new ContractValidationError('Contract must be a non-null object', 'structural');\n  }\n\n  const stripped = stripPersistenceFields(value as Record<string, unknown>);\n\n  const parsed = ContractSchema(stripped);\n  if (parsed instanceof type.errors) {\n    throw new ContractValidationError(\n      `Invalid contract structure: ${parsed.summary}`,\n      'structural',\n    );\n  }\n\n  const contract = parsed as unknown as Contract;\n\n  validateContractDomain(extractDomainShape(contract));\n\n  storageValidator(contract);\n\n  return contract as unknown as TContract;\n}\n","import { ContractValidationError } from './validate-contract';\n\nexport interface DomainModelShape {\n  readonly fields: Record<string, unknown>;\n  readonly relations?: Record<string, { readonly to: string }>;\n  readonly discriminator?: { readonly field: string };\n  readonly variants?: Record<string, unknown>;\n  readonly base?: string;\n  readonly owner?: string;\n}\n\nexport interface DomainContractShape {\n  readonly roots: Record<string, string>;\n  readonly models: Record<string, DomainModelShape>;\n  readonly valueObjects?: Record<string, { readonly fields: Record<string, unknown> }>;\n}\n\nexport function validateContractDomain(contract: DomainContractShape): void {\n  const errors: string[] = [];\n  const modelNames = new Set(Object.keys(contract.models));\n\n  validateRoots(contract, modelNames, errors);\n  validateVariantsAndBases(contract, modelNames, errors);\n  validateRelationTargets(contract, modelNames, errors);\n  validateDiscriminators(contract, errors);\n  validateOwnership(contract, modelNames, errors);\n  validateValueObjectReferences(contract, errors);\n  validateFieldModifiers(contract, errors);\n\n  if (errors.length > 0) {\n    throw new ContractValidationError(\n      `Contract domain validation failed:\\n- ${errors.join('\\n- ')}`,\n      'domain',\n    );\n  }\n}\n\nfunction validateRoots(\n  contract: DomainContractShape,\n  modelNames: Set<string>,\n  errors: string[],\n): void {\n  const seenValues = new Set<string>();\n  for (const [rootKey, modelName] of Object.entries(contract.roots)) {\n    if (seenValues.has(modelName)) {\n      errors.push(`Duplicate root value: \"${modelName}\" is mapped by multiple root keys`);\n    }\n    seenValues.add(modelName);\n\n    if (!modelNames.has(modelName)) {\n      errors.push(\n        `Root \"${rootKey}\" references model \"${modelName}\" which does not exist in models`,\n      );\n    }\n  }\n}\n\nfunction validateVariantsAndBases(\n  contract: DomainContractShape,\n  modelNames: Set<string>,\n  errors: string[],\n): void {\n  const models = new Map(Object.entries(contract.models));\n\n  for (const [modelName, model] of models) {\n    if (model.variants) {\n      for (const variantName of Object.keys(model.variants)) {\n        if (!modelNames.has(variantName)) {\n          errors.push(\n            `Model \"${modelName}\" lists variant \"${variantName}\" which does not exist in models`,\n          );\n          continue;\n        }\n        const variantModel = models.get(variantName);\n        if (!variantModel) continue;\n        if (variantModel.base !== modelName) {\n          errors.push(\n            `Variant \"${variantName}\" has base \"${variantModel.base ?? '(none)'}\" but expected \"${modelName}\"`,\n          );\n        }\n      }\n    }\n\n    if (model.base) {\n      if (!modelNames.has(model.base)) {\n        errors.push(`Model \"${modelName}\" has base \"${model.base}\" which does not exist in models`);\n        continue;\n      }\n      const baseModel = models.get(model.base);\n      if (!baseModel) continue;\n      if (!baseModel.variants || !Object.hasOwn(baseModel.variants, modelName)) {\n        errors.push(\n          `Model \"${modelName}\" has base \"${model.base}\" which does not list it as a variant`,\n        );\n      }\n    }\n  }\n}\n\nfunction validateRelationTargets(\n  contract: DomainContractShape,\n  modelNames: Set<string>,\n  errors: string[],\n): void {\n  for (const [modelName, model] of Object.entries(contract.models)) {\n    for (const [relName, relation] of Object.entries(model.relations ?? {})) {\n      if (!modelNames.has(relation.to)) {\n        errors.push(\n          `Relation \"${relName}\" on model \"${modelName}\" targets \"${relation.to}\" which does not exist in models`,\n        );\n      }\n    }\n  }\n}\n\nfunction validateDiscriminators(contract: DomainContractShape, errors: string[]): void {\n  for (const [modelName, model] of Object.entries(contract.models)) {\n    if (model.discriminator) {\n      if (!model.variants || Object.keys(model.variants).length === 0) {\n        errors.push(`Model \"${modelName}\" has discriminator but no variants`);\n      }\n      if (!Object.hasOwn(model.fields, model.discriminator.field)) {\n        errors.push(\n          `Discriminator field \"${model.discriminator.field}\" is not a field on model \"${modelName}\"`,\n        );\n      }\n    }\n\n    if (model.variants && Object.keys(model.variants).length > 0 && !model.discriminator) {\n      errors.push(`Model \"${modelName}\" has variants but no discriminator`);\n    }\n\n    if (model.base) {\n      if (model.discriminator) {\n        errors.push(`Model \"${modelName}\" has base and must not have discriminator`);\n      }\n      if (model.variants && Object.keys(model.variants).length > 0) {\n        errors.push(`Model \"${modelName}\" has base and must not have variants`);\n      }\n    }\n  }\n}\n\nfunction validateOwnership(\n  contract: DomainContractShape,\n  modelNames: Set<string>,\n  errors: string[],\n): void {\n  for (const [modelName, model] of Object.entries(contract.models)) {\n    if (!model.owner) continue;\n\n    if (model.owner === modelName) {\n      errors.push(`Model \"${modelName}\" cannot own itself`);\n    }\n\n    if (!modelNames.has(model.owner)) {\n      errors.push(`Model \"${modelName}\" has owner \"${model.owner}\" which does not exist in models`);\n    }\n\n    for (const [rootKey, rootModel] of Object.entries(contract.roots)) {\n      if (rootModel === modelName) {\n        errors.push(\n          `Owned model \"${modelName}\" must not appear in roots (found as root \"${rootKey}\")`,\n        );\n      }\n    }\n  }\n}\n\ninterface FieldTypeLike {\n  readonly kind?: string;\n  readonly name?: string;\n  readonly members?: readonly FieldTypeLike[];\n}\n\ninterface FieldLike {\n  readonly type?: FieldTypeLike;\n  readonly many?: boolean;\n  readonly dict?: boolean;\n}\n\nfunction forEachContractField(\n  contract: DomainContractShape,\n  callback: (field: unknown, location: string) => void,\n): void {\n  for (const [modelName, model] of Object.entries(contract.models)) {\n    for (const [fieldName, field] of Object.entries(model.fields)) {\n      callback(field, `Model \"${modelName}\" field \"${fieldName}\"`);\n    }\n  }\n  for (const [voName, vo] of Object.entries(contract.valueObjects ?? {})) {\n    for (const [fieldName, field] of Object.entries(vo.fields)) {\n      callback(field, `Value object \"${voName}\" field \"${fieldName}\"`);\n    }\n  }\n}\n\nfunction validateValueObjectReferences(contract: DomainContractShape, errors: string[]): void {\n  const voNames = new Set(Object.keys(contract.valueObjects ?? {}));\n\n  function checkType(type: FieldTypeLike | undefined, location: string): void {\n    if (!type) return;\n    if (type.kind === 'valueObject' && type.name && !voNames.has(type.name)) {\n      errors.push(\n        `${location} references value object \"${type.name}\" which does not exist in valueObjects`,\n      );\n      return;\n    }\n    if (type.kind === 'union') {\n      for (const member of type.members ?? []) checkType(member, location);\n    }\n  }\n\n  forEachContractField(contract, (field, location) => {\n    const f = field as FieldLike | undefined;\n    checkType(f?.type, location);\n  });\n}\n\nfunction validateFieldModifiers(contract: DomainContractShape, errors: string[]): void {\n  forEachContractField(contract, (field, location) => {\n    const f = field as FieldLike | undefined;\n    if (f?.many && f?.dict) {\n      errors.push(`${location} cannot have both \"many\" and \"dict\" modifiers`);\n    }\n  });\n}\n"],"mappings":"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"}

package/dist/validate-domain.d.mts

@@ -0,0 +1,24 @@
+//#region src/validate-domain.d.ts
+interface DomainModelShape {
+  readonly fields: Record<string, unknown>;
+  readonly relations?: Record<string, {
+    readonly to: string;
+  }>;
+  readonly discriminator?: {
+    readonly field: string;
+  };
+  readonly variants?: Record<string, unknown>;
+  readonly base?: string;
+  readonly owner?: string;
+}
+interface DomainContractShape {
+  readonly roots: Record<string, string>;
+  readonly models: Record<string, DomainModelShape>;
+  readonly valueObjects?: Record<string, {
+    readonly fields: Record<string, unknown>;
+  }>;
+}
+declare function validateContractDomain(contract: DomainContractShape): void;
+//#endregion
+export { type DomainContractShape, type DomainModelShape, validateContractDomain };
+//# sourceMappingURL=validate-domain.d.mts.map

package/dist/validate-domain.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-domain.d.mts","names":[],"sources":["../src/validate-domain.ts"],"sourcesContent":[],"mappings":";UAEiB,gBAAA;EAAA,SAAA,MAAA,EACE,MADc,CAAA,MAAA,EAAA,OAAA,CAAA;EACd,SAAA,SAAA,CAAA,EACI,MADJ,CAAA,MAAA,EAAA;IACI,SAAA,EAAA,EAAA,MAAA;EAED,CAAA,CAAA;EAAM,SAAA,aAAA,CAAA,EAAA;IAKX,SAAA,KAAA,EAAA,MAAmB;EAClB,CAAA;EACgB,SAAA,QAAA,CAAA,EAPZ,MAOY,CAAA,MAAA,EAAA,OAAA,CAAA;EAAf,SAAA,IAAA,CAAA,EAAA,MAAA;EACyC,SAAA,KAAA,CAAA,EAAA,MAAA;;AAA5B,UAHf,mBAAA,CAGe;EAGhB,SAAA,KAAA,EALE,MAKF,CAAA,MAAsB,EAAA,MAAW,CAAA;mBAJ9B,eAAe;0BACR;qBAAkC;;;iBAG5C,sBAAA,WAAiC"}

package/dist/validate-domain.mjs

@@ -0,0 +1,3 @@
+import { t as validateContractDomain } from "./validate-domain-CpCcTlqJ.mjs";
+
+export { validateContractDomain };

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "@prisma-next/contract",
-  "version": "0.3.0-pr.99.5",
+  "version": "0.3.0",
   "type": "module",
   "sideEffects": false,
   "description": "Data contract type definitions and JSON schema for Prisma Next",
   "dependencies": {
-    "@prisma-next/operations": "0.3.0-pr.99.5"
+    "arktype": "^2.1.29",
+    "@prisma-next/utils": "0.3.0"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
-    "vitest": "4.0.16",
-    "@prisma-next/test-utils": "0.0.1",
+    "vitest": "4.0.17",
     "@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",
@@ -24,12 +25,18 @@
     "node": ">=20"
   },
   "exports": {
-    "./framework-components": "./dist/framework-components.mjs",
-    "./ir": "./dist/ir.mjs",
-    "./pack-manifest-types": "./dist/pack-manifest-types.mjs",
+    "./hashing": "./dist/hashing.mjs",
+    "./testing": "./dist/testing.mjs",
     "./types": "./dist/types.mjs",
+    "./validate-contract": "./dist/validate-contract.mjs",
+    "./validate-domain": "./dist/validate-domain.mjs",
     "./package.json": "./package.json"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/1-framework/0-foundation/contract"
+  },
   "scripts": {
     "build": "tsdown",
     "test": "vitest run --passWithNoTests",

package/schemas/data-contract-document-v1.json

@@ -24,10 +24,10 @@
       "enum": ["document"],
       "description": "Target family classification"
     },
-    "coreHash": {
+    "storageHash": {
       "type": "string",
       "pattern": "^sha256:[a-f0-9]{64}$",
-      "description": "SHA-256 hash of the core schema structure (models, fields, relations, storage layout)"
+      "description": "SHA-256 hash of the storage section (DB-satisfied expectations)"
     },
     "profileHash": {
       "type": "string",
@@ -44,7 +44,7 @@
         }
       }
     },
-    "extensions": {
+    "extensionPacks": {
       "type": "object",
       "description": "Extension packs and their configuration",
       "additionalProperties": true
@@ -85,7 +85,7 @@
       "required": ["document"]
     }
   },
-  "required": ["schemaVersion", "target", "targetFamily", "coreHash", "storage"],
+  "required": ["schemaVersion", "target", "targetFamily", "storageHash", "storage"],
   "$defs": {
     "DocCollection": {
       "type": "object",
@@ -103,7 +103,7 @@
           "properties": {
             "strategy": {
               "type": "string",
-              "enum": ["auto", "client", "uuid", "cuid", "objectId"],
+              "enum": ["auto", "client", "uuid", "objectId"],
               "description": "ID generation strategy"
             }
           }