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

package/src/generate-contract-dts.ts

@@ -0,0 +1,116 @@
+import type { Contract, ContractModel, ContractValueObject } from '@prisma-next/contract/types';
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type {
+  EmissionSpi,
+  GenerateContractTypesOptions,
+  TypesImportSpec,
+} from '@prisma-next/framework-components/emission';
+import {
+  deduplicateImports,
+  generateCodecTypeIntersection,
+  generateFieldOutputTypesMap,
+  generateHashTypeAliases,
+  generateImportLines,
+  generateModelsType,
+  generateRootsType,
+  generateValueObjectsDescriptorType,
+  generateValueObjectTypeAliases,
+  serializeExecutionType,
+  serializeValue,
+} from './domain-type-generation';
+
+export function generateContractDts(
+  contract: Contract,
+  emitter: EmissionSpi,
+  codecTypeImports: ReadonlyArray<TypesImportSpec>,
+  operationTypeImports: ReadonlyArray<TypesImportSpec>,
+  hashes: {
+    readonly storageHash: string;
+    readonly executionHash?: string;
+    readonly profileHash: string;
+  },
+  options?: GenerateContractTypesOptions,
+  codecLookup?: CodecLookup,
+): string {
+  const allImports: TypesImportSpec[] = [...codecTypeImports, ...operationTypeImports];
+  if (options?.queryOperationTypeImports) {
+    allImports.push(...options.queryOperationTypeImports);
+  }
+  const uniqueImports = deduplicateImports(allImports);
+  const importLines = generateImportLines(uniqueImports);
+
+  const familyImportLines = emitter.getFamilyImports();
+
+  const hashAliases = generateHashTypeAliases(hashes);
+
+  const codecTypes = generateCodecTypeIntersection(codecTypeImports, 'CodecTypes');
+  const operationTypes = generateCodecTypeIntersection(operationTypeImports, 'OperationTypes');
+
+  const familyTypeAliases = emitter.getFamilyTypeAliases(options);
+
+  const typeMapsExpr = emitter.getTypeMapsExpression();
+
+  const storageType = emitter.generateStorageType(contract, 'StorageHash');
+
+  const modelsType = generateModelsType(
+    contract.models as Record<string, ContractModel>,
+    (name, model) => emitter.generateModelStorageType(name, model),
+  );
+
+  const rootsType = generateRootsType(contract.roots);
+
+  const valueObjects = contract.valueObjects as Record<string, ContractValueObject> | undefined;
+  const valueObjectTypeAliases = generateValueObjectTypeAliases(valueObjects);
+  const valueObjectsDescriptor = generateValueObjectsDescriptorType(valueObjects);
+
+  const executionClause =
+    contract.execution !== undefined
+      ? `\n  readonly execution: ${serializeExecutionType(contract.execution)};`
+      : '';
+
+  const fieldOutputTypesMap = generateFieldOutputTypesMap(
+    contract.models as Record<string, ContractModel> | undefined,
+    codecLookup,
+  );
+
+  const contractWrapper = emitter.getContractWrapper('ContractBase', 'TypeMaps');
+
+  return `// ⚠️  GENERATED FILE - DO NOT EDIT
+// This file is automatically generated by 'prisma-next contract emit'.
+// To regenerate, run: prisma-next contract emit
+${importLines.join('\n')}
+
+${familyImportLines.join('\n')}
+import type {
+  Contract as ContractType,
+  ExecutionHashBase,
+  ProfileHashBase,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
+
+${hashAliases}
+
+export type CodecTypes = ${codecTypes};
+export type OperationTypes = ${operationTypes};
+${familyTypeAliases}
+${valueObjectTypeAliases}
+export type FieldOutputTypes = ${fieldOutputTypesMap};
+export type TypeMaps = ${typeMapsExpr};
+
+type ContractBase = ContractType<
+${storageType},
+${modelsType}
+> & {
+  readonly target: ${serializeValue(contract.target)};
+  readonly targetFamily: ${serializeValue(contract.targetFamily)};
+  readonly roots: ${rootsType};
+  readonly capabilities: ${serializeValue(contract.capabilities)};
+  readonly extensionPacks: ${serializeValue(contract.extensionPacks)};${executionClause}
+  readonly meta: ${serializeValue(contract.meta)};
+  ${valueObjects ? `readonly valueObjects: ${valueObjectsDescriptor};` : ''}
+  readonly profileHash: ProfileHash;
+};
+
+${contractWrapper}
+`;
+}

package/src/type-expression-safety.ts

@@ -0,0 +1,3 @@
+export function isSafeTypeExpression(expr: string): boolean {
+  return !/import\s*\(|require\s*\(|declare\s|export\s|eval\s*\(/.test(expr);
+}

package/test/canonicalization.test.ts

@@ -1,10 +1,10 @@
-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: { emitterVersion: 'test' },
     });
@@ -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,15 +51,12 @@ 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.each([
-    { nullable: false },
-    { nullable: undefined },
-  ])('omits nullable:false for columns with defaults (nullable=$nullable)', ({ nullable }) => {
-    const ir = createContractIR({
+  it('preserves nullable:false for columns with defaults', () => {
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -67,7 +64,7 @@ describe('canonicalization', () => {
               created_at: {
                 codecId: 'pg/timestamptz@1',
                 nativeType: 'timestamptz',
-                nullable,
+                nullable: false,
                 default: { kind: 'function', expression: 'now()' },
               },
               updated_at: {
@@ -89,12 +86,12 @@ describe('canonicalization', () => {
     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']).toBeUndefined();
+    expect(createdAt['nullable']).toBe(false);
     expect(updatedAt['nullable']).toBe(true);
   });
 
   it('preserves nullable:true for columns with defaults', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -123,7 +120,7 @@ describe('canonicalization', () => {
   });
 
   it('omits empty arrays and objects except required ones', () => {
-    const ir = createContractIR();
+    const ir = createTestContract();
 
     const result = canonicalizeContract(ir);
     const parsed = JSON.parse(result);
@@ -143,7 +140,7 @@ describe('canonicalization', () => {
   });
 
   it('preserves semantic array order for column lists', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -161,7 +158,7 @@ describe('canonicalization', () => {
 
     const result1 = canonicalizeContract(ir);
 
-    const ir2 = createContractIR({
+    const ir2 = createTestContract({
       storage: {
         tables: {
           user: {
@@ -183,7 +180,7 @@ describe('canonicalization', () => {
   });
 
   it('sorts indexes by canonical name', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -210,7 +207,7 @@ describe('canonicalization', () => {
   });
 
   it('sorts uniques by canonical name', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -239,7 +236,7 @@ describe('canonicalization', () => {
   });
 
   it('preserves column order in composite unique constraints', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -264,7 +261,7 @@ describe('canonicalization', () => {
   });
 
   it('sorts nested object keys lexicographically', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -290,7 +287,7 @@ describe('canonicalization', () => {
 
   describe('Mongo storage.collections preservation', () => {
     it('preserves empty storage.collections container', () => {
-      const ir = createContractIR({
+      const ir = createTestContract({
         targetFamily: 'mongo',
         target: 'mongo',
         storage: { collections: {} },
@@ -303,7 +300,7 @@ describe('canonicalization', () => {
     });
 
     it('preserves collection entries with empty payloads', () => {
-      const ir = createContractIR({
+      const ir = createTestContract({
         targetFamily: 'mongo',
         target: 'mongo',
         storage: { collections: { users: {}, posts: {} } },
@@ -318,7 +315,7 @@ describe('canonicalization', () => {
     });
 
     it('sorts collection names lexicographically', () => {
-      const ir = createContractIR({
+      const ir = createTestContract({
         targetFamily: 'mongo',
         target: 'mongo',
         storage: { collections: { zebras: {}, apples: {}, mangoes: {} } },
@@ -332,12 +329,12 @@ describe('canonicalization', () => {
     });
 
     it('produces different hashes when collections differ', () => {
-      const ir1 = createContractIR({
+      const ir1 = createTestContract({
         targetFamily: 'mongo',
         target: 'mongo',
         storage: { collections: { users: {} } },
       });
-      const ir2 = createContractIR({
+      const ir2 = createTestContract({
         targetFamily: 'mongo',
         target: 'mongo',
         storage: { collections: { users: {}, posts: {} } },
@@ -350,7 +347,7 @@ describe('canonicalization', () => {
   });
 
   it('sorts extension namespaces lexicographically', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       extensionPacks: {
         pgvector: { version: '0.0.1' },
         postgres: { version: '0.0.1' },
@@ -366,7 +363,7 @@ describe('canonicalization', () => {
   });
 
   it('omits generated false', () => {
-    const ir = createContractIR({
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {