@prisma-next/emitter 0.3.0-dev.46 → 0.3.0-dev.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/emitter",
-  "version": "0.3.0-dev.46",
+  "version": "0.3.0-dev.48",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -10,16 +10,16 @@
   ],
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/core-control-plane": "0.3.0-dev.46",
-    "@prisma-next/contract": "0.3.0-dev.46"
+    "@prisma-next/contract": "0.3.0-dev.48",
+    "@prisma-next/core-control-plane": "0.3.0-dev.48"
   },
   "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.48",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/operations": "0.3.0-dev.46",
     "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0"
   },

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);
@@ -133,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(),
     });
   });
 

package/test/emitter.test.ts

@@ -572,10 +572,12 @@ describe('emitter', () => {
     await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have meta');
   });
 
-  it('throws error when sources is missing', async () => {
+  it('omits sources from emitted contract artifact', async () => {
     const ir = createContractIR({
-      sources: undefined as unknown as Record<string, unknown>,
-    }) as ContractIR;
+      sources: {
+        schema: { sourceId: 'schema.prisma' },
+      },
+    });
 
     const operationRegistry = createOperationRegistry();
     const options: EmitOptions = {
@@ -586,24 +588,68 @@ describe('emitter', () => {
       extensionIds: [],
     };
 
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have sources');
+    const result = await emit(ir, options, mockSqlHook);
+    const contractJson = JSON.parse(result.contractJson) as Record<string, unknown>;
+    expect(contractJson).not.toHaveProperty('sources');
   });
 
-  it('throws error when sources is not an object', async () => {
+  it('accepts meta keys when family validation allows them', async () => {
     const ir = createContractIR({
-      sources: 'not-an-object' as unknown as Record<string, unknown>,
-    }) as ContractIR;
+      meta: {
+        sourceId: 'schema.prisma',
+        schemaPath: '/tmp/schema.prisma',
+        source: 'psl',
+      },
+    });
 
-    const operationRegistry = createOperationRegistry();
     const options: EmitOptions = {
       outputDir: '',
-      operationRegistry,
+      operationRegistry: createOperationRegistry(),
       codecTypeImports: [],
       operationTypeImports: [],
       extensionIds: [],
     };
 
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have sources');
+    await expect(emit(ir, options, mockSqlHook)).resolves.toMatchObject({
+      contractJson: expect.any(String),
+      contractDts: expect.any(String),
+    });
+  });
+
+  it('accepts canonical section keys when family validation allows them', async () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              id: {
+                codecId: 'pg/int4@1',
+                nativeType: 'int4',
+                nullable: false,
+                sourceId: 'schema.prisma',
+              },
+            },
+            primaryKey: { columns: ['id'] },
+            uniques: [],
+            indexes: [],
+            foreignKeys: [],
+          },
+        },
+      } as unknown as Record<string, unknown>,
+    });
+
+    const options: EmitOptions = {
+      outputDir: '',
+      operationRegistry: createOperationRegistry(),
+      codecTypeImports: [],
+      operationTypeImports: [],
+      extensionIds: [],
+    };
+
+    await expect(emit(ir, options, mockSqlHook)).resolves.toMatchObject({
+      contractJson: expect.any(String),
+      contractDts: expect.any(String),
+    });
   });
 
   it('emits contract even when extensionIds are not in contract.extensionPacks', async () => {