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

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport type { DomainModel } from './domain-types';\nimport type { ContractIR } from './ir';\n\n/**\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 * Context passed to type renderers during contract.d.ts generation.\n */\nexport interface RenderTypeContext {\n  /** The name of the CodecTypes type alias (typically 'CodecTypes') */\n  readonly codecTypesName: string;\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 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\nexport interface ContractBase<\n  TStorageHash extends StorageHashBase<string> = StorageHashBase<string>,\n  TExecutionHash extends ExecutionHashBase<string> = ExecutionHashBase<string>,\n  TProfileHash extends ProfileHashBase<string> = ProfileHashBase<string>,\n  TModels extends Record<string, unknown> = Record<string, DomainModel>,\n> {\n  readonly schemaVersion: string;\n  readonly target: string;\n  readonly targetFamily: string;\n  readonly storageHash: TStorageHash;\n  readonly executionHash?: TExecutionHash | undefined;\n  readonly profileHash?: TProfileHash | undefined;\n  readonly capabilities: Record<string, Record<string, boolean>>;\n  readonly extensionPacks: Record<string, unknown>;\n  readonly meta: Record<string, unknown>;\n  readonly sources: Record<string, Source>;\n  readonly execution?: ExecutionSection;\n  readonly roots: Record<string, string>;\n  readonly models: TModels;\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 TaggedBigInt = { readonly $type: 'bigint'; readonly value: string };\n\nexport function isTaggedBigInt(value: unknown): value is TaggedBigInt {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { $type?: unknown }).$type === 'bigint' &&\n    typeof (value as { value?: unknown }).value === 'string'\n  );\n}\n\nexport function bigintJsonReplacer(_key: string, value: unknown): unknown {\n  if (typeof value === 'bigint') {\n    return { $type: 'bigint', value: value.toString() } satisfies TaggedBigInt;\n  }\n  return value;\n}\n\nexport type TaggedRaw = { readonly $type: 'raw'; readonly value: JsonValue };\n\nexport function isTaggedRaw(value: unknown): value is TaggedRaw {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { $type?: unknown }).$type === 'raw' &&\n    'value' in (value as object)\n  );\n}\n\nexport type TaggedLiteralValue = TaggedBigInt | TaggedRaw;\n\nexport type ColumnDefaultLiteralValue = JsonValue | TaggedLiteralValue;\n\nexport type ColumnDefaultLiteralInputValue = ColumnDefaultLiteralValue | bigint | 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 = {\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\nexport interface DocumentStorage {\n  readonly document: {\n    readonly collections: Record<string, DocCollection>;\n  };\n}\n\nexport interface DocumentContract<\n  TStorageHash extends StorageHashBase<string> = StorageHashBase<string>,\n  TExecutionHash extends ExecutionHashBase<string> = ExecutionHashBase<string>,\n  TProfileHash extends ProfileHashBase<string> = ProfileHashBase<string>,\n> extends ContractBase<TStorageHash, TExecutionHash, TProfileHash> {\n  // Accept string to work with JSON imports; runtime validation ensures 'document'\n  readonly targetFamily: string;\n  readonly storage: DocumentStorage;\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 * Type guard to check if a contract is a Document contract\n */\nexport function isDocumentContract(contract: unknown): contract is DocumentContract {\n  return (\n    typeof contract === 'object' &&\n    contract !== null &&\n    'targetFamily' in contract &&\n    contract.targetFamily === 'document'\n  );\n}\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\n// Emitter types - moved from @prisma-next/emitter to shared location\n/**\n * Specifies how to import TypeScript types from a package.\n * Used in extension pack manifests to declare codec and operation type imports.\n */\nexport interface TypesImportSpec {\n  readonly package: string;\n  readonly named: string;\n  readonly alias: string;\n}\n\n/**\n * Validation context passed to TargetFamilyHook.validateTypes().\n * Contains pre-assembled operation registry, type imports, and extension IDs.\n */\nexport interface ValidationContext {\n  readonly operationRegistry?: OperationRegistry;\n  readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;\n  readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;\n  readonly extensionIds?: ReadonlyArray<string>;\n  /**\n   * Parameterized codec descriptors collected from adapters and extensions.\n   * Map of codecId → descriptor for quick lookup during type generation.\n   */\n  readonly parameterizedCodecs?: Map<string, ParameterizedCodecDescriptor>;\n}\n\n/**\n * Context for rendering parameterized types during contract.d.ts generation.\n * Passed to type renderers so they can reference CodecTypes by name.\n */\nexport interface TypeRenderContext {\n  readonly codecTypesName: string;\n}\n\n/**\n * A normalized type renderer for parameterized codecs.\n * This is the interface expected by TargetFamilyHook.generateContractTypes.\n */\nexport interface TypeRenderEntry {\n  readonly codecId: string;\n  readonly render: (params: Record<string, unknown>, ctx: TypeRenderContext) => string;\n}\n\n/**\n * Additional options for generateContractTypes.\n */\nexport interface GenerateContractTypesOptions {\n  /**\n   * Normalized parameterized type renderers, keyed by codecId.\n   * When a column has typeParams and a renderer exists for its codecId,\n   * the renderer is called to produce the TypeScript type expression.\n   */\n  readonly parameterizedRenderers?: Map<string, TypeRenderEntry>;\n  /**\n   * Type imports for parameterized codecs.\n   * These are merged with codec and operation type imports in contract.d.ts.\n   */\n  readonly parameterizedTypeImports?: ReadonlyArray<TypesImportSpec>;\n  /**\n   * Query operation type imports for the query builder.\n   * Flat operation signatures keyed by operation name, emitted as standalone QueryOperationTypes.\n   */\n  readonly queryOperationTypeImports?: ReadonlyArray<TypesImportSpec>;\n}\n\n/**\n * SPI interface for target family hooks that extend emission behavior.\n * Implemented by family-specific emitter hooks (e.g., SQL family).\n */\nexport interface TargetFamilyHook {\n  readonly id: string;\n\n  /**\n   * Validates that all type IDs in the contract come from referenced extension packs.\n   * @param ir - Contract IR to validate\n   * @param ctx - Validation context with operation registry and extension IDs\n   */\n  validateTypes(ir: ContractIR, ctx: ValidationContext): void;\n\n  /**\n   * Validates family-specific contract structure.\n   * @param ir - Contract IR to validate\n   */\n  validateStructure(ir: ContractIR): void;\n\n  /**\n   * Generates contract.d.ts file content.\n   * @param ir - Contract IR\n   * @param codecTypeImports - Array of codec type import specs\n   * @param operationTypeImports - Array of operation type import specs\n   * @param hashes - Contract hash values (storageHash, executionHash, profileHash)\n   * @param options - Additional options including parameterized type renderers\n   * @returns Generated TypeScript type definitions as string\n   */\n  generateContractTypes(\n    ir: ContractIR,\n    codecTypeImports: ReadonlyArray<TypesImportSpec>,\n    operationTypeImports: ReadonlyArray<TypesImportSpec>,\n    hashes: {\n      readonly storageHash: string;\n      readonly executionHash?: string;\n      readonly profileHash: string;\n    },\n    options?: GenerateContractTypesOptions,\n  ): string;\n}\n\n// ============================================================================\n// Parameterized Codec Descriptor Types\n// ============================================================================\n//\n// Types for codecs that support type parameters (e.g., Vector<1536>, Decimal<2>).\n// These enable precise TypeScript types for parameterized columns without\n// coupling the SQL family emitter to specific adapter codec IDs.\n//\n// ============================================================================\n\n/**\n * Declarative type renderer that produces a TypeScript type expression.\n *\n * Renderers can be:\n * - A template string with `{{paramName}}` placeholders (e.g., `Vector<{{length}}>`)\n * - A function that receives typeParams and context and returns a type expression\n *\n * **Prefer template strings** for most cases:\n * - Templates are JSON-serializable (safe for pack-ref metadata)\n * - Templates can be statically analyzed by tooling\n *\n * Function renderers are allowed but have tradeoffs:\n * - Require runtime execution during emission (the emitter runs code)\n * - Not JSON-serializable (can't be stored in contract.json)\n * - The emitted artifacts (contract.json, contract.d.ts) still contain no\n *   executable code - this constraint applies to outputs, not the emission process\n */\nexport type TypeRenderer =\n  | string\n  | ((params: Record<string, unknown>, ctx: RenderTypeContext) => string);\n\n/**\n * Descriptor for a codec that supports type parameters.\n *\n * Parameterized codecs allow columns to carry additional metadata (typeParams)\n * that affects the generated TypeScript types. For example:\n * - A vector codec can use `{ length: 1536 }` to generate `Vector<1536>`\n * - A decimal codec can use `{ precision: 10, scale: 2 }` to generate `Decimal<10, 2>`\n *\n * The SQL family emitter uses these descriptors to generate precise types\n * without hard-coding knowledge of specific codec IDs.\n *\n * @example\n * ```typescript\n * const vectorCodecDescriptor: ParameterizedCodecDescriptor = {\n *   codecId: 'pg/vector@1',\n *   outputTypeRenderer: 'Vector<{{length}}>',\n *   // Optional: paramsSchema for runtime validation\n * };\n * ```\n */\nexport interface ParameterizedCodecDescriptor {\n  /** The codec ID this descriptor applies to (e.g., 'pg/vector@1') */\n  readonly codecId: string;\n\n  /**\n   * Renderer for the output (read) type.\n   * Can be a template string or function.\n   *\n   * This is the primary renderer used by SQL emission to generate\n   * model field types in contract.d.ts.\n   */\n  readonly outputTypeRenderer: TypeRenderer;\n\n  /**\n   * Optional renderer for the input (write) type.\n   * If not provided, outputTypeRenderer is used for both.\n   *\n   * **Reserved for future use**: Currently, SQL emission only uses\n   * outputTypeRenderer. This field is defined for future support of\n   * asymmetric codecs where input and output types differ (e.g., a\n   * codec that accepts `string | number` but always returns `number`).\n   */\n  readonly inputTypeRenderer?: TypeRenderer;\n\n  /**\n   * Optional import spec for types used by this codec's renderers.\n   * The emitter will add this import to contract.d.ts.\n   */\n  readonly typesImport?: TypesImportSpec;\n}\n"],"mappings":";AA2CA,SAAgB,SAAiC,OAA8B;AAC7E,QAAO;;AAUT,SAAgB,YAAoC,OAA8B;AAChF,QAAO;;AA6CT,SAAgB,eAAe,OAAuC;AACpE,QACE,OAAO,UAAU,YACjB,UAAU,QACT,MAA8B,UAAU,YACzC,OAAQ,MAA8B,UAAU;;AAIpD,SAAgB,mBAAmB,MAAc,OAAyB;AACxE,KAAI,OAAO,UAAU,SACnB,QAAO;EAAE,OAAO;EAAU,OAAO,MAAM,UAAU;EAAE;AAErD,QAAO;;AAKT,SAAgB,YAAY,OAAoC;AAC9D,QACE,OAAO,UAAU,YACjB,UAAU,QACT,MAA8B,UAAU,SACzC,WAAY;;;;;AA4JhB,SAAgB,mBAAmB,UAAiD;AAClF,QACE,OAAO,aAAa,YACpB,aAAa,QACb,kBAAkB,YAClB,SAAS,iBAAiB"}

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>;
+}
+interface DomainValidationResult {
+  readonly warnings: string[];
+}
+declare function validateContractDomain(contract: DomainContractShape): DomainValidationResult;
+//#endregion
+export { type DomainContractShape, type DomainModelShape, type DomainValidationResult, 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":";UAAiB,gBAAA;EAAA,SAAA,MAAA,EACE,MADc,CAAA,MAAA,EAAA,OAAA,CAAA;EACd,SAAA,SAAA,EACG,MADH,CAAA,MAAA,EAAA;IACG,SAAA,EAAA,EAAA,MAAA;EAEA,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;EAAM,SAAA,KAAA,CAAA,EAAA,MAAA;AAGzB;AAIgB,UATC,mBAAA,CASqB;kBARpB;mBACC,eAAe;;UAGjB,sBAAA;;;iBAID,sBAAA,WAAiC,sBAAsB"}

package/dist/validate-domain.mjs

@@ -0,0 +1,83 @@
+//#region src/validate-domain.ts
+function validateContractDomain(contract) {
+	const errors = [];
+	const warnings = [];
+	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);
+	detectOrphanedModels(contract, modelNames, warnings);
+	if (errors.length > 0) throw new Error(`Contract domain validation failed:\n- ${errors.join("\n- ")}`);
+	return { warnings };
+}
+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) {
+	for (const [modelName, model] of Object.entries(contract.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 = contract.models[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 = contract.models[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 detectOrphanedModels(contract, modelNames, warnings) {
+	const referenced = /* @__PURE__ */ new Set();
+	for (const modelName of Object.values(contract.roots)) referenced.add(modelName);
+	for (const [modelName, model] of Object.entries(contract.models)) {
+		for (const relation of Object.values(model.relations)) referenced.add(relation.to);
+		if (model.variants) for (const variantName of Object.keys(model.variants)) referenced.add(variantName);
+		if (model.base) referenced.add(model.base);
+		if (model.owner) referenced.add(modelName);
+	}
+	for (const modelName of modelNames) if (!referenced.has(modelName)) warnings.push(`Orphaned model: "${modelName}" is not referenced by any root, relation, or variant`);
+}
+
+//#endregion
+export { validateContractDomain };
+//# sourceMappingURL=validate-domain.mjs.map

package/dist/validate-domain.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-domain.mjs","names":["errors: string[]","warnings: string[]"],"sources":["../src/validate-domain.ts"],"sourcesContent":["export 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}\n\nexport interface DomainValidationResult {\n  readonly warnings: string[];\n}\n\nexport function validateContractDomain(contract: DomainContractShape): DomainValidationResult {\n  const errors: string[] = [];\n  const warnings: 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  detectOrphanedModels(contract, modelNames, warnings);\n\n  if (errors.length > 0) {\n    throw new Error(`Contract domain validation failed:\\n- ${errors.join('\\n- ')}`);\n  }\n\n  return { warnings };\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  for (const [modelName, model] of Object.entries(contract.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 = contract.models[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 = contract.models[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\nfunction detectOrphanedModels(\n  contract: DomainContractShape,\n  modelNames: Set<string>,\n  warnings: string[],\n): void {\n  const referenced = new Set<string>();\n\n  for (const modelName of Object.values(contract.roots)) {\n    referenced.add(modelName);\n  }\n\n  for (const [modelName, model] of Object.entries(contract.models)) {\n    for (const relation of Object.values(model.relations)) {\n      referenced.add(relation.to);\n    }\n    if (model.variants) {\n      for (const variantName of Object.keys(model.variants)) {\n        referenced.add(variantName);\n      }\n    }\n    if (model.base) {\n      referenced.add(model.base);\n    }\n    if (model.owner) {\n      referenced.add(modelName);\n    }\n  }\n\n  for (const modelName of modelNames) {\n    if (!referenced.has(modelName)) {\n      warnings.push(\n        `Orphaned model: \"${modelName}\" is not referenced by any root, relation, or variant`,\n      );\n    }\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,51 +1,48 @@
 {
   "name": "@prisma-next/contract",
-  "version": "0.3.0-dev.13",
+  "version": "0.3.0-dev.130",
   "type": "module",
   "sideEffects": false,
   "description": "Data contract type definitions and JSON schema for Prisma Next",
   "dependencies": {
-    "@prisma-next/operations": "0.3.0-dev.13"
+    "@prisma-next/operations": "0.3.0-dev.130"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "4.0.16",
-    "tsup": "8.5.1",
+    "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/test-utils": "0.0.1",
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",
     "src",
     "schemas"
   ],
+  "engines": {
+    "node": ">=20"
+  },
   "exports": {
-    "./types": {
-      "types": "./dist/exports/types.d.ts",
-      "import": "./dist/exports/types.js"
-    },
-    "./pack-manifest-types": {
-      "types": "./dist/exports/pack-manifest-types.d.ts",
-      "import": "./dist/exports/pack-manifest-types.js"
-    },
-    "./ir": {
-      "types": "./dist/exports/ir.d.ts",
-      "import": "./dist/exports/ir.js"
-    },
-    "./framework-components": {
-      "types": "./dist/exports/framework-components.d.ts",
-      "import": "./dist/exports/framework-components.js"
-    },
-    "./schema-document": "./schemas/data-contract-document-v1.json"
+    "./framework-components": "./dist/framework-components.mjs",
+    "./ir": "./dist/ir.mjs",
+    "./types": "./dist/types.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/1-core/shared/contract"
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
+    "build": "tsdown",
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests",
     "typecheck": "tsc --project tsconfig.json --noEmit",
     "lint": "biome check . --error-on-warnings",
     "lint:fix": "biome check --write .",
     "lint:fix:unsafe": "biome check --write --unsafe .",
-    "clean": "node ../../../../../scripts/clean.mjs"
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

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

@@ -24,10 +24,15 @@
       "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)"
+    },
+    "executionHash": {
+      "type": "string",
+      "pattern": "^sha256:[a-f0-9]{64}$",
+      "description": "SHA-256 hash of the execution section (client-side behavior)"
     },
     "profileHash": {
       "type": "string",
@@ -85,7 +90,7 @@
       "required": ["document"]
     }
   },
-  "required": ["schemaVersion", "target", "targetFamily", "coreHash", "storage"],
+  "required": ["schemaVersion", "target", "targetFamily", "storageHash", "storage"],
   "$defs": {
     "DocCollection": {
       "type": "object",
@@ -103,7 +108,7 @@
           "properties": {
             "strategy": {
               "type": "string",
-              "enum": ["auto", "client", "uuid", "cuid", "objectId"],
+              "enum": ["auto", "client", "uuid", "objectId"],
               "description": "ID generation strategy"
             }
           }

package/src/domain-types.ts

@@ -0,0 +1,62 @@
+export type DomainField = {
+  readonly nullable: boolean;
+  readonly codecId: string;
+};
+
+export type DomainRelationOn = {
+  readonly localFields: readonly string[];
+  readonly targetFields: readonly string[];
+};
+
+export type DomainReferenceRelation = {
+  readonly to: string;
+  readonly cardinality: '1:1' | '1:N' | 'N:1';
+  readonly on: DomainRelationOn;
+};
+
+export type DomainEmbedRelation = {
+  readonly to: string;
+  readonly cardinality: '1:1' | '1:N';
+};
+
+export type DomainRelation = DomainReferenceRelation | DomainEmbedRelation;
+
+export type DomainDiscriminator = {
+  readonly field: string;
+};
+
+export type DomainVariantEntry = {
+  readonly value: string;
+};
+
+export type DomainModel = {
+  readonly fields: Record<string, DomainField>;
+  readonly relations: Record<string, DomainRelation>;
+  readonly storage: Record<string, unknown>;
+  readonly discriminator?: DomainDiscriminator;
+  readonly variants?: Record<string, DomainVariantEntry>;
+  readonly base?: string;
+  readonly owner?: string;
+};
+
+type HasModelsWithRelations = {
+  readonly models: Record<string, { readonly relations: Record<string, DomainRelation> }>;
+};
+
+export type ReferenceRelationKeys<
+  TContract extends HasModelsWithRelations,
+  ModelName extends string & keyof TContract['models'],
+> = {
+  [K in keyof TContract['models'][ModelName]['relations']]: TContract['models'][ModelName]['relations'][K] extends DomainReferenceRelation
+    ? K
+    : never;
+}[keyof TContract['models'][ModelName]['relations']];
+
+export type EmbedRelationKeys<
+  TContract extends HasModelsWithRelations,
+  ModelName extends string & keyof TContract['models'],
+> = {
+  [K in keyof TContract['models'][ModelName]['relations']]: TContract['models'][ModelName]['relations'][K] extends DomainReferenceRelation
+    ? never
+    : K;
+}[keyof TContract['models'][ModelName]['relations']];

package/src/exports/framework-components.ts

@@ -16,11 +16,20 @@ export type {
   ExtensionPackRef,
   FamilyDescriptor,
   FamilyInstance,
+  // Type renderers for parameterized codec emission
+  NormalizedTypeRenderer,
   PackRefBase,
   TargetBoundComponentDescriptor,
   TargetDescriptor,
   TargetInstance,
   TargetPackRef,
+  TypeRenderer,
+  TypeRendererFunction,
+  TypeRendererTemplate,
 } from '../framework-components';
 
-export { checkContractComponentRequirements } from '../framework-components';
+export {
+  checkContractComponentRequirements,
+  interpolateTypeTemplate,
+  normalizeRenderer,
+} from '../framework-components';

package/src/exports/types.ts

@@ -1,26 +1,62 @@
-// Shared types
-// Document family types
-// Plan types - target-family agnostic execution types
-// Emitter types (moved from @prisma-next/emitter)
 export type {
+  DomainDiscriminator,
+  DomainEmbedRelation,
+  DomainField,
+  DomainModel,
+  DomainReferenceRelation,
+  DomainRelation,
+  DomainRelationOn,
+  DomainVariantEntry,
+  EmbedRelationKeys,
+  ReferenceRelationKeys,
+} from '../domain-types';
+export type {
+  $,
+  Brand,
+  ColumnDefault,
+  ColumnDefaultLiteralInputValue,
+  ColumnDefaultLiteralValue,
   ContractBase,
   ContractMarkerRecord,
   DocCollection,
   DocIndex,
   DocumentContract,
   DocumentStorage,
+  ExecutionHashBase,
+  ExecutionMutationDefault,
+  ExecutionMutationDefaultValue,
   ExecutionPlan,
+  ExecutionSection,
   Expr,
   FieldType,
-  OperationManifest,
+  GenerateContractTypesOptions,
+  GeneratedValueSpec,
+  JsonPrimitive,
+  JsonValue,
   ParamDescriptor,
+  ParameterizedCodecDescriptor,
   PlanMeta,
   PlanRefs,
+  ProfileHashBase,
+  RenderTypeContext,
   ResultType,
   Source,
+  StorageHashBase,
+  TaggedBigInt,
+  TaggedLiteralValue,
+  TaggedRaw,
   TargetFamilyHook,
+  TypeRenderContext,
+  TypeRenderEntry,
+  TypeRenderer,
   TypesImportSpec,
   ValidationContext,
 } from '../types';
-// Type guards
-export { isDocumentContract } from '../types';
+export {
+  bigintJsonReplacer,
+  coreHash,
+  isDocumentContract,
+  isTaggedBigInt,
+  isTaggedRaw,
+  profileHash,
+} from '../types';

package/src/exports/validate-domain.ts

@@ -0,0 +1,6 @@
+export {
+  type DomainContractShape,
+  type DomainModelShape,
+  type DomainValidationResult,
+  validateContractDomain,
+} from '../validate-domain';