feat(core): added factoryMethods - code review

Author: mironbalcerzak

docs/content/docs/reference/configuration/output.mdx

@@ -1686,31 +1686,23 @@ Generate factory methods for DTOs (Data Transfer Objects) initialized with safe
 Functionality handles OpenAPI `readOnly` and `writeOnly` flags to generate appropriate payload structures:
 - **Required properties:** Always included in the factory output, regardless of their visibility flags.
 - **Optional `readOnly` properties:** Always omitted from the factory output, as they would be dropped by the server.
-- **Optional `writeOnly` properties:** Always included in the factory output (even if `optionalPropertyStrategy` is set to `'omit'`).
+- **Optional `writeOnly` properties:** Always included in the factory output (even if `includeOptionalProperty` is set to `false`).
 
 ```ts title="orval.config.ts"
 export default defineConfig({
   petstore: {
     output: {
       factoryMethods: {
-        generate: true,
         functionNamePrefix: 'create',
-        mode: 'separate-file',
-        optionalPropertyStrategy: 'include',
+        mode: 'split',
+        includeOptionalProperty: true,
         outputDirectory: `#output.workspace.schemas`,
       },
     },
   },
 });
 ```
 
-### generate
-
-**Type:** `Boolean`
-**Default:** `false`
-
-Enables or disables factory generation.
-
 ### functionNamePrefix
 
 **Type:** `String`
@@ -1720,18 +1712,18 @@ Prefix for the generated factory function names.
 
 ### mode
 
-**Type:** `'inline-with-schema' | 'separate-file' | 'combined-separate-file'`
-**Default:** `'separate-file'`
+**Type:** `'single' | 'split' | 'single-split'`
+**Default:** `'split'`
 
 Where to generate the factory methods:
-- `inline-with-schema`: Appends the factory function to the schema file.
-- `separate-file`: Creates a `{schema}.factory.ts` with factory method. By default it is placed next to schema file.
-- `combined-separate-file`: Aggregates all factory methods into a single `factoryMethods.ts` file.
+- `single`: Appends the factory function to the schema file.
+- `split`: Creates a `{schema}.factory.ts` with factory method. By default it is placed next to schema file.
+- `single-split`: Aggregates all factory methods into a single `factoryMethods.ts` file.
 
-### optionalPropertyStrategy
+### includeOptionalProperty
 
-**Type:** `'include' | 'omit'`
-**Default:** `'include'`
+**Type:** `boolean`
+**Default:** `true`
 
 Determines whether optional schema properties are included in the default factory output.
 
@@ -1742,7 +1734,7 @@ Determines whether optional schema properties are included in the default factor
 
 Defaults to the value configured in `#output.workspace.schemas`.
 Determines where factory methods will be generated (can be used to generated methods away from schema directory).
-Takes effect only when used `mode` is `separate-file` or `combined-separate-file`.
+Takes effect only when used `mode` is `split` or `single-split`.
 ---
 
 ## Other Options

packages/angular/src/http-client.test.ts

@@ -126,11 +126,10 @@ const createOutput = (
     unionAddMissingProperties: false,
     propertySortOrder: 'Specification',
     factoryMethods: {
-      generate: false,
       functionNamePrefix: 'create',
-      mode: 'inline-with-schema',
+      mode: 'single',
       outputDirectory: '',
-      optionalPropertyStrategy: 'omit',
+      includeOptionalProperty: false,
     },
     ...overrides,
   } satisfies NormalizedOutputOptions;

packages/angular/src/http-resource.test.ts

@@ -136,11 +136,10 @@ const createOutput = (
     unionAddMissingProperties: false,
     propertySortOrder: 'Specification',
     factoryMethods: {
-      generate: false,
       functionNamePrefix: 'create',
-      mode: 'inline-with-schema',
+      mode: 'single',
       outputDirectory: '',
-      optionalPropertyStrategy: 'omit',
+      includeOptionalProperty: false,
     },
     ...overrides,
   } satisfies NormalizedOutputOptions;

packages/core/src/generators/factory.test.ts

@@ -9,11 +9,10 @@ import { NamingConvention } from '../types';
 import { generateFactory } from './factory';
 
 const baseFactoryMethods = {
-  generate: true,
   functionNamePrefix: 'create',
-  mode: 'inline-with-schema',
+  mode: 'single',
   outputDirectory: '',
-  optionalPropertyStrategy: 'omit',
+  includeOptionalProperty: false,
 };
 
 const baseOverride = {
@@ -141,7 +140,7 @@ describe('generateFactory', () => {
       createMockContext({
         factoryMethods: {
           ...baseFactoryMethods,
-          optionalPropertyStrategy: 'include',
+          includeOptionalProperty: true,
         },
       }),
     );
@@ -205,7 +204,7 @@ describe('generateFactory', () => {
     expect(result?.imports).toContainEqual({ name: 'RefTarget' });
   });
 
-  it('handles mode: separate-file import paths', () => {
+  it('handles mode: split import paths', () => {
     const schema: OpenApiSchemaObject = {
       type: 'object',
       required: ['target'],
@@ -218,7 +217,7 @@ describe('generateFactory', () => {
       schema,
       'WithRef',
       createMockContext({
-        factoryMethods: { ...baseFactoryMethods, mode: 'separate-file' },
+        factoryMethods: { ...baseFactoryMethods, mode: 'split' },
       }),
     );
     expect(result?.imports).toContainEqual({
@@ -228,7 +227,7 @@ describe('generateFactory', () => {
     });
   });
 
-  it('handles mode: combined-separate-file import paths', () => {
+  it('handles mode: single-split import paths', () => {
     const schema: OpenApiSchemaObject = {
       type: 'object',
       required: ['target'],
@@ -243,7 +242,7 @@ describe('generateFactory', () => {
       createMockContext({
         factoryMethods: {
           ...baseFactoryMethods,
-          mode: 'combined-separate-file',
+          mode: 'single-split',
         },
       }),
     );

packages/core/src/generators/factory.ts

@@ -31,10 +31,10 @@ function getSchemaImportPath(
   refName: string,
   context: ContextSpec,
 ): string | undefined {
-  if (context.output.factoryMethods.mode === 'inline-with-schema') {
+  if (context.output.factoryMethods?.mode === 'single') {
     return undefined;
   }
-  let outputDir = context.output.factoryMethods.outputDirectory;
+  let outputDir = context.output.factoryMethods?.outputDirectory;
   let schemasPath = getSchemasPath(context);
 
   if (context.output.workspace) {
@@ -128,14 +128,15 @@ export function generateFactory(
   name: string,
   context: ContextSpec,
 ): { model: string; imports: GeneratorImport[] } | undefined {
-  if (!canGenerateSchema(schema)) return undefined;
+  if (!canGenerateSchema(schema) || !context.output.factoryMethods)
+    return undefined;
 
   const { functionNamePrefix, mode } = context.output.factoryMethods;
   const factoryName = `${functionNamePrefix}${pascal(name)}`;
   const imports: GeneratorImport[] = [];
   const payload = buildPayload(schema, context, [name], imports);
 
-  if (mode !== 'inline-with-schema') {
+  if (mode !== 'single') {
     const schemaImportPath = getSchemaImportPath(name, context);
     imports.push({ name, importPath: schemaImportPath });
   }
@@ -287,10 +288,11 @@ function buildRefPayload(
     return `{} as ${refName}`;
   }
 
-  const { functionNamePrefix, mode } = context.output.factoryMethods;
+  const { functionNamePrefix = 'create', mode = 'single' } =
+    context.output.factoryMethods ?? {};
   const refFactoryName = `${functionNamePrefix}${pascal(refName)}`;
 
-  if (mode !== 'combined-separate-file') {
+  if (mode !== 'single-split') {
     const importPath = resolveImportPath(mode, refName, context);
     imports.push({ name: refFactoryName, importPath, isConstant: true });
   }
@@ -310,13 +312,13 @@ function resolveImportPath(
 ): string | undefined {
   const baseName = conventionName(refName, context.output.namingConvention);
   switch (mode) {
-    case 'separate-file': {
+    case 'split': {
       return `./${baseName}.factory`;
     }
-    case 'combined-separate-file': {
+    case 'single-split': {
       return `./${conventionName('factoryMethods', context.output.namingConvention)}`;
     }
-    case 'inline-with-schema': {
+    case 'single': {
       return `./${baseName}`;
     }
   }
@@ -350,7 +352,8 @@ function buildObjectPayload(
   parents: string[],
   imports: GeneratorImport[],
 ): string {
-  const { optionalPropertyStrategy } = context.output.factoryMethods;
+  const { includeOptionalProperty = false } =
+    context.output.factoryMethods ?? {};
   const props = getProperties(schema);
   const requiredProps: string[] =
     (schema.required as string[] | undefined) ?? [];
@@ -360,7 +363,7 @@ function buildObjectPayload(
     entries.sort(([a], [b]) => a.localeCompare(b));
   }
 
-  const includeOptional = optionalPropertyStrategy === 'include';
+  const includeOptional = includeOptionalProperty;
   const lines: string[] = [];
 
   for (const [key, prop] of entries) {

packages/core/src/generators/schema-definition.test.ts

@@ -11,12 +11,7 @@ describe('generateSchemasDefinition', () => {
   const context = {
     output: {
       override: { namingConvention: {} },
-      factoryMethods: {
-        generate: false,
-        functionNamePrefix: 'create',
-        mode: 'separate-file',
-        optionalPropertyStrategy: 'include',
-      },
+      factoryMethods: undefined,
     },
     target: 'typescript',
     workspace: '',
@@ -145,15 +140,9 @@ describe('generateSchemasDefinition', () => {
             enum: 'PascalCase',
           },
         },
-        factoryMethods: {
-          generate: false,
-          functionNamePrefix: 'create',
-          mode: 'separate-file',
-          optionalPropertyStrategy: 'include',
-        },
+        factoryMethods: undefined,
       },
       target: 'typescript',
-      workspace: '',
       spec: {},
     } as unknown as ContextSpec;
 

packages/core/src/generators/schema-definition.ts

@@ -71,14 +71,14 @@ export function generateSchemasDefinition(
     if (!seenNames.has(normalizedName)) {
       seenNames.add(normalizedName);
 
-      if (context.output.factoryMethods.generate && schema.schema) {
+      if (context.output.factoryMethods && schema.schema) {
         const factoryData = generateFactory(
           schema.schema,
           schema.name,
           context,
         );
         if (factoryData) {
-          if (context.output.factoryMethods.mode === 'inline-with-schema') {
+          if (context.output.factoryMethods.mode === 'single') {
             schema.model += `\n${factoryData.model}`;
             for (const imp of factoryData.imports) {
               if (

packages/core/src/test-utils/context.ts

@@ -41,13 +41,7 @@ export function createTestContextSpec({
     unionAddMissingProperties: false,
     optionsParamRequired: false,
     propertySortOrder: PropertySortOrder.SPECIFICATION,
-    factoryMethods: {
-      generate: false,
-      functionNamePrefix: 'create',
-      mode: 'separate-file',
-      outputDirectory: '',
-      optionalPropertyStrategy: 'include',
-    },
+    factoryMethods: undefined,
     override: {
       title: undefined,
       transformer: undefined,

packages/core/src/types.ts

@@ -58,7 +58,7 @@ export interface NormalizedOutputOptions {
   unionAddMissingProperties: boolean;
   optionsParamRequired: boolean;
   propertySortOrder: PropertySortOrder;
-  factoryMethods: NormalizedFactoryMethodsOptions;
+  factoryMethods?: NormalizedFactoryMethodsOptions;
 }
 
 export interface NormalizedParamsSerializerOptions {
@@ -278,26 +278,20 @@ export type EnumGeneration =
 
 export type SchemaGenerationType = 'typescript' | 'zod';
 
-export type FactoryMethodsOptionalPropertyStrategy = 'include' | 'omit';
-export type FactoryMethodsMode =
-  | 'inline-with-schema'
-  | 'separate-file'
-  | 'combined-separate-file';
+export type FactoryMethodsMode = 'single' | 'split' | 'single-split';
 
 export interface FactoryMethodsOptions {
-  generate?: boolean;
   functionNamePrefix?: string;
   mode?: FactoryMethodsMode;
   outputDirectory?: string;
-  optionalPropertyStrategy?: FactoryMethodsOptionalPropertyStrategy;
+  includeOptionalProperty?: boolean;
 }
 
 export interface NormalizedFactoryMethodsOptions {
-  generate: boolean;
   functionNamePrefix: string;
   mode: FactoryMethodsMode;
   outputDirectory: string;
-  optionalPropertyStrategy: FactoryMethodsOptionalPropertyStrategy;
+  includeOptionalProperty: boolean;
 }
 
 export interface SchemaOptions {

packages/core/src/writers/schemas.ts

@@ -426,7 +426,7 @@ async function emitFactoryForSchema(
 ) {
   if (schema.factory && schema.factoryMode) {
     const mode = schema.factoryMode;
-    if (mode === 'separate-file') {
+    if (mode === 'split') {
       const baseName = conventionName(schema.name, namingConvention);
       const factoryName = `${baseName}.factory`;
       helpers.separateFactoryNames.push(factoryName);
@@ -439,7 +439,7 @@ async function emitFactoryForSchema(
         getPath(factoryDir, factoryName, fileExtension),
         factoryFile,
       );
-    } else if (mode === 'combined-separate-file') {
+    } else if (mode === 'single-split') {
       helpers.isCombined.value = true;
       helpers.combinedFactoryContent.value += `${schema.factory}\n`;
       helpers.combinedFactoryImports.push(...(schema.factoryImports ?? []));