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

package/test/emitter.roundtrip.test.ts

@@ -1,86 +1,18 @@
-import type { ContractIR } from '@prisma-next/contract/ir';
-import type {
-  TargetFamilyHook,
-  TypesImportSpec,
-  ValidationContext,
-} from '@prisma-next/contract/types';
-import type { EmitOptions } from '@prisma-next/core-control-plane/emission';
-import { emit } from '@prisma-next/core-control-plane/emission';
-import { createOperationRegistry } from '@prisma-next/operations';
+import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
 import { timeouts } from '@prisma-next/test-utils';
 import { describe, expect, it } from 'vitest';
-import { createContractIR } from './utils';
+import type { EmitStackInput } from '../src/exports';
+import { emit } from '../src/exports';
+import { createMockSpi } from './mock-spi';
+import { createTestContract } from './utils';
 
-const mockSqlHook: TargetFamilyHook = {
-  id: 'sql',
-  validateTypes: (ir: ContractIR, _ctx: ValidationContext) => {
-    const storage = ir.storage as
-      | { tables?: Record<string, { columns?: Record<string, { codecId?: string }> }> }
-      | undefined;
-    if (!storage?.tables) {
-      return;
-    }
-
-    const referencedNamespaces = new Set<string>();
-    const extensionPacks = ir.extensionPacks as Record<string, unknown> | undefined;
-    if (extensionPacks) {
-      for (const namespace of Object.keys(extensionPacks)) {
-        referencedNamespaces.add(namespace);
-      }
-    }
-
-    const typeIdRegex = /^([^/]+)\/([^@]+)@(\d+)$/;
-
-    for (const [tableName, table] of Object.entries(storage.tables)) {
-      if (!table.columns) continue;
-      for (const [colName, col] of Object.entries(table.columns)) {
-        const column = col as { codecId?: string };
-        if (!column.codecId) {
-          throw new Error(`Column "${colName}" in table "${tableName}" is missing codecId`);
-        }
-
-        if (!typeIdRegex.test(column.codecId)) {
-          throw new Error(
-            `Column "${colName}" in table "${tableName}" has invalid codecId format "${column.codecId}". Expected format: ns/name@version`,
-          );
-        }
-
-        const match = column.codecId.match(typeIdRegex);
-        if (match?.[1]) {
-          const namespace = match[1];
-          if (!referencedNamespaces.has(namespace)) {
-            if (namespace === 'pg' && referencedNamespaces.has('postgres')) {
-              continue;
-            }
-            throw new Error(
-              `Column "${colName}" in table "${tableName}" uses codecId "${column.codecId}" from namespace "${namespace}" which is not referenced in contract.extensionPacks`,
-            );
-          }
-        }
-      }
-    }
-  },
-  validateStructure: (ir: ContractIR) => {
-    if (ir.targetFamily !== 'sql') {
-      throw new Error(`Expected targetFamily "sql", got "${ir.targetFamily}"`);
-    }
-  },
-  generateContractTypes: (_ir, _codecTypeImports, _operationTypeImports) => {
-    void _codecTypeImports;
-    void _operationTypeImports;
-    return `// Generated contract types
-export type CodecTypes = Record<string, never>;
-export type LaneCodecTypes = CodecTypes;
-export type Contract = unknown;
-`;
-  },
-};
+const mockSqlHook = createMockSpi();
 
 describe('emitter round-trip', () => {
   it(
     'round-trip with minimal IR',
     async () => {
-      const ir = createContractIR({
+      const ir = createTestContract({
         storage: {
           tables: {
             user: {
@@ -100,14 +32,10 @@ describe('emitter round-trip', () => {
         },
       });
 
-      // Create minimal test data (emitter tests don't load packs)
-      const operationRegistry = createOperationRegistry();
       const codecTypeImports: TypesImportSpec[] = [];
       const operationTypeImports: TypesImportSpec[] = [];
       const extensionIds = ['postgres', 'pg'];
-      const options: EmitOptions = {
-        outputDir: '',
-        operationRegistry,
+      const options: EmitStackInput = {
         codecTypeImports,
         operationTypeImports,
         extensionIds,
@@ -116,125 +44,135 @@ describe('emitter round-trip', () => {
       const result1 = await emit(ir, options, mockSqlHook);
       const contractJson1 = JSON.parse(result1.contractJson) as Record<string, unknown>;
 
-      const ir2 = createContractIR({
-        schemaVersion: contractJson1['schemaVersion'] as string,
+      const ir2 = createTestContract({
         targetFamily: contractJson1['targetFamily'] as string,
         target: contractJson1['target'] as string,
+        roots: contractJson1['roots'] as Record<string, string>,
         models: contractJson1['models'] as Record<string, unknown>,
-        relations: (contractJson1['relations'] as Record<string, unknown>) || {},
         storage: contractJson1['storage'] as Record<string, unknown>,
         extensionPacks: contractJson1['extensionPacks'] as Record<string, unknown>,
         capabilities:
           (contractJson1['capabilities'] as Record<string, Record<string, boolean>>) || {},
         meta: (contractJson1['meta'] as Record<string, unknown>) || {},
-        sources: (contractJson1['sources'] as Record<string, unknown>) || {},
       });
 
       const result2 = await emit(ir2, options, mockSqlHook);
 
       expect(result1.contractJson).toBe(result2.contractJson);
-      expect(result1.coreHash).toBe(result2.coreHash);
+      expect(result1.storageHash).toBe(result2.storageHash);
     },
     timeouts.typeScriptCompilation,
   );
 
-  it('round-trip with complex IR', async () => {
-    const ir = createContractIR({
-      models: {
-        User: {
-          storage: { table: 'user' },
-          fields: {
-            id: { column: 'id' },
-            email: { column: 'email' },
-            name: { column: 'name' },
-          },
-          relations: {},
-        },
-        Post: {
-          storage: { table: 'post' },
-          fields: {
-            id: { column: 'id' },
-            title: { column: 'title' },
-            userId: { column: 'user_id' },
+  it(
+    'round-trip with complex IR',
+    async () => {
+      const ir = createTestContract({
+        models: {
+          User: {
+            storage: {
+              table: 'user',
+              fields: {
+                id: { column: 'id' },
+                email: { column: 'email' },
+                name: { column: 'name' },
+              },
+            },
+            fields: {
+              id: { type: { kind: 'scalar', codecId: 'pg/int4@1' }, nullable: false },
+              email: { type: { kind: 'scalar', codecId: 'pg/text@1' }, nullable: false },
+              name: { type: { kind: 'scalar', codecId: 'pg/text@1' }, nullable: true },
+            },
+            relations: {},
           },
-          relations: {},
-        },
-      },
-      storage: {
-        tables: {
-          user: {
-            columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
-              email: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
-              name: { codecId: 'pg/text@1', nativeType: 'text', nullable: true },
+          Post: {
+            storage: {
+              table: 'post',
+              fields: {
+                id: { column: 'id' },
+                title: { column: 'title' },
+                userId: { column: 'user_id' },
+              },
             },
-            primaryKey: { columns: ['id'] },
-            uniques: [{ columns: ['email'], name: 'user_email_key' }],
-            indexes: [{ columns: ['name'], name: 'user_name_idx' }],
-            foreignKeys: [],
+            fields: {
+              id: { type: { kind: 'scalar', codecId: 'pg/int4@1' }, nullable: false },
+              title: { type: { kind: 'scalar', codecId: 'pg/text@1' }, nullable: false },
+              userId: { type: { kind: 'scalar', codecId: 'pg/int4@1' }, nullable: false },
+            },
+            relations: {},
           },
-          post: {
-            columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
-              title: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
-              user_id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+        },
+        storage: {
+          tables: {
+            user: {
+              columns: {
+                id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+                email: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+                name: { codecId: 'pg/text@1', nativeType: 'text', nullable: true },
+              },
+              primaryKey: { columns: ['id'] },
+              uniques: [{ columns: ['email'], name: 'user_email_key' }],
+              indexes: [{ columns: ['name'], name: 'user_name_idx' }],
+              foreignKeys: [],
             },
-            primaryKey: { columns: ['id'] },
-            uniques: [],
-            indexes: [],
-            foreignKeys: [
-              {
-                columns: ['user_id'],
-                references: { table: 'user', columns: ['id'] },
-                name: 'post_user_id_fkey',
+            post: {
+              columns: {
+                id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+                title: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+                user_id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
               },
-            ],
+              primaryKey: { columns: ['id'] },
+              uniques: [],
+              indexes: [],
+              foreignKeys: [
+                {
+                  columns: ['user_id'],
+                  references: { table: 'user', columns: ['id'] },
+                  name: 'post_user_id_fkey',
+                },
+              ],
+            },
           },
         },
-      },
-      extensionPacks: {
-        postgres: { version: '0.0.1' },
-      },
-    });
+        extensionPacks: {
+          postgres: { version: '0.0.1' },
+        },
+      });
 
-    // Create minimal test data (emitter tests don't load packs)
-    const operationRegistry = createOperationRegistry();
-    const codecTypeImports: TypesImportSpec[] = [];
-    const operationTypeImports: TypesImportSpec[] = [];
-    const extensionIds = ['postgres'];
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports,
-      operationTypeImports,
-      extensionIds,
-    };
+      const codecTypeImports: TypesImportSpec[] = [];
+      const operationTypeImports: TypesImportSpec[] = [];
+      const extensionIds = ['postgres'];
+      const options: EmitStackInput = {
+        codecTypeImports,
+        operationTypeImports,
+        extensionIds,
+      };
 
-    const result1 = await emit(ir, options, mockSqlHook);
-    const contractJson1 = JSON.parse(result1.contractJson) as Record<string, unknown>;
+      const result1 = await emit(ir, options, mockSqlHook);
+      const contractJson1 = JSON.parse(result1.contractJson) as Record<string, unknown>;
 
-    const ir2 = createContractIR({
-      schemaVersion: contractJson1['schemaVersion'] as string,
-      targetFamily: contractJson1['targetFamily'] as string,
-      target: contractJson1['target'] as string,
-      models: contractJson1['models'] as Record<string, unknown>,
-      relations: (contractJson1['relations'] as Record<string, unknown>) || {},
-      storage: contractJson1['storage'] as Record<string, unknown>,
-      extensionPacks: contractJson1['extensionPacks'] as Record<string, unknown>,
-      capabilities:
-        (contractJson1['capabilities'] as Record<string, Record<string, boolean>>) || {},
-      meta: (contractJson1['meta'] as Record<string, unknown>) || {},
-      sources: (contractJson1['sources'] as Record<string, unknown>) || {},
-    });
+      const ir2 = createTestContract({
+        targetFamily: contractJson1['targetFamily'] as string,
+        target: contractJson1['target'] as string,
+        roots: contractJson1['roots'] as Record<string, string>,
+        models: contractJson1['models'] as Record<string, unknown>,
+        storage: contractJson1['storage'] as Record<string, unknown>,
+        extensionPacks: contractJson1['extensionPacks'] as Record<string, unknown>,
+        capabilities:
+          (contractJson1['capabilities'] as Record<string, Record<string, boolean>>) || {},
+        meta: (contractJson1['meta'] as Record<string, unknown>) || {},
+      });
 
-    const result2 = await emit(ir2, options, mockSqlHook);
+      const result2 = await emit(ir2, options, mockSqlHook);
 
-    expect(result1.contractJson).toBe(result2.contractJson);
-    expect(result1.coreHash).toBe(result2.coreHash);
-  });
+      expect(result1.contractJson).toBe(result2.contractJson);
+      expect(result1.storageHash).toBe(result2.storageHash);
+    },
+    timeouts.typeScriptCompilation,
+  );
 
   it('round-trip with nullable fields', async () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -256,14 +194,10 @@ describe('emitter round-trip', () => {
       },
     });
 
-    // Create minimal test data (emitter tests don't load packs)
-    const operationRegistry = createOperationRegistry();
     const codecTypeImports: TypesImportSpec[] = [];
     const operationTypeImports: TypesImportSpec[] = [];
     const extensionIds = ['postgres', 'pg'];
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
+    const options: EmitStackInput = {
       codecTypeImports,
       operationTypeImports,
       extensionIds,
@@ -272,24 +206,22 @@ describe('emitter round-trip', () => {
     const result1 = await emit(ir, options, mockSqlHook);
     const contractJson1 = JSON.parse(result1.contractJson) as Record<string, unknown>;
 
-    const ir2 = createContractIR({
-      schemaVersion: contractJson1['schemaVersion'] as string,
+    const ir2 = createTestContract({
       targetFamily: contractJson1['targetFamily'] as string,
       target: contractJson1['target'] as string,
+      roots: contractJson1['roots'] as Record<string, string>,
       models: contractJson1['models'] as Record<string, unknown>,
-      relations: (contractJson1['relations'] as Record<string, unknown>) || {},
       storage: contractJson1['storage'] as Record<string, unknown>,
       extensionPacks: contractJson1['extensionPacks'] as Record<string, unknown>,
       capabilities:
         (contractJson1['capabilities'] as Record<string, Record<string, boolean>>) || {},
       meta: (contractJson1['meta'] as Record<string, unknown>) || {},
-      sources: (contractJson1['sources'] as Record<string, unknown>) || {},
     });
 
     const result2 = await emit(ir2, options, mockSqlHook);
 
     expect(result1.contractJson).toBe(result2.contractJson);
-    expect(result1.coreHash).toBe(result2.coreHash);
+    expect(result1.storageHash).toBe(result2.storageHash);
 
     const parsed2 = JSON.parse(result2.contractJson) as Record<string, unknown>;
     const storage = parsed2['storage'] as Record<string, unknown>;
@@ -299,13 +231,13 @@ describe('emitter round-trip', () => {
     const id = columns['id'] as Record<string, unknown>;
     const email = columns['email'] as Record<string, unknown>;
     const name = columns['name'] as Record<string, unknown>;
-    expect(id['nullable']).toBeUndefined();
+    expect(id['nullable']).toBe(false);
     expect(email['nullable']).toBe(true);
-    expect(name['nullable']).toBeUndefined();
+    expect(name['nullable']).toBe(false);
   });
 
   it('round-trip with capabilities', async () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -331,14 +263,10 @@ describe('emitter round-trip', () => {
       },
     });
 
-    // Create minimal test data (emitter tests don't load packs)
-    const operationRegistry = createOperationRegistry();
     const codecTypeImports: TypesImportSpec[] = [];
     const operationTypeImports: TypesImportSpec[] = [];
     const extensionIds = ['postgres', 'pg'];
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
+    const options: EmitStackInput = {
       codecTypeImports,
       operationTypeImports,
       extensionIds,
@@ -347,24 +275,22 @@ describe('emitter round-trip', () => {
     const result1 = await emit(ir, options, mockSqlHook);
     const contractJson1 = JSON.parse(result1.contractJson) as Record<string, unknown>;
 
-    const ir2 = createContractIR({
-      schemaVersion: contractJson1['schemaVersion'] as string,
+    const ir2 = createTestContract({
       targetFamily: contractJson1['targetFamily'] as string,
       target: contractJson1['target'] as string,
+      roots: contractJson1['roots'] as Record<string, string>,
       models: contractJson1['models'] as Record<string, unknown>,
-      relations: (contractJson1['relations'] as Record<string, unknown>) || {},
       storage: contractJson1['storage'] as Record<string, unknown>,
       extensionPacks: contractJson1['extensionPacks'] as Record<string, unknown>,
       capabilities:
         (contractJson1['capabilities'] as Record<string, Record<string, boolean>>) || {},
       meta: (contractJson1['meta'] as Record<string, unknown>) || {},
-      sources: (contractJson1['sources'] as Record<string, unknown>) || {},
     });
 
     const result2 = await emit(ir2, options, mockSqlHook);
 
     expect(result1.contractJson).toBe(result2.contractJson);
-    expect(result1.coreHash).toBe(result2.coreHash);
+    expect(result1.storageHash).toBe(result2.storageHash);
     expect(result1.profileHash).toBe(result2.profileHash);
   });
 });