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

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

@@ -6,7 +6,7 @@ describe('canonicalization', () => {
   it('orders top-level sections correctly', () => {
     const ir = createContractIR({
       capabilities: { postgres: { jsonAgg: true } },
-      meta: { source: 'test' },
+      meta: { emitterVersion: 'test' },
     });
 
     const result = canonicalizeContract(ir);
@@ -17,6 +17,7 @@ describe('canonicalization', () => {
     const targetFamilyIndex = keys.indexOf('targetFamily');
     const targetIndex = keys.indexOf('target');
     const modelsIndex = keys.indexOf('models');
+    const relationsIndex = keys.indexOf('relations');
     const storageIndex = keys.indexOf('storage');
     const capabilitiesIndex = keys.indexOf('capabilities');
     const metaIndex = keys.indexOf('meta');
@@ -24,6 +25,8 @@ describe('canonicalization', () => {
     expect(schemaVersionIndex).toBeLessThan(targetFamilyIndex);
     expect(targetFamilyIndex).toBeLessThan(targetIndex);
     expect(targetIndex).toBeLessThan(modelsIndex);
+    expect(modelsIndex).toBeLessThan(relationsIndex);
+    expect(relationsIndex).toBeLessThan(storageIndex);
     expect(modelsIndex).toBeLessThan(storageIndex);
     expect(storageIndex).toBeLessThan(capabilitiesIndex);
     expect(capabilitiesIndex).toBeLessThan(metaIndex);
@@ -55,6 +58,73 @@ describe('canonicalization', () => {
     expect(email['nullable']).toBe(true);
   });
 
+  it.each([
+    { nullable: false },
+    { nullable: undefined },
+  ])('omits nullable:false for columns with defaults (nullable=$nullable)', ({ nullable }) => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              created_at: {
+                codecId: 'pg/timestamptz@1',
+                nativeType: 'timestamptz',
+                nullable,
+                default: { kind: 'function', expression: 'now()' },
+              },
+              updated_at: {
+                codecId: 'pg/timestamptz@1',
+                nativeType: 'timestamptz',
+                nullable: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const result = canonicalizeContract(ir);
+    const parsed = JSON.parse(result) as Record<string, unknown>;
+    const storage = parsed['storage'] as Record<string, unknown>;
+    const tables = storage['tables'] as Record<string, unknown>;
+    const user = tables['user'] as Record<string, unknown>;
+    const columns = user['columns'] as Record<string, unknown>;
+    const createdAt = columns['created_at'] as Record<string, unknown>;
+    const updatedAt = columns['updated_at'] as Record<string, unknown>;
+    expect(createdAt['nullable']).toBeUndefined();
+    expect(updatedAt['nullable']).toBe(true);
+  });
+
+  it('preserves nullable:true for columns with defaults', () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              bio: {
+                codecId: 'pg/text@1',
+                nativeType: 'text',
+                nullable: true,
+                default: { kind: 'literal', value: '' },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const result = canonicalizeContract(ir);
+    const parsed = JSON.parse(result) as Record<string, unknown>;
+    const storage = parsed['storage'] as Record<string, unknown>;
+    const tables = storage['tables'] as Record<string, unknown>;
+    const user = tables['user'] as Record<string, unknown>;
+    const columns = user['columns'] as Record<string, unknown>;
+    const bio = columns['bio'] as Record<string, unknown>;
+    expect(bio['nullable']).toBe(true);
+    expect(bio['default']).toEqual({ kind: 'literal', value: '' });
+  });
+
   it('omits empty arrays and objects except required ones', () => {
     const ir = createContractIR();
 
@@ -66,14 +136,12 @@ describe('canonicalization', () => {
         tables: expect.anything(),
       },
     });
-    // Required top-level fields (capabilities, extensionPacks, meta, relations, sources) are preserved even when empty
-    // because they are required by ContractIR and needed for round-trip tests
+    // Required top-level fields (capabilities, extensionPacks, meta, relations) are preserved even when empty.
     expect(parsed).toMatchObject({
       capabilities: expect.anything(),
       extensionPacks: expect.anything(),
       meta: expect.anything(),
       relations: expect.anything(),
-      sources: expect.anything(),
     });
   });
 
@@ -117,7 +185,7 @@ describe('canonicalization', () => {
     expect(result1).not.toBe(result2);
   });
 
-  it('sorts non-semantic arrays by canonical name', () => {
+  it('sorts indexes by canonical name', () => {
     const ir = createContractIR({
       storage: {
         tables: {
@@ -144,6 +212,60 @@ describe('canonicalization', () => {
     expect(indexNames).toEqual(['user_email_idx', 'user_name_idx']);
   });
 
+  it('sorts uniques by canonical name', () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+              email: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+              username: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+            },
+            uniques: [
+              { columns: ['username'], name: 'user_username_key' },
+              { columns: ['email'], name: 'user_email_key' },
+            ],
+          },
+        },
+      },
+    });
+
+    const result = canonicalizeContract(ir);
+    const parsed = JSON.parse(result) as Record<string, unknown>;
+    const storage = parsed['storage'] as Record<string, unknown>;
+    const tables = storage['tables'] as Record<string, unknown>;
+    const user = tables['user'] as Record<string, unknown>;
+    const uniques = user['uniques'] as Array<{ name: string }>;
+    const uniqueNames = uniques.map((u) => u.name);
+    expect(uniqueNames).toEqual(['user_email_key', 'user_username_key']);
+  });
+
+  it('preserves column order in composite unique constraints', () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+              first_name: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+              last_name: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+            },
+            uniques: [{ columns: ['last_name', 'first_name'], name: 'user_name_key' }],
+          },
+        },
+      },
+    });
+
+    const result = canonicalizeContract(ir);
+    const parsed = JSON.parse(result) as Record<string, unknown>;
+    const storage = parsed['storage'] as Record<string, unknown>;
+    const tables = storage['tables'] as Record<string, unknown>;
+    const user = tables['user'] as Record<string, unknown>;
+    const uniques = user['uniques'] as Array<{ columns: string[] }>;
+    expect(uniques[0]!.columns).toEqual(['last_name', 'first_name']);
+  });
+
   it('sorts nested object keys lexicographically', () => {
     const ir = createContractIR({
       storage: {
@@ -169,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>');
+  });
+});