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

package/test/domain-type-generation.test.ts

@@ -1,12 +1,27 @@
-import type { TypesImportSpec } from '@prisma-next/contract/types';
-import { describe, expect, it } from 'vitest';
+import type {
+  ContractField,
+  ContractModel,
+  ContractValueObject,
+} from '@prisma-next/contract/types';
+import type { Codec, CodecLookup } from '@prisma-next/framework-components/codec';
+import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
+import { describe, expect, it, vi } from 'vitest';
 import {
   deduplicateImports,
   generateCodecTypeIntersection,
+  generateContractFieldDescriptor,
+  generateFieldOutputTypesMap,
+  generateFieldResolvedType,
   generateHashTypeAliases,
   generateImportLines,
+  generateModelFieldsType,
   generateModelRelationsType,
+  generateModelsType,
   generateRootsType,
+  generateValueObjectsDescriptorType,
+  generateValueObjectType,
+  generateValueObjectTypeAliases,
+  serializeExecutionType,
   serializeObjectKey,
   serializeValue,
 } from '../src/domain-type-generation';
@@ -76,6 +91,125 @@ describe('serializeObjectKey', () => {
   });
 });
 
+describe('generateModelFieldsType', () => {
+  it('returns Record<string, never> for empty fields', () => {
+    expect(generateModelFieldsType({})).toBe('Record<string, never>');
+  });
+
+  it('generates field with type descriptor and nullable', () => {
+    const result = generateModelFieldsType({
+      name: { type: { kind: 'scalar', codecId: 'sql/text@1' }, nullable: false },
+    });
+    expect(result).toBe(
+      "{ readonly name: { readonly nullable: false; readonly type: { readonly kind: 'scalar'; readonly codecId: 'sql/text@1' } } }",
+    );
+  });
+
+  it('generates multiple fields', () => {
+    const result = generateModelFieldsType({
+      id: { type: { kind: 'scalar', codecId: 'sql/int4@1' }, nullable: false },
+      email: { type: { kind: 'scalar', codecId: 'sql/text@1' }, nullable: true },
+    });
+    expect(result).toContain(
+      "readonly id: { readonly nullable: false; readonly type: { readonly kind: 'scalar'; readonly codecId: 'sql/int4@1' } }",
+    );
+    expect(result).toContain(
+      "readonly email: { readonly nullable: true; readonly type: { readonly kind: 'scalar'; readonly codecId: 'sql/text@1' } }",
+    );
+  });
+
+  it('quotes keys with special characters', () => {
+    const result = generateModelFieldsType({
+      'field-name': { type: { kind: 'scalar', codecId: 'sql/text@1' }, nullable: false },
+    });
+    expect(result).toContain("readonly 'field-name':");
+  });
+});
+
+describe('generateModelsType', () => {
+  const noopStorage = () => 'Record<string, never>';
+
+  function makeModel(overrides: Partial<ContractModel> = {}): ContractModel {
+    return {
+      fields: {},
+      relations: {},
+      storage: { storageHash: 'test' },
+      ...overrides,
+    };
+  }
+
+  it('returns Record<string, never> for empty models', () => {
+    expect(generateModelsType({}, noopStorage)).toBe('Record<string, never>');
+  });
+
+  it('generates model with fields, relations, and storage', () => {
+    const models: Record<string, ContractModel> = {
+      User: makeModel({
+        fields: { name: { type: { kind: 'scalar', codecId: 'sql/text@1' }, nullable: false } },
+        relations: { posts: { to: 'Post', cardinality: '1:N' } },
+      }),
+    };
+    const result = generateModelsType(models, () => "{ readonly table: 'users' }");
+    expect(result).toContain('readonly User:');
+    expect(result).toContain("readonly codecId: 'sql/text@1'");
+    expect(result).toContain("readonly to: 'Post'");
+    expect(result).toContain("readonly table: 'users'");
+  });
+
+  it('sorts models by name', () => {
+    const models: Record<string, ContractModel> = {
+      Zebra: makeModel(),
+      Alpha: makeModel(),
+    };
+    const result = generateModelsType(models, noopStorage);
+    const alphaIdx = result.indexOf('Alpha');
+    const zebraIdx = result.indexOf('Zebra');
+    expect(alphaIdx).toBeLessThan(zebraIdx);
+  });
+
+  it('passes modelName and model to the storage callback', () => {
+    const model = makeModel();
+    const models: Record<string, ContractModel> = { User: model };
+    const storageFn = vi.fn(() => 'Record<string, never>');
+    generateModelsType(models, storageFn);
+    expect(storageFn).toHaveBeenCalledWith('User', model);
+  });
+
+  it('includes owner when present', () => {
+    const models: Record<string, ContractModel> = {
+      Comment: makeModel({ owner: 'Post' }),
+    };
+    const result = generateModelsType(models, noopStorage);
+    expect(result).toContain("readonly owner: 'Post'");
+  });
+
+  it('includes discriminator when present', () => {
+    const models: Record<string, ContractModel> = {
+      Animal: makeModel({ discriminator: { field: 'type' } }),
+    };
+    const result = generateModelsType(models, noopStorage);
+    expect(result).toContain("readonly discriminator: { readonly field: 'type' }");
+  });
+
+  it('includes variants when present', () => {
+    const models: Record<string, ContractModel> = {
+      Animal: makeModel({ variants: { Dog: { value: 'dog' }, Cat: { value: 'cat' } } }),
+    };
+    const result = generateModelsType(models, noopStorage);
+    expect(result).toContain('readonly variants:');
+    expect(result).toContain('readonly Dog:');
+    expect(result).toContain('readonly Cat:');
+  });
+
+  it('includes base when present', () => {
+    const models: Record<string, ContractModel> = {
+      Dog: makeModel({ base: 'Animal' }),
+    };
+    const result = generateModelsType(models, noopStorage);
+    expect(result).toContain("readonly base: 'Animal'");
+  });
+});
+
 describe('generateRootsType', () => {
   it('returns Record<string, string> for undefined roots', () => {
     expect(generateRootsType(undefined)).toBe('Record<string, string>');
@@ -281,3 +415,376 @@ describe('generateHashTypeAliases', () => {
     expect(result).toContain('ExecutionHashBase<string>');
   });
 });
+
+describe('serializeExecutionType', () => {
+  it('uses ExecutionHash alias instead of literal hash value', () => {
+    const result = serializeExecutionType({
+      executionHash: 'sha256:abc123',
+      mutations: { defaults: [] },
+    });
+    expect(result).toContain('readonly executionHash: ExecutionHash');
+    expect(result).not.toContain('sha256:abc123');
+  });
+
+  it('serializes non-hash fields normally', () => {
+    const result = serializeExecutionType({
+      executionHash: 'sha256:abc123',
+      mutations: { defaults: [{ kind: 'autoIncrement' }] },
+    });
+    expect(result).toContain('readonly mutations:');
+    expect(result).toContain("readonly kind: 'autoIncrement'");
+  });
+});
+
+describe('generateFieldResolvedType', () => {
+  it('generates CodecTypes lookup for scalar fields', () => {
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'scalar', codecId: 'mongo/string@1' },
+    };
+    expect(generateFieldResolvedType(field)).toBe("CodecTypes['mongo/string@1']['output']");
+  });
+
+  it('generates named type reference for value object fields', () => {
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'valueObject', name: 'Address' },
+    };
+    expect(generateFieldResolvedType(field)).toBe('Address');
+  });
+
+  it('wraps in ReadonlyArray for many: true', () => {
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'valueObject', name: 'Address' },
+      many: true,
+    };
+    expect(generateFieldResolvedType(field)).toBe('ReadonlyArray<Address>');
+  });
+
+  it('wraps in Readonly<Record> for dict: true', () => {
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'scalar', codecId: 'mongo/string@1' },
+      dict: true,
+    };
+    expect(generateFieldResolvedType(field)).toBe(
+      "Readonly<Record<string, CodecTypes['mongo/string@1']['output']>>",
+    );
+  });
+
+  it('appends | null for nullable: true', () => {
+    const field: ContractField = {
+      nullable: true,
+      type: { kind: 'valueObject', name: 'Address' },
+    };
+    expect(generateFieldResolvedType(field)).toBe('Address | null');
+  });
+
+  it('combines many and nullable', () => {
+    const field: ContractField = {
+      nullable: true,
+      type: { kind: 'valueObject', name: 'Address' },
+      many: true,
+    };
+    expect(generateFieldResolvedType(field)).toBe('ReadonlyArray<Address> | null');
+  });
+
+  it('handles union types', () => {
+    const field: ContractField = {
+      nullable: false,
+      type: {
+        kind: 'union',
+        members: [
+          { kind: 'scalar', codecId: 'mongo/string@1' },
+          { kind: 'valueObject', name: 'Address' },
+        ],
+      },
+    };
+    expect(generateFieldResolvedType(field)).toBe(
+      "CodecTypes['mongo/string@1']['output'] | Address",
+    );
+  });
+});
+
+describe('generateValueObjectType', () => {
+  const addressVo: ContractValueObject = {
+    fields: {
+      street: { nullable: false, type: { kind: 'scalar', codecId: 'mongo/string@1' } },
+      city: { nullable: false, type: { kind: 'scalar', codecId: 'mongo/string@1' } },
+      zip: { nullable: false, type: { kind: 'scalar', codecId: 'mongo/string@1' } },
+    },
+  };
+  const valueObjects: Record<string, ContractValueObject> = { Address: addressVo };
+
+  it('generates object type with all fields', () => {
+    const result = generateValueObjectType('Address', addressVo, valueObjects);
+    expect(result).toContain("readonly street: CodecTypes['mongo/string@1']['output']");
+    expect(result).toContain("readonly city: CodecTypes['mongo/string@1']['output']");
+    expect(result).toContain("readonly zip: CodecTypes['mongo/string@1']['output']");
+  });
+
+  it('handles value object field referencing another value object', () => {
+    const companyVo: ContractValueObject = {
+      fields: {
+        name: { nullable: false, type: { kind: 'scalar', codecId: 'mongo/string@1' } },
+        address: { nullable: false, type: { kind: 'valueObject', name: 'Address' } },
+      },
+    };
+    const vos = { ...valueObjects, Company: companyVo };
+    const result = generateValueObjectType('Company', companyVo, vos);
+    expect(result).toContain('readonly address: Address');
+  });
+
+  it('handles self-referencing value object (no infinite recursion)', () => {
+    const navItemVo: ContractValueObject = {
+      fields: {
+        label: { nullable: false, type: { kind: 'scalar', codecId: 'mongo/string@1' } },
+        children: {
+          nullable: false,
+          type: { kind: 'valueObject', name: 'NavItem' },
+          many: true,
+        },
+      },
+    };
+    const vos = { NavItem: navItemVo };
+    const result = generateValueObjectType('NavItem', navItemVo, vos);
+    expect(result).toContain('readonly children: ReadonlyArray<NavItem>');
+  });
+
+  it('returns Record<string, never> for empty value object', () => {
+    const emptyVo: ContractValueObject = { fields: {} };
+    expect(generateValueObjectType('Empty', emptyVo, {})).toBe('Record<string, never>');
+  });
+});
+
+describe('generateContractFieldDescriptor', () => {
+  it('generates scalar field descriptor', () => {
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'scalar', codecId: 'pg/text@1' },
+    };
+    const result = generateContractFieldDescriptor('name', field);
+    expect(result).toBe(
+      "readonly name: { readonly nullable: false; readonly type: { readonly kind: 'scalar'; readonly codecId: 'pg/text@1' } }",
+    );
+  });
+
+  it('generates value object field descriptor', () => {
+    const field: ContractField = {
+      nullable: true,
+      type: { kind: 'valueObject', name: 'Address' },
+    };
+    const result = generateContractFieldDescriptor('homeAddress', field);
+    expect(result).toBe(
+      "readonly homeAddress: { readonly nullable: true; readonly type: { readonly kind: 'valueObject'; readonly name: 'Address' } }",
+    );
+  });
+
+  it('includes many modifier', () => {
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'valueObject', name: 'Address' },
+      many: true,
+    };
+    const result = generateContractFieldDescriptor('addresses', field);
+    expect(result).toContain('; readonly many: true');
+  });
+
+  it('includes dict modifier', () => {
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'scalar', codecId: 'mongo/string@1' },
+      dict: true,
+    };
+    const result = generateContractFieldDescriptor('labels', field);
+    expect(result).toContain('; readonly dict: true');
+  });
+
+  it('includes typeParams for scalar fields', () => {
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'scalar', codecId: 'pg/vector@1', typeParams: { length: 1536 } },
+    };
+    const result = generateContractFieldDescriptor('embedding', field);
+    expect(result).toContain('readonly typeParams: { readonly length: 1536 }');
+  });
+});
+
+describe('generateValueObjectsDescriptorType', () => {
+  it('returns Record<string, never> for undefined', () => {
+    expect(generateValueObjectsDescriptorType(undefined)).toBe('Record<string, never>');
+  });
+
+  it('returns Record<string, never> for empty', () => {
+    expect(generateValueObjectsDescriptorType({})).toBe('Record<string, never>');
+  });
+
+  it('generates descriptor with fields for each value object', () => {
+    const valueObjects: Record<string, ContractValueObject> = {
+      Address: {
+        fields: {
+          street: { nullable: false, type: { kind: 'scalar', codecId: 'mongo/string@1' } },
+        },
+      },
+    };
+    const result = generateValueObjectsDescriptorType(valueObjects);
+    expect(result).toContain('readonly Address: { readonly fields:');
+    expect(result).toContain("readonly kind: 'scalar'");
+    expect(result).toContain("readonly codecId: 'mongo/string@1'");
+  });
+});
+
+describe('generateValueObjectTypeAliases', () => {
+  it('returns empty string for undefined', () => {
+    expect(generateValueObjectTypeAliases(undefined)).toBe('');
+  });
+
+  it('returns empty string for empty', () => {
+    expect(generateValueObjectTypeAliases({})).toBe('');
+  });
+
+  it('generates export type alias for each value object', () => {
+    const valueObjects: Record<string, ContractValueObject> = {
+      Address: {
+        fields: {
+          street: { nullable: false, type: { kind: 'scalar', codecId: 'mongo/string@1' } },
+        },
+      },
+    };
+    const result = generateValueObjectTypeAliases(valueObjects);
+    expect(result).toContain('export type Address =');
+    expect(result).toContain("readonly street: CodecTypes['mongo/string@1']['output']");
+  });
+
+  it('generates multiple type aliases', () => {
+    const valueObjects: Record<string, ContractValueObject> = {
+      Address: {
+        fields: {
+          street: { nullable: false, type: { kind: 'scalar', codecId: 'mongo/string@1' } },
+        },
+      },
+      GeoPoint: {
+        fields: {
+          lat: { nullable: false, type: { kind: 'scalar', codecId: 'mongo/double@1' } },
+          lng: { nullable: false, type: { kind: 'scalar', codecId: 'mongo/double@1' } },
+        },
+      },
+    };
+    const result = generateValueObjectTypeAliases(valueObjects);
+    expect(result).toContain('export type Address =');
+    expect(result).toContain('export type GeoPoint =');
+  });
+});
+
+function stubCodec(overrides: Partial<Codec> & { id: string }): Codec {
+  return {
+    targetTypes: [],
+    decode: (w: unknown) => w,
+    encodeJson: (v: unknown) => v,
+    decodeJson: (j: unknown) => j,
+    ...overrides,
+  } as unknown as Codec;
+}
+
+function stubCodecLookup(codecs: Record<string, Codec>): CodecLookup {
+  return { get: (id) => codecs[id] };
+}
+
+describe('generateFieldResolvedType', () => {
+  it('uses codec renderOutputType when typeParams are present', () => {
+    const lookup = stubCodecLookup({
+      'pg/char@1': stubCodec({
+        id: 'pg/char@1',
+        renderOutputType: (p) => `Char<${p['length']}>`,
+      }),
+    });
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'scalar', codecId: 'pg/char@1', typeParams: { length: 36 } },
+    };
+    expect(generateFieldResolvedType(field, lookup)).toBe('Char<36>');
+  });
+
+  it('falls back to CodecTypes lookup when no codecLookup provided', () => {
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'scalar', codecId: 'pg/int4@1' },
+    };
+    expect(generateFieldResolvedType(field)).toBe("CodecTypes['pg/int4@1']['output']");
+  });
+
+  it('falls back to CodecTypes when renderOutputType returns unsafe expression', () => {
+    const lookup = stubCodecLookup({
+      'test@1': stubCodec({
+        id: 'test@1',
+        renderOutputType: () => 'import("fs")',
+      }),
+    });
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'scalar', codecId: 'test@1', typeParams: { x: 1 } },
+    };
+    expect(generateFieldResolvedType(field, lookup)).toBe("CodecTypes['test@1']['output']");
+  });
+
+  it('falls back to CodecTypes when codec has no renderOutputType', () => {
+    const lookup = stubCodecLookup({
+      'pg/int4@1': stubCodec({ id: 'pg/int4@1' }),
+    });
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'scalar', codecId: 'pg/int4@1', typeParams: { x: 1 } },
+    };
+    expect(generateFieldResolvedType(field, lookup)).toBe("CodecTypes['pg/int4@1']['output']");
+  });
+
+  it('falls back to CodecTypes when typeParams is empty', () => {
+    const lookup = stubCodecLookup({
+      'pg/char@1': stubCodec({
+        id: 'pg/char@1',
+        renderOutputType: () => 'Char<36>',
+      }),
+    });
+    const field: ContractField = {
+      nullable: false,
+      type: { kind: 'scalar', codecId: 'pg/char@1', typeParams: {} },
+    };
+    expect(generateFieldResolvedType(field, lookup)).toBe("CodecTypes['pg/char@1']['output']");
+  });
+});
+
+describe('generateFieldOutputTypesMap', () => {
+  it('generates map entries with codec-dispatched rendering', () => {
+    const lookup = stubCodecLookup({
+      'pg/char@1': stubCodec({
+        id: 'pg/char@1',
+        renderOutputType: (p) => `Char<${p['length']}>`,
+      }),
+    });
+    const models: Record<string, ContractModel> = {
+      User: {
+        fields: {
+          id: {
+            nullable: false,
+            type: { kind: 'scalar', codecId: 'pg/char@1', typeParams: { length: 36 } },
+          },
+          name: {
+            nullable: false,
+            type: { kind: 'scalar', codecId: 'pg/text@1' },
+          },
+        },
+        relations: {},
+        storage: { fields: {}, table: 'user' },
+      },
+    };
+    const result = generateFieldOutputTypesMap(models, lookup);
+    expect(result).toContain('Char<36>');
+    expect(result).toContain("CodecTypes['pg/text@1']['output']");
+  });
+
+  it('returns Record<string, never> for empty models', () => {
+    expect(generateFieldOutputTypesMap(undefined)).toBe('Record<string, never>');
+    expect(generateFieldOutputTypesMap({})).toBe('Record<string, never>');
+  });
+});