@prisma-next/emitter 0.5.0-dev.4 → 0.5.0-dev.41

package/test/emitter.test.ts

@@ -1,367 +0,0 @@
-import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
-import { timeouts } from '@prisma-next/test-utils';
-import { describe, expect, it } from 'vitest';
-import type { EmitStackInput } from '../src/exports';
-import { emit, getEmittedArtifactPaths } from '../src/exports';
-import { createMockSpi } from './mock-spi';
-import { createTestContract } from './utils';
-
-const mockSqlHook = createMockSpi();
-
-describe('emitter', () => {
-  it('derives colocated artifact paths from contract.json output', () => {
-    expect(getEmittedArtifactPaths('/abs/contract.json')).toEqual({
-      jsonPath: '/abs/contract.json',
-      dtsPath: '/abs/contract.d.ts',
-    });
-  });
-
-  it('rejects non-json output paths when deriving artifact paths', () => {
-    expect(() => getEmittedArtifactPaths('/abs/contract.ts')).toThrow(
-      'Contract output path must end with .json',
-    );
-  });
-
-  it(
-    'rejects non-json output paths when emit receives an output path',
-    async () => {
-      const ir = createTestContract();
-      const options: EmitStackInput = {
-        codecTypeImports: [],
-        operationTypeImports: [],
-      };
-
-      await expect(
-        emit(ir, options, mockSqlHook, {
-          outputJsonPath: '/abs/contract.ts',
-        }),
-      ).rejects.toThrow('Contract output path must end with .json');
-    },
-    timeouts.typeScriptCompilation,
-  );
-
-  it(
-    'emits contract.json and contract.d.ts',
-    async () => {
-      const ir = createTestContract({
-        models: {
-          User: {
-            storage: {
-              table: 'user',
-              fields: {
-                id: { column: 'id' },
-                email: { column: 'email' },
-              },
-            },
-            fields: {
-              id: { type: { kind: 'scalar', codecId: 'pg/int4@1' }, nullable: false },
-              email: { type: { kind: 'scalar', codecId: 'pg/text@1' }, nullable: false },
-            },
-            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: {},
-        },
-      });
-
-      const codecTypeImports: TypesImportSpec[] = [];
-      const operationTypeImports: TypesImportSpec[] = [];
-      const extensionIds = ['postgres', 'pg'];
-      const options: EmitStackInput = {
-        codecTypeImports,
-        operationTypeImports,
-        extensionIds,
-      };
-
-      const result = await emit(ir, options, mockSqlHook);
-      expect(result.storageHash).toMatch(/^sha256:[a-f0-9]{64}$/);
-      expect(result.contractDts).toContain('export type Contract');
-      expect(result.contractDts).toContain('CodecTypes');
-
-      const contractJson = JSON.parse(result.contractJson) as Record<string, unknown>;
-      const storage = contractJson['storage'] as Record<string, unknown>;
-      const tables = storage['tables'] as Record<string, unknown>;
-      expect(tables).toBeDefined();
-    },
-    timeouts.typeScriptCompilation,
-  );
-
-  it('emits contract even when extension pack namespace does not match extensionIds', async () => {
-    const ir = createTestContract({
-      storage: {
-        tables: {
-          user: {
-            columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
-            },
-            uniques: [],
-            indexes: [],
-            foreignKeys: [],
-          },
-        },
-      },
-    });
-
-    const options: EmitStackInput = {
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    const result = await emit(ir, options, mockSqlHook);
-    expect(result.contractJson).toBeDefined();
-    expect(result.contractDts).toBeDefined();
-  });
-
-  it('tolerates codec namespaces not registered in extensionIds', async () => {
-    const ir = createTestContract({
-      storage: {
-        tables: {
-          data: {
-            columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
-              value: { codecId: 'unknown/type@1', nativeType: 'custom', nullable: false },
-            },
-            uniques: [],
-            indexes: [],
-            foreignKeys: [],
-          },
-        },
-      },
-    });
-
-    const options: EmitStackInput = {
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: ['some-other-extension'],
-    };
-
-    const result = await emit(ir, options, mockSqlHook);
-    expect(result.contractJson).toBeDefined();
-    expect(result.contractDts).toBeDefined();
-  });
-
-  it('handles missing extensionPacks field', async () => {
-    const ir = createTestContract({
-      storage: {
-        tables: {
-          user: {
-            columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
-            },
-            uniques: [],
-            indexes: [],
-            foreignKeys: [],
-          },
-        },
-      },
-    });
-
-    const options: EmitStackInput = {
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    const result = await emit(ir, options, mockSqlHook);
-    expect(result.contractJson).toBeDefined();
-    expect(result.contractDts).toBeDefined();
-  });
-
-  it('handles empty packs array', async () => {
-    const ir = createTestContract({
-      storage: {
-        tables: {
-          user: {
-            columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
-            },
-            uniques: [],
-            indexes: [],
-            foreignKeys: [],
-          },
-        },
-      },
-    });
-
-    const options: EmitStackInput = {
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    const result = await emit(ir, options, mockSqlHook);
-    expect(result.contractJson).toBeDefined();
-    expect(result.contractDts).toBeDefined();
-  });
-
-  it(
-    'omits sources from emitted contract artifact',
-    async () => {
-      const ir = createTestContract({
-        sources: {
-          schema: { sourceId: 'schema.prisma' },
-        },
-      });
-
-      const options: EmitStackInput = {
-        codecTypeImports: [],
-        operationTypeImports: [],
-        extensionIds: [],
-      };
-
-      const result = await emit(ir, options, mockSqlHook);
-      const contractJson = JSON.parse(result.contractJson) as Record<string, unknown>;
-      expect(contractJson).not.toHaveProperty('sources');
-    },
-    timeouts.typeScriptCompilation,
-  );
-
-  it('accepts meta keys when family validation allows them', async () => {
-    const ir = createTestContract({
-      meta: {
-        sourceId: 'schema.prisma',
-        schemaPath: '/tmp/schema.prisma',
-        source: 'psl',
-      },
-    });
-
-    const options: EmitStackInput = {
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    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 = createTestContract({
-      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: EmitStackInput = {
-      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 () => {
-    const ir = createTestContract({
-      storage: {
-        tables: {},
-      },
-    });
-
-    const mockHookNoTypeValidation = createMockSpi();
-
-    const options: EmitStackInput = {
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: ['postgres'],
-    };
-
-    const result = await emit(ir, options, mockHookNoTypeValidation);
-    expect(result.contractJson).toBeDefined();
-    expect(result.contractDts).toBeDefined();
-  });
-
-  it('defaults codecTypeImports and operationTypeImports to empty arrays when omitted', async () => {
-    const ir = createTestContract({
-      storage: { tables: {} },
-    });
-
-    const options: EmitStackInput = {
-      extensionIds: [],
-    };
-
-    const result = await emit(ir, options, mockSqlHook);
-    expect(result.contractDts).toContain('export type CodecTypes');
-    expect(result.contractDts).toContain('export type OperationTypes');
-  });
-
-  it('passes parameterizedTypeImports and queryOperationTypeImports to generateContractDts', async () => {
-    const ir = createTestContract({
-      storage: { tables: {} },
-    });
-
-    const queryOperationTypeImports: TypesImportSpec[] = [
-      { package: '@ext/query', named: 'QueryOperationTypes', alias: 'ExtQueryOpTypes' },
-    ];
-
-    const options: EmitStackInput = {
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-      queryOperationTypeImports,
-    };
-
-    const result = await emit(ir, options, mockSqlHook);
-    expect(result.contractDts).toContain("from '@ext/query'");
-  });
-
-  it('emits execution clause when contract has execution section', async () => {
-    const ir = createTestContract({
-      storage: { tables: {} },
-      execution: {
-        executionHash: 'sha256:abc123',
-        operations: {},
-      },
-    });
-
-    const options: EmitStackInput = {
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    const result = await emit(ir, options, mockSqlHook);
-    expect(result.contractDts).toContain('readonly execution:');
-    expect(result.contractDts).toContain('readonly executionHash: ExecutionHash');
-    expect(result.executionHash).toMatch(/^sha256:[a-f0-9]{64}$/);
-  });
-});

package/test/hashing.test.ts

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

package/test/mock-spi.ts

@@ -1,18 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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,31 +0,0 @@
-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]);
-}