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

package/test/canonicalization.test.ts

@@ -1,12 +1,12 @@
-import { canonicalizeContract } from '@prisma-next/core-control-plane/emission';
+import { canonicalizeContract } from '@prisma-next/contract/hashing';
 import { describe, expect, it } from 'vitest';
-import { createContractIR } from './utils';
+import { createTestContract } from './utils';
 
 describe('canonicalization', () => {
   it('orders top-level sections correctly', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       capabilities: { postgres: { jsonAgg: true } },
-      meta: { source: 'test' },
+      meta: { emitterVersion: 'test' },
     });
 
     const result = canonicalizeContract(ir);
@@ -29,8 +29,8 @@ describe('canonicalization', () => {
     expect(capabilitiesIndex).toBeLessThan(metaIndex);
   });
 
-  it('omits nullable false from columns', () => {
-    const ir = createContractIR({
+  it('preserves nullable false on columns', () => {
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -51,12 +51,76 @@ describe('canonicalization', () => {
     const columns = user['columns'] as Record<string, unknown>;
     const id = columns['id'] as Record<string, unknown>;
     const email = columns['email'] as Record<string, unknown>;
-    expect(id['nullable']).toBeUndefined();
+    expect(id['nullable']).toBe(false);
     expect(email['nullable']).toBe(true);
   });
 
+  it('preserves nullable:false for columns with defaults', () => {
+    const ir = createTestContract({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              created_at: {
+                codecId: 'pg/timestamptz@1',
+                nativeType: 'timestamptz',
+                nullable: false,
+                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']).toBe(false);
+    expect(updatedAt['nullable']).toBe(true);
+  });
+
+  it('preserves nullable:true for columns with defaults', () => {
+    const ir = createTestContract({
+      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();
+    const ir = createTestContract();
 
     const result = canonicalizeContract(ir);
     const parsed = JSON.parse(result);
@@ -66,19 +130,17 @@ 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) are preserved even when empty.
     expect(parsed).toMatchObject({
       capabilities: expect.anything(),
       extensionPacks: expect.anything(),
       meta: expect.anything(),
-      relations: expect.anything(),
-      sources: expect.anything(),
     });
+    expect(parsed).not.toHaveProperty('relations');
   });
 
   it('preserves semantic array order for column lists', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -96,7 +158,7 @@ describe('canonicalization', () => {
 
     const result1 = canonicalizeContract(ir);
 
-    const ir2 = createContractIR({
+    const ir2 = createTestContract({
       storage: {
         tables: {
           user: {
@@ -117,8 +179,8 @@ describe('canonicalization', () => {
     expect(result1).not.toBe(result2);
   });
 
-  it('sorts non-semantic arrays by canonical name', () => {
-    const ir = createContractIR({
+  it('sorts indexes by canonical name', () => {
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -144,8 +206,62 @@ describe('canonicalization', () => {
     expect(indexNames).toEqual(['user_email_idx', 'user_name_idx']);
   });
 
+  it('sorts uniques by canonical name', () => {
+    const ir = createTestContract({
+      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 = createTestContract({
+      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({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -169,8 +285,69 @@ describe('canonicalization', () => {
     expect(columnKeys).toEqual(['a_field', 'm_field', 'z_field']);
   });
 
+  describe('Mongo storage.collections preservation', () => {
+    it('preserves empty storage.collections container', () => {
+      const ir = createTestContract({
+        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 = createTestContract({
+        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 = createTestContract({
+        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 = createTestContract({
+        targetFamily: 'mongo',
+        target: 'mongo',
+        storage: { collections: { users: {} } },
+      });
+      const ir2 = createTestContract({
+        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({
+    const ir = createTestContract({
       extensionPacks: {
         pgvector: { version: '0.0.1' },
         postgres: { version: '0.0.1' },
@@ -186,7 +363,7 @@ describe('canonicalization', () => {
   });
 
   it('omits generated false', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {