@prisma-next/emitter 0.3.0-dev.128 → 0.3.0-dev.129

package/README.md

@@ -49,6 +49,7 @@ flowchart TD
 
     subgraph "Target Family Hooks"
         SQL[SQL Hook]
+        MONGO[Mongo Hook]
         DOC[Document Hook]
     end
 
@@ -61,8 +62,10 @@ flowchart TD
     TS --> IR
     IR --> VAL
     VAL --> SQL
+    VAL --> MONGO
     VAL --> DOC
     SQL --> HASH
+    MONGO --> HASH
     DOC --> HASH
     PACK1 --> SQL
     PACK2 --> DOC
@@ -137,6 +140,7 @@ import { createOperationRegistry } from '@prisma-next/operations';
 
 // Determine target family SPI based on target family
 import { sqlTargetFamilyHook } from '@prisma-next/sql-contract-emitter';
+// or: import { mongoTargetFamilyHook } from '@prisma-next/mongo-emitter';
 
 // Emit contract
 const ir: ContractIR = {
@@ -188,5 +192,6 @@ This ensures all required fields are present with sensible defaults. See `.curso
 
 ## Exports
 
-- `.`: Main emitter API (`emit`, types)
+- `.`: Main emitter API (`emit`, types, shared domain-level generation utilities)
+- `./domain-type-generation`: Shared domain-level `.d.ts` generation utilities (used by family-specific emitter hooks)
 

package/dist/domain-type-generation.d.mts

@@ -0,0 +1,18 @@
+import { TypesImportSpec } from "@prisma-next/contract/types";
+
+//#region src/domain-type-generation.d.ts
+declare function serializeValue(value: unknown): string;
+declare function serializeObjectKey(key: string): string;
+declare function generateRootsType(roots: Record<string, string> | undefined): string;
+declare function generateModelRelationsType(relations: Record<string, unknown>): string;
+declare function deduplicateImports(imports: TypesImportSpec[]): TypesImportSpec[];
+declare function generateImportLines(imports: TypesImportSpec[]): string[];
+declare function generateCodecTypeIntersection(imports: ReadonlyArray<TypesImportSpec>, named: string): string;
+declare function generateHashTypeAliases(hashes: {
+  readonly storageHash: string;
+  readonly executionHash?: string;
+  readonly profileHash: string;
+}): string;
+//#endregion
+export { deduplicateImports, generateCodecTypeIntersection, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, serializeObjectKey, serializeValue };
+//# sourceMappingURL=domain-type-generation.d.mts.map

package/dist/domain-type-generation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-type-generation.d.mts","names":[],"sources":["../src/domain-type-generation.ts"],"sourcesContent":[],"mappings":";;;iBAEgB,cAAA;iBA+BA,kBAAA;AA/BA,iBAsCA,iBAAA,CAtCc,KAAA,EAsCW,MAtCX,CAAA,MAAA,EAAA,MAAA,CAAA,GAAA,SAAA,CAAA,EAAA,MAAA;AA+Bd,iBAiBA,0BAAA,CAjBkB,SAAA,EAiBoB,MAjBpB,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA;AAOlB,iBA2CA,kBAAA,CA3C+B,OAAA,EA2CH,eA3CG,EAAA,CAAA,EA2CiB,eA3CjB,EAAA;AAU/B,iBA8CA,mBAAA,CA9CsC,OAAM,EA8Cf,eA9Ce,EAAA,CAAA,EAAA,MAAA,EAAA;AAiC5C,iBAoBA,6BAAA,CApBgD,OAAA,EAqBrD,aArBoE,CAqBtD,eArBsD,CAAA,EAAA,KAAA,EAAA,MAAA,CAAA,EAAA,MAAA;AAa/D,iBAeA,uBAAA,CAf6B,MAAe,EAAA;EAO5C,SAAA,WAAA,EAAA,MAAA;EAQA,SAAA,aAAA,CAAA,EAAA,MAAuB"}

package/dist/domain-type-generation.mjs

@@ -0,0 +1,74 @@
+//#region src/domain-type-generation.ts
+function serializeValue(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (typeof value === "string") return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (typeof value === "bigint") return `${value}n`;
+	if (Array.isArray(value)) return `readonly [${value.map((v) => serializeValue(v)).join(", ")}]`;
+	if (typeof value === "object") {
+		const entries = [];
+		for (const [k, v] of Object.entries(value)) entries.push(`readonly ${serializeObjectKey(k)}: ${serializeValue(v)}`);
+		return `{ ${entries.join("; ")} }`;
+	}
+	return "unknown";
+}
+function serializeObjectKey(key) {
+	if (/^[$A-Z_a-z][$\w]*$/.test(key)) return key;
+	return serializeValue(key);
+}
+function generateRootsType(roots) {
+	if (!roots || Object.keys(roots).length === 0) return "Record<string, string>";
+	return `{ ${Object.entries(roots).map(([key, value]) => `readonly ${serializeObjectKey(key)}: ${serializeValue(value)}`).join("; ")} }`;
+}
+function generateModelRelationsType(relations) {
+	const relationEntries = [];
+	for (const [relName, rel] of Object.entries(relations)) {
+		if (typeof rel !== "object" || rel === null) continue;
+		const relObj = rel;
+		const parts = [];
+		if (relObj["to"]) parts.push(`readonly to: ${serializeValue(relObj["to"])}`);
+		if (relObj["cardinality"]) parts.push(`readonly cardinality: ${serializeValue(relObj["cardinality"])}`);
+		const on = relObj["on"];
+		if (on?.localFields && on.targetFields) {
+			const localFields = on.localFields.map((f) => serializeValue(f)).join(", ");
+			const targetFields = on.targetFields.map((f) => serializeValue(f)).join(", ");
+			parts.push(`readonly on: { readonly localFields: readonly [${localFields}]; readonly targetFields: readonly [${targetFields}] }`);
+		}
+		if (parts.length > 0) relationEntries.push(`readonly ${relName}: { ${parts.join("; ")} }`);
+	}
+	if (relationEntries.length === 0) return "Record<string, never>";
+	return `{ ${relationEntries.join("; ")} }`;
+}
+function deduplicateImports(imports) {
+	const seenKeys = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const imp of imports) {
+		const key = `${imp.package}::${imp.named}`;
+		if (!seenKeys.has(key)) {
+			seenKeys.add(key);
+			result.push(imp);
+		}
+	}
+	return result;
+}
+function generateImportLines(imports) {
+	return imports.map((imp) => {
+		return `import type { ${imp.named === imp.alias ? imp.named : `${imp.named} as ${imp.alias}`} } from '${imp.package}';`;
+	});
+}
+function generateCodecTypeIntersection(imports, named) {
+	return imports.filter((imp) => imp.named === named).map((imp) => imp.alias).join(" & ") || "Record<string, never>";
+}
+function generateHashTypeAliases(hashes) {
+	const executionHashType = hashes.executionHash ? `ExecutionHashBase<'${hashes.executionHash}'>` : "ExecutionHashBase<string>";
+	return [
+		`export type StorageHash = StorageHashBase<'${hashes.storageHash}'>;`,
+		`export type ExecutionHash = ${executionHashType};`,
+		`export type ProfileHash = ProfileHashBase<'${hashes.profileHash}'>;`
+	].join("\n");
+}
+
+//#endregion
+export { deduplicateImports, generateCodecTypeIntersection, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, serializeObjectKey, serializeValue };
+//# sourceMappingURL=domain-type-generation.mjs.map

package/dist/domain-type-generation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-type-generation.mjs","names":["entries: string[]","relationEntries: string[]","parts: string[]","result: TypesImportSpec[]"],"sources":["../src/domain-type-generation.ts"],"sourcesContent":["import type { TypesImportSpec } from '@prisma-next/contract/types';\n\nexport function serializeValue(value: unknown): string {\n  if (value === null) {\n    return 'null';\n  }\n  if (value === undefined) {\n    return 'undefined';\n  }\n  if (typeof value === 'string') {\n    const escaped = value.replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\");\n    return `'${escaped}'`;\n  }\n  if (typeof value === 'number' || typeof value === 'boolean') {\n    return String(value);\n  }\n  if (typeof value === 'bigint') {\n    return `${value}n`;\n  }\n  if (Array.isArray(value)) {\n    const items = value.map((v) => serializeValue(v)).join(', ');\n    return `readonly [${items}]`;\n  }\n  if (typeof value === 'object') {\n    const entries: string[] = [];\n    for (const [k, v] of Object.entries(value)) {\n      entries.push(`readonly ${serializeObjectKey(k)}: ${serializeValue(v)}`);\n    }\n    return `{ ${entries.join('; ')} }`;\n  }\n  return 'unknown';\n}\n\nexport function serializeObjectKey(key: string): string {\n  if (/^[$A-Z_a-z][$\\w]*$/.test(key)) {\n    return key;\n  }\n  return serializeValue(key);\n}\n\nexport function generateRootsType(roots: Record<string, string> | undefined): string {\n  if (!roots || Object.keys(roots).length === 0) {\n    return 'Record<string, string>';\n  }\n  const entries = Object.entries(roots)\n    .map(([key, value]) => `readonly ${serializeObjectKey(key)}: ${serializeValue(value)}`)\n    .join('; ');\n  return `{ ${entries} }`;\n}\n\nexport function generateModelRelationsType(relations: Record<string, unknown>): string {\n  const relationEntries: string[] = [];\n\n  for (const [relName, rel] of Object.entries(relations)) {\n    if (typeof rel !== 'object' || rel === null) continue;\n    const relObj = rel as Record<string, unknown>;\n    const parts: string[] = [];\n\n    if (relObj['to']) parts.push(`readonly to: ${serializeValue(relObj['to'])}`);\n    if (relObj['cardinality'])\n      parts.push(`readonly cardinality: ${serializeValue(relObj['cardinality'])}`);\n\n    const on = relObj['on'] as { localFields?: string[]; targetFields?: string[] } | undefined;\n    if (on?.localFields && on.targetFields) {\n      const localFields = on.localFields.map((f) => serializeValue(f)).join(', ');\n      const targetFields = on.targetFields.map((f) => serializeValue(f)).join(', ');\n      parts.push(\n        `readonly on: { readonly localFields: readonly [${localFields}]; readonly targetFields: readonly [${targetFields}] }`,\n      );\n    }\n\n    if (parts.length > 0) {\n      relationEntries.push(`readonly ${relName}: { ${parts.join('; ')} }`);\n    }\n  }\n\n  if (relationEntries.length === 0) {\n    return 'Record<string, never>';\n  }\n\n  return `{ ${relationEntries.join('; ')} }`;\n}\n\nexport function deduplicateImports(imports: TypesImportSpec[]): TypesImportSpec[] {\n  const seenKeys = new Set<string>();\n  const result: TypesImportSpec[] = [];\n  for (const imp of imports) {\n    const key = `${imp.package}::${imp.named}`;\n    if (!seenKeys.has(key)) {\n      seenKeys.add(key);\n      result.push(imp);\n    }\n  }\n  return result;\n}\n\nexport function generateImportLines(imports: TypesImportSpec[]): string[] {\n  return imports.map((imp) => {\n    const importClause = imp.named === imp.alias ? imp.named : `${imp.named} as ${imp.alias}`;\n    return `import type { ${importClause} } from '${imp.package}';`;\n  });\n}\n\nexport function generateCodecTypeIntersection(\n  imports: ReadonlyArray<TypesImportSpec>,\n  named: string,\n): string {\n  const aliases = imports.filter((imp) => imp.named === named).map((imp) => imp.alias);\n  return aliases.join(' & ') || 'Record<string, never>';\n}\n\nexport function generateHashTypeAliases(hashes: {\n  readonly storageHash: string;\n  readonly executionHash?: string;\n  readonly profileHash: string;\n}): string {\n  const executionHashType = hashes.executionHash\n    ? `ExecutionHashBase<'${hashes.executionHash}'>`\n    : 'ExecutionHashBase<string>';\n\n  return [\n    `export type StorageHash = StorageHashBase<'${hashes.storageHash}'>;`,\n    `export type ExecutionHash = ${executionHashType};`,\n    `export type ProfileHash = ProfileHashBase<'${hashes.profileHash}'>;`,\n  ].join('\\n');\n}\n"],"mappings":"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"}

package/dist/exports/index.d.mts

@@ -1,3 +1,4 @@
+import { deduplicateImports, generateCodecTypeIntersection, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, serializeObjectKey, serializeValue } from "../domain-type-generation.mjs";
 import { EmitOptions, EmitResult, emit } from "@prisma-next/core-control-plane/emission";
 import { TargetFamilyHook, TypesImportSpec, ValidationContext } from "@prisma-next/contract/types";
-export { type EmitOptions, type EmitResult, type TargetFamilyHook, type TypesImportSpec, type ValidationContext, emit };
+export { type EmitOptions, type EmitResult, type TargetFamilyHook, type TypesImportSpec, type ValidationContext, deduplicateImports, emit, generateCodecTypeIntersection, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, serializeObjectKey, serializeValue };

package/dist/exports/index.mjs

@@ -1,3 +1,4 @@
+import { deduplicateImports, generateCodecTypeIntersection, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, serializeObjectKey, serializeValue } from "../domain-type-generation.mjs";
 import { emit } from "@prisma-next/core-control-plane/emission";
 
-export { emit };
+export { deduplicateImports, emit, generateCodecTypeIntersection, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, serializeObjectKey, serializeValue };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/emitter",
-  "version": "0.3.0-dev.128",
+  "version": "0.3.0-dev.129",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -10,24 +10,28 @@
   ],
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/contract": "0.3.0-dev.128",
-    "@prisma-next/core-control-plane": "0.3.0-dev.128"
+    "@prisma-next/contract": "0.3.0-dev.129",
+    "@prisma-next/core-control-plane": "0.3.0-dev.129"
   },
   "devDependencies": {
     "@types/node": "24.10.4",
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/operations": "0.3.0-dev.128",
+    "@prisma-next/operations": "0.3.0-dev.129",
+    "@prisma-next/tsdown": "0.0.0",
     "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/test-utils": "0.0.1"
   },
   "exports": {
     ".": {
       "types": "./dist/exports/index.d.mts",
       "import": "./dist/exports/index.mjs"
     },
+    "./domain-type-generation": {
+      "types": "./dist/domain-type-generation.d.mts",
+      "import": "./dist/domain-type-generation.mjs"
+    },
     "./test/utils": {
       "types": "./dist/test/utils.d.mts",
       "import": "./dist/test/utils.mjs"

package/src/domain-type-generation.ts

@@ -0,0 +1,126 @@
+import type { TypesImportSpec } from '@prisma-next/contract/types';
+
+export function serializeValue(value: unknown): string {
+  if (value === null) {
+    return 'null';
+  }
+  if (value === undefined) {
+    return 'undefined';
+  }
+  if (typeof value === 'string') {
+    const escaped = value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    return `'${escaped}'`;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  if (typeof value === 'bigint') {
+    return `${value}n`;
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((v) => serializeValue(v)).join(', ');
+    return `readonly [${items}]`;
+  }
+  if (typeof value === 'object') {
+    const entries: string[] = [];
+    for (const [k, v] of Object.entries(value)) {
+      entries.push(`readonly ${serializeObjectKey(k)}: ${serializeValue(v)}`);
+    }
+    return `{ ${entries.join('; ')} }`;
+  }
+  return 'unknown';
+}
+
+export function serializeObjectKey(key: string): string {
+  if (/^[$A-Z_a-z][$\w]*$/.test(key)) {
+    return key;
+  }
+  return serializeValue(key);
+}
+
+export function generateRootsType(roots: Record<string, string> | undefined): string {
+  if (!roots || Object.keys(roots).length === 0) {
+    return 'Record<string, string>';
+  }
+  const entries = Object.entries(roots)
+    .map(([key, value]) => `readonly ${serializeObjectKey(key)}: ${serializeValue(value)}`)
+    .join('; ');
+  return `{ ${entries} }`;
+}
+
+export function generateModelRelationsType(relations: Record<string, unknown>): string {
+  const relationEntries: string[] = [];
+
+  for (const [relName, rel] of Object.entries(relations)) {
+    if (typeof rel !== 'object' || rel === null) continue;
+    const relObj = rel as Record<string, unknown>;
+    const parts: string[] = [];
+
+    if (relObj['to']) parts.push(`readonly to: ${serializeValue(relObj['to'])}`);
+    if (relObj['cardinality'])
+      parts.push(`readonly cardinality: ${serializeValue(relObj['cardinality'])}`);
+
+    const on = relObj['on'] as { localFields?: string[]; targetFields?: string[] } | undefined;
+    if (on?.localFields && on.targetFields) {
+      const localFields = on.localFields.map((f) => serializeValue(f)).join(', ');
+      const targetFields = on.targetFields.map((f) => serializeValue(f)).join(', ');
+      parts.push(
+        `readonly on: { readonly localFields: readonly [${localFields}]; readonly targetFields: readonly [${targetFields}] }`,
+      );
+    }
+
+    if (parts.length > 0) {
+      relationEntries.push(`readonly ${relName}: { ${parts.join('; ')} }`);
+    }
+  }
+
+  if (relationEntries.length === 0) {
+    return 'Record<string, never>';
+  }
+
+  return `{ ${relationEntries.join('; ')} }`;
+}
+
+export function deduplicateImports(imports: TypesImportSpec[]): TypesImportSpec[] {
+  const seenKeys = new Set<string>();
+  const result: TypesImportSpec[] = [];
+  for (const imp of imports) {
+    const key = `${imp.package}::${imp.named}`;
+    if (!seenKeys.has(key)) {
+      seenKeys.add(key);
+      result.push(imp);
+    }
+  }
+  return result;
+}
+
+export function generateImportLines(imports: TypesImportSpec[]): string[] {
+  return imports.map((imp) => {
+    const importClause = imp.named === imp.alias ? imp.named : `${imp.named} as ${imp.alias}`;
+    return `import type { ${importClause} } from '${imp.package}';`;
+  });
+}
+
+export function generateCodecTypeIntersection(
+  imports: ReadonlyArray<TypesImportSpec>,
+  named: string,
+): string {
+  const aliases = imports.filter((imp) => imp.named === named).map((imp) => imp.alias);
+  return aliases.join(' & ') || 'Record<string, never>';
+}
+
+export function generateHashTypeAliases(hashes: {
+  readonly storageHash: string;
+  readonly executionHash?: string;
+  readonly profileHash: string;
+}): string {
+  const executionHashType = hashes.executionHash
+    ? `ExecutionHashBase<'${hashes.executionHash}'>`
+    : 'ExecutionHashBase<string>';
+
+  return [
+    `export type StorageHash = StorageHashBase<'${hashes.storageHash}'>;`,
+    `export type ExecutionHash = ${executionHashType};`,
+    `export type ProfileHash = ProfileHashBase<'${hashes.profileHash}'>;`,
+  ].join('\n');
+}

package/src/exports/index.ts

@@ -7,3 +7,13 @@ export type {
 export type { EmitOptions, EmitResult } from '@prisma-next/core-control-plane/emission';
 // Re-export emit function and types from core-control-plane
 export { emit } from '@prisma-next/core-control-plane/emission';
+export {
+  deduplicateImports,
+  generateCodecTypeIntersection,
+  generateHashTypeAliases,
+  generateImportLines,
+  generateModelRelationsType,
+  generateRootsType,
+  serializeObjectKey,
+  serializeValue,
+} from '../domain-type-generation';

package/test/canonicalization.test.ts

@@ -291,6 +291,67 @@ describe('canonicalization', () => {
     expect(columnKeys).toEqual(['a_field', 'm_field', 'z_field']);
   });
 
+  describe('Mongo storage.collections preservation', () => {
+    it('preserves empty storage.collections container', () => {
+      const ir = createContractIR({
+        targetFamily: 'mongo',
+        target: 'mongo',
+        storage: { collections: {} },
+      });
+
+      const result = canonicalizeContract(ir);
+      const parsed = JSON.parse(result) as Record<string, unknown>;
+      const storage = parsed['storage'] as Record<string, unknown>;
+      expect(storage['collections']).toEqual({});
+    });
+
+    it('preserves collection entries with empty payloads', () => {
+      const ir = createContractIR({
+        targetFamily: 'mongo',
+        target: 'mongo',
+        storage: { collections: { users: {}, posts: {} } },
+      });
+
+      const result = canonicalizeContract(ir);
+      const parsed = JSON.parse(result) as Record<string, unknown>;
+      const storage = parsed['storage'] as Record<string, unknown>;
+      const collections = storage['collections'] as Record<string, unknown>;
+      expect(collections['users']).toEqual({});
+      expect(collections['posts']).toEqual({});
+    });
+
+    it('sorts collection names lexicographically', () => {
+      const ir = createContractIR({
+        targetFamily: 'mongo',
+        target: 'mongo',
+        storage: { collections: { zebras: {}, apples: {}, mangoes: {} } },
+      });
+
+      const result = canonicalizeContract(ir);
+      const parsed = JSON.parse(result) as Record<string, unknown>;
+      const storage = parsed['storage'] as Record<string, unknown>;
+      const collections = storage['collections'] as Record<string, unknown>;
+      expect(Object.keys(collections)).toEqual(['apples', 'mangoes', 'zebras']);
+    });
+
+    it('produces different hashes when collections differ', () => {
+      const ir1 = createContractIR({
+        targetFamily: 'mongo',
+        target: 'mongo',
+        storage: { collections: { users: {} } },
+      });
+      const ir2 = createContractIR({
+        targetFamily: 'mongo',
+        target: 'mongo',
+        storage: { collections: { users: {}, posts: {} } },
+      });
+
+      const result1 = canonicalizeContract(ir1);
+      const result2 = canonicalizeContract(ir2);
+      expect(result1).not.toBe(result2);
+    });
+  });
+
   it('sorts extension namespaces lexicographically', () => {
     const ir = createContractIR({
       extensionPacks: {

package/test/domain-type-generation.test.ts

@@ -0,0 +1,271 @@
+import type { TypesImportSpec } from '@prisma-next/contract/types';
+import { describe, expect, it } from 'vitest';
+import {
+  deduplicateImports,
+  generateCodecTypeIntersection,
+  generateHashTypeAliases,
+  generateImportLines,
+  generateModelRelationsType,
+  generateRootsType,
+  serializeObjectKey,
+  serializeValue,
+} from '../src/domain-type-generation';
+
+describe('serializeValue', () => {
+  it('serializes null', () => {
+    expect(serializeValue(null)).toBe('null');
+  });
+
+  it('serializes undefined', () => {
+    expect(serializeValue(undefined)).toBe('undefined');
+  });
+
+  it('serializes strings with single quotes', () => {
+    expect(serializeValue('hello')).toBe("'hello'");
+  });
+
+  it('escapes backslashes and single quotes in strings', () => {
+    expect(serializeValue("it's")).toBe("'it\\'s'");
+    expect(serializeValue('back\\slash')).toBe("'back\\\\slash'");
+  });
+
+  it('serializes numbers', () => {
+    expect(serializeValue(42)).toBe('42');
+    expect(serializeValue(3.14)).toBe('3.14');
+  });
+
+  it('serializes booleans', () => {
+    expect(serializeValue(true)).toBe('true');
+    expect(serializeValue(false)).toBe('false');
+  });
+
+  it('serializes bigints', () => {
+    expect(serializeValue(BigInt(123))).toBe('123n');
+  });
+
+  it('serializes arrays as readonly tuples', () => {
+    expect(serializeValue(['a', 'b'])).toBe("readonly ['a', 'b']");
+  });
+
+  it('serializes objects with readonly properties', () => {
+    expect(serializeValue({ key: 'val' })).toBe("{ readonly key: 'val' }");
+  });
+
+  it('serializes nested objects', () => {
+    const result = serializeValue({ a: { b: 1 } });
+    expect(result).toBe('{ readonly a: { readonly b: 1 } }');
+  });
+
+  it('returns unknown for unsupported types', () => {
+    expect(serializeValue(Symbol('test'))).toBe('unknown');
+  });
+});
+
+describe('serializeObjectKey', () => {
+  it('passes through valid identifiers', () => {
+    expect(serializeObjectKey('foo')).toBe('foo');
+    expect(serializeObjectKey('_bar')).toBe('_bar');
+    expect(serializeObjectKey('$baz')).toBe('$baz');
+    expect(serializeObjectKey('camelCase')).toBe('camelCase');
+  });
+
+  it('quotes keys with special characters', () => {
+    expect(serializeObjectKey('has space')).toBe("'has space'");
+    expect(serializeObjectKey('has-dash')).toBe("'has-dash'");
+    expect(serializeObjectKey('ns/name@1')).toBe("'ns/name@1'");
+  });
+});
+
+describe('generateRootsType', () => {
+  it('returns Record<string, string> for undefined roots', () => {
+    expect(generateRootsType(undefined)).toBe('Record<string, string>');
+  });
+
+  it('returns Record<string, string> for empty roots', () => {
+    expect(generateRootsType({})).toBe('Record<string, string>');
+  });
+
+  it('generates literal object type for roots', () => {
+    const result = generateRootsType({ users: 'User', posts: 'Post' });
+    expect(result).toContain("readonly users: 'User'");
+    expect(result).toContain("readonly posts: 'Post'");
+  });
+});
+
+describe('generateModelRelationsType', () => {
+  it('returns empty object for empty relations', () => {
+    expect(generateModelRelationsType({})).toBe('Record<string, never>');
+  });
+
+  it('generates relation with to and cardinality', () => {
+    const result = generateModelRelationsType({
+      posts: { to: 'Post', cardinality: '1:N' },
+    });
+    expect(result).toContain("readonly to: 'Post'");
+    expect(result).toContain("readonly cardinality: '1:N'");
+  });
+
+  it('generates relation with on (localFields/targetFields)', () => {
+    const result = generateModelRelationsType({
+      author: {
+        to: 'User',
+        cardinality: 'N:1',
+        on: { localFields: ['authorId'], targetFields: ['_id'] },
+      },
+    });
+    expect(result).toContain("readonly to: 'User'");
+    expect(result).toContain("readonly cardinality: 'N:1'");
+    expect(result).toContain("readonly localFields: readonly ['authorId']");
+    expect(result).toContain("readonly targetFields: readonly ['_id']");
+  });
+
+  it('skips non-object relations', () => {
+    const result = generateModelRelationsType({
+      bad: 'not an object' as unknown as Record<string, unknown>,
+    });
+    expect(result).toBe('Record<string, never>');
+  });
+
+  it('generates multiple relations', () => {
+    const result = generateModelRelationsType({
+      author: { to: 'User', cardinality: 'N:1' },
+      comments: { to: 'Comment', cardinality: '1:N' },
+    });
+    expect(result).toContain('readonly author:');
+    expect(result).toContain('readonly comments:');
+  });
+
+  it('omits to when missing from relation', () => {
+    const result = generateModelRelationsType({
+      rel: { cardinality: '1:N' },
+    });
+    expect(result).toContain("readonly cardinality: '1:N'");
+    expect(result).not.toContain('readonly to:');
+  });
+
+  it('omits cardinality when missing from relation', () => {
+    const result = generateModelRelationsType({
+      rel: { to: 'Post' },
+    });
+    expect(result).toContain("readonly to: 'Post'");
+    expect(result).not.toContain('readonly cardinality:');
+  });
+
+  it('skips relation object with no recognized properties', () => {
+    const result = generateModelRelationsType({
+      empty: { unknown: true },
+    });
+    expect(result).toBe('Record<string, never>');
+  });
+});
+
+describe('deduplicateImports', () => {
+  it('returns empty array for empty input', () => {
+    expect(deduplicateImports([])).toEqual([]);
+  });
+
+  it('keeps unique imports', () => {
+    const imports: TypesImportSpec[] = [
+      { package: 'pkg-a', named: 'CodecTypes', alias: 'A' },
+      { package: 'pkg-b', named: 'CodecTypes', alias: 'B' },
+    ];
+    expect(deduplicateImports(imports)).toHaveLength(2);
+  });
+
+  it('deduplicates by package+named (first wins)', () => {
+    const imports: TypesImportSpec[] = [
+      { package: 'pkg-a', named: 'CodecTypes', alias: 'First' },
+      { package: 'pkg-a', named: 'CodecTypes', alias: 'Second' },
+    ];
+    const result = deduplicateImports(imports);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.alias).toBe('First');
+  });
+
+  it('preserves insertion order', () => {
+    const imports: TypesImportSpec[] = [
+      { package: 'pkg-b', named: 'X', alias: 'X' },
+      { package: 'pkg-a', named: 'Y', alias: 'Y' },
+    ];
+    const result = deduplicateImports(imports);
+    expect(result[0]!.package).toBe('pkg-b');
+    expect(result[1]!.package).toBe('pkg-a');
+  });
+});
+
+describe('generateImportLines', () => {
+  it('generates import with alias', () => {
+    const imports: TypesImportSpec[] = [
+      { package: '@prisma-next/adapter', named: 'CodecTypes', alias: 'PgCodecTypes' },
+    ];
+    const lines = generateImportLines(imports);
+    expect(lines).toEqual([
+      "import type { CodecTypes as PgCodecTypes } from '@prisma-next/adapter';",
+    ]);
+  });
+
+  it('simplifies import when named === alias', () => {
+    const imports: TypesImportSpec[] = [
+      { package: '@prisma-next/adapter', named: 'Vector', alias: 'Vector' },
+    ];
+    const lines = generateImportLines(imports);
+    expect(lines).toEqual(["import type { Vector } from '@prisma-next/adapter';"]);
+  });
+});
+
+describe('generateCodecTypeIntersection', () => {
+  it('returns Record<string, never> when no matching imports', () => {
+    expect(generateCodecTypeIntersection([], 'CodecTypes')).toBe('Record<string, never>');
+  });
+
+  it('returns single alias when one match', () => {
+    const imports: TypesImportSpec[] = [
+      { package: 'pkg', named: 'CodecTypes', alias: 'PgCodecTypes' },
+    ];
+    expect(generateCodecTypeIntersection(imports, 'CodecTypes')).toBe('PgCodecTypes');
+  });
+
+  it('returns intersection when multiple matches', () => {
+    const imports: TypesImportSpec[] = [
+      { package: 'pkg-a', named: 'CodecTypes', alias: 'A' },
+      { package: 'pkg-b', named: 'CodecTypes', alias: 'B' },
+    ];
+    expect(generateCodecTypeIntersection(imports, 'CodecTypes')).toBe('A & B');
+  });
+
+  it('filters by named parameter', () => {
+    const imports: TypesImportSpec[] = [
+      { package: 'pkg', named: 'CodecTypes', alias: 'CT' },
+      { package: 'pkg', named: 'OperationTypes', alias: 'OT' },
+    ];
+    expect(generateCodecTypeIntersection(imports, 'OperationTypes')).toBe('OT');
+  });
+});
+
+describe('generateHashTypeAliases', () => {
+  it('generates storage and profile hash aliases', () => {
+    const result = generateHashTypeAliases({
+      storageHash: 'sha256:abc123',
+      profileHash: 'sha256:def456',
+    });
+    expect(result).toContain("StorageHashBase<'sha256:abc123'>");
+    expect(result).toContain("ProfileHashBase<'sha256:def456'>");
+  });
+
+  it('generates concrete execution hash when provided', () => {
+    const result = generateHashTypeAliases({
+      storageHash: 'sha256:abc',
+      executionHash: 'sha256:exec',
+      profileHash: 'sha256:prof',
+    });
+    expect(result).toContain("ExecutionHashBase<'sha256:exec'>");
+  });
+
+  it('generates generic execution hash when not provided', () => {
+    const result = generateHashTypeAliases({
+      storageHash: 'sha256:abc',
+      profileHash: 'sha256:prof',
+    });
+    expect(result).toContain('ExecutionHashBase<string>');
+  });
+});