@prisma-next/emitter 0.3.0-dev.135 → 0.3.0-dev.146

package/test/hashing.test.ts

@@ -1,56 +1,34 @@
-import { computeProfileHash, computeStorageHash } from '@prisma-next/core-control-plane/emission';
+import { computeProfileHash, computeStorageHash } from '@prisma-next/contract/hashing';
 import { describe, expect, it } from 'vitest';
 
 describe('hashing', () => {
   it('computes storage hash', () => {
-    const contract = {
-      schemaVersion: '1',
+    const hash = computeStorageHash({
       targetFamily: 'sql',
       target: 'postgres',
-      models: {},
       storage: { tables: {} },
-      extensionPacks: {},
-      capabilities: {},
-      meta: {},
-      sources: {},
-    };
-
-    const hash = computeStorageHash(contract);
+    });
     expect(hash).toMatch(/^sha256:[a-f0-9]{64}$/);
   });
 
   it('computes profile hash', () => {
-    const contract = {
-      schemaVersion: '1',
+    const hash = computeProfileHash({
       targetFamily: 'sql',
       target: 'postgres',
-      models: {},
-      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',
+    const args = {
       targetFamily: 'sql',
       target: 'postgres',
-      models: {},
       storage: { tables: {} },
-      extensionPacks: {},
-      capabilities: {},
-      meta: {},
-      sources: {},
     };
 
-    const hash1 = computeStorageHash(contract);
-    const hash2 = computeStorageHash(contract);
+    const hash1 = computeStorageHash(args);
+    const hash2 = computeStorageHash(args);
     expect(hash1).toBe(hash2);
   });
 });

package/test/mock-spi.ts

@@ -0,0 +1,18 @@
+import type { EmissionSpi } from '@prisma-next/framework-components/emission';
+
+export function createMockSpi(overrides: Partial<EmissionSpi> = {}): EmissionSpi {
+  return {
+    id: 'sql',
+    generateStorageType: () =>
+      '{ readonly tables: Record<string, never>; readonly types: Record<string, never>; readonly storageHash: StorageHash }',
+    generateModelStorageType: () => 'Record<string, never>',
+    getFamilyImports: () => [
+      "import type { ContractWithTypeMaps, TypeMaps as TypeMapsType } from '@prisma-next/sql-contract/types';",
+    ],
+    getFamilyTypeAliases: () => 'export type LaneCodecTypes = CodecTypes;',
+    getTypeMapsExpression: () => 'TypeMapsType<CodecTypes, OperationTypes>',
+    getContractWrapper: (base, tm) =>
+      `export type Contract = ContractWithTypeMaps<${base}, ${tm}>;`,
+    ...overrides,
+  };
+}

package/test/type-expression-safety.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { isSafeTypeExpression } from '../src/type-expression-safety';
+
+describe('isSafeTypeExpression', () => {
+  it('accepts normal type expressions', () => {
+    expect(isSafeTypeExpression('Char<36>')).toBe(true);
+    expect(isSafeTypeExpression('Vector<1536>')).toBe(true);
+    expect(isSafeTypeExpression("'USER' | 'ADMIN'")).toBe(true);
+    expect(isSafeTypeExpression('{ name: string; age: number }')).toBe(true);
+    expect(isSafeTypeExpression('Numeric<10, 2>')).toBe(true);
+    expect(isSafeTypeExpression('Timestamp<3>')).toBe(true);
+  });
+
+  it('rejects import expressions', () => {
+    expect(isSafeTypeExpression('import("fs")')).toBe(false);
+    expect(isSafeTypeExpression('import ("fs")')).toBe(false);
+  });
+
+  it('rejects require expressions', () => {
+    expect(isSafeTypeExpression('require("fs")')).toBe(false);
+  });
+
+  it('rejects declare statements', () => {
+    expect(isSafeTypeExpression('declare module "foo"')).toBe(false);
+  });
+
+  it('rejects export statements', () => {
+    expect(isSafeTypeExpression('export default 42')).toBe(false);
+  });
+
+  it('rejects eval expressions', () => {
+    expect(isSafeTypeExpression('eval("code")')).toBe(false);
+  });
+});

package/test/utils.ts

@@ -1,157 +1,31 @@
-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> & { storageHash?: string; profileHash?: string } = {},
-): ContractIR {
-  // Check if fields are explicitly undefined (not just missing)
-  const hasTarget = 'target' in overrides;
-  const hasTargetFamily = 'targetFamily' in overrides;
-  const hasStorageHash = 'storageHash' in overrides;
-  const hasSchemaVersion = 'schemaVersion' in overrides;
-  const hasModels = 'models' 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;
-    storageHash?: 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 (hasStorageHash && overrides.storageHash !== undefined) {
-    headerOpts.storageHash = overrides.storageHash;
-  } else if (!hasStorageHash) {
-    headerOpts.storageHash = '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;
-      storageHash: 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 storageHash/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>),
-  } as ContractIR;
-
-  return result;
+import { createContract } from '@prisma-next/contract/testing';
+import type { Contract } from '@prisma-next/contract/types';
+
+type TestContractOverrides = {
+  target?: string;
+  targetFamily?: string;
+  roots?: Record<string, string>;
+  models?: Record<string, unknown>;
+  storage?: Record<string, unknown>;
+  capabilities?: Record<string, Record<string, boolean>>;
+  extensionPacks?: Record<string, unknown>;
+  execution?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
+  storageHash?: string;
+  schemaVersion?: string;
+  sources?: Record<string, unknown>;
+};
+
+export function createTestContract(overrides: TestContractOverrides = {}): Contract {
+  const { storageHash: _sh, schemaVersion: _sv, sources: _src, storage, ...rest } = overrides;
+  const cleanStorage = storage
+    ? (() => {
+        const { storageHash: _innerSh, ...storageRest } = storage as Record<string, unknown>;
+        return storageRest;
+      })()
+    : undefined;
+  return createContract({
+    ...rest,
+    ...(cleanStorage ? { storage: cleanStorage } : {}),
+  } as Parameters<typeof createContract>[0]);
 }

package/src/target-family.ts

@@ -1,7 +0,0 @@
-// 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/factories.test.ts

@@ -1,274 +0,0 @@
-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',
-        storageHash: 'sha256:abc123',
-      });
-      expect(header).toEqual({
-        schemaVersion: '1',
-        target: 'postgres',
-        targetFamily: 'sql',
-        storageHash: 'sha256:abc123',
-      });
-    });
-
-    it('creates header with profileHash', () => {
-      const header = irHeader({
-        target: 'postgres',
-        targetFamily: 'sql',
-        storageHash: 'sha256:abc123',
-        profileHash: 'sha256:def456',
-      });
-      expect(header).toEqual({
-        schemaVersion: '1',
-        target: 'postgres',
-        targetFamily: 'sql',
-        storageHash: 'sha256:abc123',
-        profileHash: 'sha256:def456',
-      });
-    });
-
-    it('creates header for different target families', () => {
-      const header = irHeader({
-        target: 'mongodb',
-        targetFamily: 'document',
-        storageHash: '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',
-        storageHash: '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: storageHash 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',
-        storageHash: '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',
-        storageHash: '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',
-        storageHash: '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);
-    });
-  });
-});