@prisma-next/emitter 0.3.0-dev.2 → 0.3.0-dev.21

package/test/factories.test.ts

@@ -0,0 +1,274 @@
+import { contractIR, irHeader, irMeta } from '@prisma-next/contract/ir';
+import { describe, expect, it } from 'vitest';
+
+describe('emitter factories', () => {
+  describe('irHeader', () => {
+    it('creates header with required fields', () => {
+      const header = irHeader({
+        target: 'postgres',
+        targetFamily: 'sql',
+        coreHash: 'sha256:abc123',
+      });
+      expect(header).toEqual({
+        schemaVersion: '1',
+        target: 'postgres',
+        targetFamily: 'sql',
+        coreHash: 'sha256:abc123',
+      });
+    });
+
+    it('creates header with profileHash', () => {
+      const header = irHeader({
+        target: 'postgres',
+        targetFamily: 'sql',
+        coreHash: 'sha256:abc123',
+        profileHash: 'sha256:def456',
+      });
+      expect(header).toEqual({
+        schemaVersion: '1',
+        target: 'postgres',
+        targetFamily: 'sql',
+        coreHash: 'sha256:abc123',
+        profileHash: 'sha256:def456',
+      });
+    });
+
+    it('creates header for different target families', () => {
+      const header = irHeader({
+        target: 'mongodb',
+        targetFamily: 'document',
+        coreHash: 'sha256:xyz789',
+      });
+      expect(header.targetFamily).toBe('document');
+      expect(header.target).toBe('mongodb');
+    });
+  });
+
+  describe('irMeta', () => {
+    it('creates empty meta when no options provided', () => {
+      const meta = irMeta({});
+      expect(meta).toEqual({
+        capabilities: {},
+        extensionPacks: {},
+        meta: {},
+        sources: {},
+      });
+    });
+
+    it('creates meta with capabilities', () => {
+      const meta = irMeta({
+        capabilities: {
+          postgres: {
+            returning: true,
+            lateral: true,
+          },
+        },
+      });
+      expect(meta.capabilities).toEqual({
+        postgres: {
+          returning: true,
+          lateral: true,
+        },
+      });
+      expect(meta.extensionPacks).toEqual({});
+      expect(meta.meta).toEqual({});
+      expect(meta.sources).toEqual({});
+    });
+
+    it('creates meta with extension packs', () => {
+      const meta = irMeta({
+        extensionPacks: {
+          postgres: {
+            id: 'postgres',
+            version: '0.0.1',
+          },
+        },
+      });
+      expect(meta.extensionPacks).toEqual({
+        postgres: {
+          id: 'postgres',
+          version: '0.0.1',
+        },
+      });
+    });
+
+    it('creates meta with custom meta', () => {
+      const meta = irMeta({
+        meta: {
+          generated: true,
+          timestamp: '2024-01-01T00:00:00Z',
+        },
+      });
+      expect(meta.meta).toEqual({
+        generated: true,
+        timestamp: '2024-01-01T00:00:00Z',
+      });
+    });
+
+    it('creates meta with sources', () => {
+      const meta = irMeta({
+        sources: {
+          userView: {
+            kind: 'view',
+            sql: 'SELECT * FROM "user"',
+          },
+        },
+      });
+      expect(meta.sources).toEqual({
+        userView: {
+          kind: 'view',
+          sql: 'SELECT * FROM "user"',
+        },
+      });
+    });
+
+    it('creates meta with all fields', () => {
+      const meta = irMeta({
+        capabilities: {
+          postgres: { returning: true },
+        },
+        extensionPacks: {
+          postgres: { id: 'postgres', version: '0.0.1' },
+        },
+        meta: { generated: true },
+        sources: { userView: { kind: 'view' } },
+      });
+      expect(meta.capabilities).toEqual({
+        postgres: { returning: true },
+      });
+      expect(meta.extensionPacks).toEqual({
+        postgres: { id: 'postgres', version: '0.0.1' },
+      });
+      expect(meta.meta).toEqual({ generated: true });
+      expect(meta.sources).toEqual({ userView: { kind: 'view' } });
+    });
+  });
+
+  describe('contractIR', () => {
+    it('creates complete ContractIR from header, meta, and family sections', () => {
+      const header = irHeader({
+        target: 'postgres',
+        targetFamily: 'sql',
+        coreHash: 'sha256:abc123',
+      });
+      const meta = irMeta({
+        capabilities: {
+          postgres: { returning: true },
+        },
+      });
+      const storage = { tables: { user: { columns: {} } } };
+      const models = { User: { storage: { table: 'user' }, fields: {} } };
+      const relations = {};
+
+      const ir = contractIR({
+        header,
+        meta,
+        storage,
+        models,
+        relations,
+      });
+
+      expect(ir.schemaVersion).toBe('1');
+      expect(ir.target).toBe('postgres');
+      expect(ir.targetFamily).toBe('sql');
+      // Note: coreHash is not part of ContractIR (it's computed by emitter)
+      expect(ir.storage).toEqual(storage);
+      expect(ir.models).toEqual(models);
+      expect(ir.relations).toEqual(relations);
+      expect(ir.capabilities).toEqual({
+        postgres: { returning: true },
+      });
+      expect(ir.extensionPacks).toEqual({});
+      expect(ir.meta).toEqual({});
+      expect(ir.sources).toEqual({});
+    });
+
+    it('creates ContractIR with profileHash in header', () => {
+      const header = irHeader({
+        target: 'postgres',
+        targetFamily: 'sql',
+        coreHash: 'sha256:abc123',
+        profileHash: 'sha256:def456',
+      });
+      const meta = irMeta({});
+      const storage = { tables: {} };
+      const models = {};
+      const relations = {};
+
+      const ir = contractIR({
+        header,
+        meta,
+        storage,
+        models,
+        relations,
+      });
+
+      // Note: profileHash is not part of ContractIR (it's computed by emitter)
+      // The header contains it, but it's not included in the ContractIR
+      expect(header.profileHash).toBe('sha256:def456');
+      expect(ir.target).toBe('postgres');
+    });
+
+    it('creates ContractIR with all meta fields', () => {
+      const header = irHeader({
+        target: 'postgres',
+        targetFamily: 'sql',
+        coreHash: 'sha256:abc123',
+      });
+      const meta = irMeta({
+        capabilities: {
+          postgres: { returning: true },
+        },
+        extensionPacks: {
+          postgres: { id: 'postgres', version: '0.0.1' },
+        },
+        meta: { generated: true },
+        sources: { userView: { kind: 'view' } },
+      });
+      const storage = { tables: {} };
+      const models = {};
+      const relations = {};
+
+      const ir = contractIR({
+        header,
+        meta,
+        storage,
+        models,
+        relations,
+      });
+
+      expect(ir.capabilities).toEqual({
+        postgres: { returning: true },
+      });
+      expect(ir.extensionPacks).toEqual({
+        postgres: { id: 'postgres', version: '0.0.1' },
+      });
+      expect(ir.meta).toEqual({ generated: true });
+      expect(ir.sources).toEqual({ userView: { kind: 'view' } });
+    });
+
+    it('creates ContractIR for document family', () => {
+      const header = irHeader({
+        target: 'mongodb',
+        targetFamily: 'document',
+        coreHash: 'sha256:xyz789',
+      });
+      const meta = irMeta({});
+      const storage = { document: { collections: {} } };
+      const models = {};
+      const relations = {};
+
+      const ir = contractIR({
+        header,
+        meta,
+        storage,
+        models,
+        relations,
+      });
+
+      expect(ir.targetFamily).toBe('document');
+      expect(ir.target).toBe('mongodb');
+      expect(ir.storage).toEqual(storage);
+    });
+  });
+});

package/test/hashing.test.ts

@@ -0,0 +1,59 @@
+import { computeCoreHash, computeProfileHash } from '@prisma-next/core-control-plane/emission';
+import { describe, expect, it } from 'vitest';
+
+describe('hashing', () => {
+  it('computes core hash', () => {
+    const contract = {
+      schemaVersion: '1',
+      targetFamily: 'sql',
+      target: 'postgres',
+      models: {},
+      relations: {},
+      storage: { tables: {} },
+      extensionPacks: {},
+      capabilities: {},
+      meta: {},
+      sources: {},
+    };
+
+    const hash = computeCoreHash(contract);
+    expect(hash).toMatch(/^sha256:[a-f0-9]{64}$/);
+  });
+
+  it('computes profile hash', () => {
+    const contract = {
+      schemaVersion: '1',
+      targetFamily: 'sql',
+      target: 'postgres',
+      models: {},
+      relations: {},
+      storage: { tables: {} },
+      extensionPacks: {},
+      capabilities: { postgres: { jsonAgg: true } },
+      meta: {},
+      sources: {},
+    };
+
+    const hash = computeProfileHash(contract);
+    expect(hash).toMatch(/^sha256:[a-f0-9]{64}$/);
+  });
+
+  it('produces stable hashes for identical input', () => {
+    const contract = {
+      schemaVersion: '1',
+      targetFamily: 'sql',
+      target: 'postgres',
+      models: {},
+      relations: {},
+      storage: { tables: {} },
+      extensionPacks: {},
+      capabilities: {},
+      meta: {},
+      sources: {},
+    };
+
+    const hash1 = computeCoreHash(contract);
+    const hash2 = computeCoreHash(contract);
+    expect(hash1).toBe(hash2);
+  });
+});

package/test/utils.ts

@@ -0,0 +1,166 @@
+import { type ContractIR, irHeader, irMeta } from '@prisma-next/contract/ir';
+
+/**
+ * Factory function for creating ContractIR objects in tests.
+ * Provides sensible defaults and allows overriding specific fields.
+ * Uses the emitter factories internally for consistency.
+ *
+ * If a field is explicitly set to `undefined` in overrides, it will be omitted
+ * from the result (useful for testing validation of missing fields).
+ */
+export function createContractIR(
+  overrides: Partial<ContractIR> & { coreHash?: string; profileHash?: string } = {},
+): ContractIR {
+  // Check if fields are explicitly undefined (not just missing)
+  const hasTarget = 'target' in overrides;
+  const hasTargetFamily = 'targetFamily' in overrides;
+  const hasCoreHash = 'coreHash' in overrides;
+  const hasSchemaVersion = 'schemaVersion' in overrides;
+  const hasModels = 'models' in overrides;
+  const hasRelations = 'relations' in overrides;
+  const hasStorage = 'storage' in overrides;
+  const hasCapabilities = 'capabilities' in overrides;
+  const hasExtensionPacks = 'extensionPacks' in overrides;
+  const hasMeta = 'meta' in overrides;
+  const hasSources = 'sources' in overrides;
+
+  // Build header, omitting fields that are explicitly undefined
+  const headerOpts: {
+    target?: string;
+    targetFamily?: string;
+    coreHash?: string;
+    profileHash?: string;
+  } = {};
+
+  if (hasTarget && overrides.target !== undefined) {
+    headerOpts.target = overrides.target;
+  } else if (!hasTarget) {
+    headerOpts.target = 'postgres';
+  }
+
+  if (hasTargetFamily && overrides.targetFamily !== undefined) {
+    headerOpts.targetFamily = overrides.targetFamily;
+  } else if (!hasTargetFamily) {
+    headerOpts.targetFamily = 'sql';
+  }
+
+  if (hasCoreHash && overrides.coreHash !== undefined) {
+    headerOpts.coreHash = overrides.coreHash;
+  } else if (!hasCoreHash) {
+    headerOpts.coreHash = 'sha256:test';
+  }
+
+  // profileHash is not part of ContractIR, but we can accept it for header creation
+  if (overrides.profileHash !== undefined) {
+    headerOpts.profileHash = overrides.profileHash;
+  }
+
+  const header = irHeader(
+    headerOpts as {
+      target: string;
+      targetFamily: string;
+      coreHash: string;
+      profileHash?: string;
+    },
+  );
+
+  // Build meta, handling explicitly undefined fields
+  // If a field is explicitly undefined, we'll omit it from the result later
+  const metaOpts: {
+    capabilities?: Record<string, Record<string, boolean>>;
+    extensionPacks?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+    sources?: Record<string, unknown>;
+  } = {};
+
+  if (hasCapabilities && overrides.capabilities !== undefined) {
+    metaOpts.capabilities = overrides.capabilities;
+  } else if (!hasCapabilities) {
+    metaOpts.capabilities = {};
+  }
+
+  if (hasExtensionPacks && overrides.extensionPacks !== undefined) {
+    metaOpts.extensionPacks = overrides.extensionPacks;
+  } else if (!hasExtensionPacks) {
+    metaOpts.extensionPacks = {};
+  }
+
+  if (hasMeta && overrides.meta !== undefined) {
+    metaOpts.meta = overrides.meta;
+  } else if (!hasMeta) {
+    metaOpts.meta = {};
+  }
+
+  if (hasSources && overrides.sources !== undefined) {
+    metaOpts.sources = overrides.sources;
+  } else if (!hasSources) {
+    metaOpts.sources = {};
+  }
+
+  const meta = irMeta(Object.keys(metaOpts).length > 0 ? metaOpts : undefined);
+
+  // Build result by constructing the object directly (ContractIR doesn't include coreHash/profileHash)
+  // When fields are explicitly undefined, include them as undefined (tests use type assertions to bypass TS)
+  const result = {
+    schemaVersion:
+      hasSchemaVersion && overrides.schemaVersion !== undefined
+        ? overrides.schemaVersion
+        : hasSchemaVersion && overrides.schemaVersion === undefined
+          ? (undefined as unknown as string)
+          : header.schemaVersion,
+    target: header.target,
+    targetFamily: header.targetFamily,
+    // Only include meta fields if they're not explicitly undefined
+    capabilities:
+      hasCapabilities && overrides.capabilities === undefined
+        ? (undefined as unknown as Record<string, Record<string, boolean>>)
+        : !hasCapabilities || overrides.capabilities !== undefined
+          ? meta.capabilities
+          : ({} as Record<string, Record<string, boolean>>),
+    extensionPacks:
+      hasExtensionPacks && overrides.extensionPacks === undefined
+        ? (undefined as unknown as Record<string, unknown>)
+        : !hasExtensionPacks || overrides.extensionPacks !== undefined
+          ? meta.extensionPacks
+          : ({} as Record<string, unknown>),
+    meta:
+      hasMeta && overrides.meta === undefined
+        ? (undefined as unknown as Record<string, unknown>)
+        : !hasMeta || overrides.meta !== undefined
+          ? meta.meta
+          : ({} as Record<string, unknown>),
+    sources:
+      hasSources && overrides.sources === undefined
+        ? (undefined as unknown as Record<string, unknown>)
+        : !hasSources || overrides.sources !== undefined
+          ? meta.sources
+          : ({} as Record<string, unknown>),
+    // Only include family sections if they're not explicitly undefined
+    storage:
+      hasStorage && overrides.storage === undefined
+        ? (undefined as unknown as Record<string, unknown>)
+        : hasStorage && overrides.storage !== undefined
+          ? (overrides.storage as Record<string, unknown>)
+          : !hasStorage
+            ? ({ tables: {} } as Record<string, unknown>)
+            : ({} as Record<string, unknown>),
+    models:
+      hasModels && overrides.models === undefined
+        ? (undefined as unknown as Record<string, unknown>)
+        : hasModels && overrides.models !== undefined
+          ? (overrides.models as Record<string, unknown>)
+          : !hasModels
+            ? {}
+            : ({} as Record<string, unknown>),
+    relations:
+      hasRelations && overrides.relations === undefined
+        ? (undefined as unknown as Record<string, unknown>)
+        : hasRelations && overrides.relations !== undefined
+          ? (overrides.relations as Record<string, unknown>)
+          : !hasRelations
+            ? {}
+            : ({} as Record<string, unknown>),
+  } as ContractIR;
+
+  return result;
+}

package/dist/exports/index.d.ts

@@ -1,2 +0,0 @@
-export { TargetFamilyHook, TypesImportSpec, ValidationContext } from '@prisma-next/contract/types';
-export { EmitOptions, EmitResult, emit } from '@prisma-next/core-control-plane/emission';