@prisma-next/emitter 0.3.0-dev.3 → 0.3.0-dev.30

package/dist/src/exports/index.d.ts

@@ -0,0 +1,4 @@
+export type { TargetFamilyHook, TypesImportSpec, ValidationContext, } from '@prisma-next/contract/types';
+export type { EmitOptions, EmitResult } from '@prisma-next/core-control-plane/emission';
+export { emit } from '@prisma-next/core-control-plane/emission';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/exports/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exports/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,iBAAiB,GAClB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,IAAI,EAAE,MAAM,0CAA0C,CAAC"}

package/dist/src/target-family.d.ts

@@ -0,0 +1,2 @@
+export type { TargetFamilyHook, TypesImportSpec, ValidationContext, } from '@prisma-next/contract/types';
+//# sourceMappingURL=target-family.d.ts.map

package/dist/src/target-family.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target-family.d.ts","sourceRoot":"","sources":["../../src/target-family.ts"],"names":[],"mappings":"AAEA,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,iBAAiB,GAClB,MAAM,6BAA6B,CAAC"}

package/dist/test/utils.d.ts

@@ -1,5 +1,4 @@
-import { ContractIR } from '@prisma-next/contract/ir';
-
+import { type ContractIR } from '@prisma-next/contract/ir';
 /**
  * Factory function for creating ContractIR objects in tests.
  * Provides sensible defaults and allows overriding specific fields.
@@ -8,9 +7,8 @@ import { ContractIR } from '@prisma-next/contract/ir';
  * If a field is explicitly set to `undefined` in overrides, it will be omitted
  * from the result (useful for testing validation of missing fields).
  */
-declare function createContractIR(overrides?: Partial<ContractIR> & {
+export declare function createContractIR(overrides?: Partial<ContractIR> & {
     coreHash?: string;
     profileHash?: string;
 }): ContractIR;
-
-export { createContractIR };
+//# sourceMappingURL=utils.d.ts.map

package/dist/test/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../test/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,0BAA0B,CAAC;AAE7E;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,GAAE,OAAO,CAAC,UAAU,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAChF,UAAU,CAyJZ"}

package/package.json

@@ -1,28 +1,30 @@
 {
   "name": "@prisma-next/emitter",
-  "version": "0.3.0-dev.3",
+  "version": "0.3.0-dev.30",
   "type": "module",
   "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "src",
+    "test"
   ],
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/contract": "0.3.0-dev.3",
-    "@prisma-next/core-control-plane": "0.3.0-dev.3"
+    "@prisma-next/contract": "0.3.0-dev.30",
+    "@prisma-next/core-control-plane": "0.3.0-dev.30"
   },
   "devDependencies": {
     "@types/node": "24.10.4",
-    "@vitest/coverage-v8": "^4.0.0",
-    "tsup": "^8.3.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.16",
-    "@prisma-next/operations": "0.3.0-dev.3",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "vitest": "4.0.16",
+    "@prisma-next/operations": "0.3.0-dev.30",
+    "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/test-utils": "0.0.1"
   },
   "exports": {
     ".": {
-      "types": "./dist/exports/index.d.ts",
+      "types": "./dist/src/exports/index.d.ts",
       "import": "./dist/exports/index.js"
     },
     "./test/utils": {
@@ -31,13 +33,13 @@
     }
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts",
+    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --project tsconfig.json --noEmit",
-    "lint": "biome check . --config-path ../../../../biome.json --error-on-warnings",
-    "lint:fix": "biome check --write . --config-path ../../../../biome.json",
-    "lint:fix:unsafe": "biome check --write --unsafe . --config-path ../../../../biome.json",
-    "clean": "node ../../../../scripts/clean.mjs"
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

package/src/exports/index.ts

@@ -0,0 +1,9 @@
+// Re-export types from @prisma-next/contract for backward compatibility
+export type {
+  TargetFamilyHook,
+  TypesImportSpec,
+  ValidationContext,
+} from '@prisma-next/contract/types';
+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';

package/src/target-family.ts

@@ -0,0 +1,7 @@
+// Re-export types from @prisma-next/contract for backward compatibility
+// These types were moved to @prisma-next/contract to resolve dependency violations
+export type {
+  TargetFamilyHook,
+  TypesImportSpec,
+  ValidationContext,
+} from '@prisma-next/contract/types';

package/test/canonicalization.test.ts

@@ -0,0 +1,210 @@
+import { canonicalizeContract } from '@prisma-next/core-control-plane/emission';
+import { describe, expect, it } from 'vitest';
+import { createContractIR } from './utils';
+
+describe('canonicalization', () => {
+  it('orders top-level sections correctly', () => {
+    const ir = createContractIR({
+      capabilities: { postgres: { jsonAgg: true } },
+      meta: { source: 'test' },
+    });
+
+    const result = canonicalizeContract(ir);
+    const parsed = JSON.parse(result) as Record<string, unknown>;
+
+    const keys = Object.keys(parsed);
+    const schemaVersionIndex = keys.indexOf('schemaVersion');
+    const targetFamilyIndex = keys.indexOf('targetFamily');
+    const targetIndex = keys.indexOf('target');
+    const modelsIndex = keys.indexOf('models');
+    const storageIndex = keys.indexOf('storage');
+    const capabilitiesIndex = keys.indexOf('capabilities');
+    const metaIndex = keys.indexOf('meta');
+
+    expect(schemaVersionIndex).toBeLessThan(targetFamilyIndex);
+    expect(targetFamilyIndex).toBeLessThan(targetIndex);
+    expect(targetIndex).toBeLessThan(modelsIndex);
+    expect(modelsIndex).toBeLessThan(storageIndex);
+    expect(storageIndex).toBeLessThan(capabilitiesIndex);
+    expect(capabilitiesIndex).toBeLessThan(metaIndex);
+  });
+
+  it('omits nullable false from columns', () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+              email: { codecId: 'pg/text@1', nativeType: 'text', 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 id = columns['id'] as Record<string, unknown>;
+    const email = columns['email'] as Record<string, unknown>;
+    expect(id['nullable']).toBeUndefined();
+    expect(email['nullable']).toBe(true);
+  });
+
+  it('omits empty arrays and objects except required ones', () => {
+    const ir = createContractIR();
+
+    const result = canonicalizeContract(ir);
+    const parsed = JSON.parse(result);
+    expect(parsed).toMatchObject({
+      models: expect.anything(),
+      storage: {
+        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
+    expect(parsed).toMatchObject({
+      capabilities: expect.anything(),
+      extensionPacks: expect.anything(),
+      meta: expect.anything(),
+      relations: expect.anything(),
+      sources: expect.anything(),
+    });
+  });
+
+  it('preserves semantic array order for column lists', () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              first: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+              second: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+            },
+            primaryKey: {
+              columns: ['second', 'first'],
+            },
+          },
+        },
+      },
+    });
+
+    const result1 = canonicalizeContract(ir);
+
+    const ir2 = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              first: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+              second: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+            },
+            primaryKey: {
+              columns: ['first', 'second'],
+            },
+          },
+        },
+      },
+    });
+
+    const result2 = canonicalizeContract(ir2);
+
+    expect(result1).not.toBe(result2);
+  });
+
+  it('sorts non-semantic arrays by canonical name', () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+            },
+            indexes: [
+              { columns: ['id'], name: 'user_email_idx' },
+              { columns: ['id'], name: 'user_name_idx' },
+            ],
+          },
+        },
+      },
+    });
+
+    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 indexes = user['indexes'] as Array<{ name: string }>;
+    const indexNames = indexes.map((idx) => idx.name);
+    expect(indexNames).toEqual(['user_email_idx', 'user_name_idx']);
+  });
+
+  it('sorts nested object keys lexicographically', () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              z_field: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+              a_field: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+              m_field: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+            },
+          },
+        },
+      },
+    });
+
+    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 columnKeys = Object.keys(columns);
+    expect(columnKeys).toEqual(['a_field', 'm_field', 'z_field']);
+  });
+
+  it('sorts extension namespaces lexicographically', () => {
+    const ir = createContractIR({
+      extensionPacks: {
+        pgvector: { version: '0.0.1' },
+        postgres: { version: '0.0.1' },
+        another: { version: '0.0.1' },
+      },
+    });
+
+    const result = canonicalizeContract(ir);
+    const parsed = JSON.parse(result) as Record<string, unknown>;
+    const extensionPacks = parsed['extensionPacks'] as Record<string, unknown>;
+    const extensionKeys = Object.keys(extensionPacks);
+    expect(extensionKeys).toEqual(['another', 'pgvector', 'postgres']);
+  });
+
+  it('omits generated false', () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false, generated: false },
+            },
+          },
+        },
+      },
+    });
+
+    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 id = columns['id'] as Record<string, unknown>;
+    expect(id['generated']).toBeUndefined();
+  });
+});

package/test/emitter.integration.test.ts

@@ -0,0 +1,274 @@
+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 { timeouts } from '@prisma-next/test-utils';
+import { describe, expect, it } from 'vitest';
+import { createContractIR } from './utils';
+
+const mockSqlHook: TargetFamilyHook = {
+  id: 'sql',
+  validateTypes: (ir: ContractIR, _ctx: ValidationContext) => {
+    const storage = ir.storage as
+      | { tables?: Record<string, { columns?: Record<string, { type?: 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;
+`;
+  },
+};
+
+describe('emitter integration', () => {
+  it(
+    'emits complete contract from IR to artifacts',
+    async () => {
+      const ir = createContractIR({
+        models: {
+          User: {
+            storage: { table: 'user' },
+            fields: {
+              id: { column: 'id' },
+              email: { column: 'email' },
+            },
+            relations: {},
+          },
+        },
+        storage: {
+          tables: {
+            user: {
+              columns: {
+                id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+                email: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+              },
+              primaryKey: { columns: ['id'] },
+              uniques: [],
+              indexes: [],
+              foreignKeys: [],
+            },
+          },
+        },
+        extensionPacks: {
+          postgres: {
+            version: '0.0.1',
+          },
+          pg: {},
+        },
+      });
+
+      // 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,
+        codecTypeImports,
+        operationTypeImports,
+        extensionIds,
+      };
+
+      const result = await emit(ir, options, mockSqlHook);
+
+      expect(result.coreHash).toMatch(/^sha256:[a-f0-9]{64}$/);
+      expect(result.contractDts).toContain('export type Contract');
+      expect(result.contractDts).toContain('CodecTypes');
+      expect(result.contractDts).toContain('LaneCodecTypes');
+
+      const contractJson = JSON.parse(result.contractJson);
+      expect(contractJson).toMatchObject({
+        schemaVersion: '1',
+        targetFamily: 'sql',
+        target: 'postgres',
+        coreHash: result.coreHash,
+        storage: {
+          tables: {
+            user: expect.anything(),
+          },
+        },
+      });
+    },
+    timeouts.typeScriptCompilation,
+  );
+
+  it('produces stable hashes for identical input', async () => {
+    const ir = createContractIR({
+      models: {
+        User: {
+          storage: { table: 'user' },
+          fields: {
+            id: { column: 'id' },
+          },
+          relations: {},
+        },
+      },
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+            },
+            primaryKey: { columns: ['id'] },
+            uniques: [],
+            indexes: [],
+            foreignKeys: [],
+          },
+        },
+      },
+      extensionPacks: {
+        postgres: {
+          version: '0.0.1',
+        },
+        pg: {},
+      },
+    });
+
+    // 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,
+      codecTypeImports,
+      operationTypeImports,
+      extensionIds,
+    };
+
+    const result1 = await emit(ir, options, mockSqlHook);
+    const result2 = await emit(ir, options, mockSqlHook);
+
+    expect(result1.coreHash).toBe(result2.coreHash);
+    expect(result1.contractDts).toBe(result2.contractDts);
+    expect(result1.contractJson).toBe(result2.contractJson);
+  });
+
+  it('round-trip: IR → JSON → parse JSON → compare', async () => {
+    const ir = createContractIR({
+      models: {
+        User: {
+          storage: { table: 'user' },
+          fields: {
+            id: { column: 'id' },
+            email: { column: 'email' },
+          },
+          relations: {},
+        },
+      },
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+              email: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+            },
+            primaryKey: { columns: ['id'] },
+            uniques: [],
+            indexes: [],
+            foreignKeys: [],
+          },
+        },
+      },
+      extensionPacks: {
+        postgres: {
+          version: '0.0.1',
+        },
+        pg: {},
+      },
+    });
+
+    // 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,
+      codecTypeImports,
+      operationTypeImports,
+      extensionIds,
+    };
+
+    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 result2 = await emit(ir2, options, mockSqlHook);
+
+    expect(result1.contractJson).toBe(result2.contractJson);
+    expect(result1.coreHash).toBe(result2.coreHash);
+  });
+});