test: test fallback to custom codecs when arrow function inlining fails

Check if parseFunctionBody() succeeded before returning, allowing parser
to use custom codec definitions when function contains parameter references.

Author: yanxue-22

packages/openapi-generator/test/arrowFunctionFallback.test.ts

@@ -0,0 +1,81 @@
+const E = require('fp-ts/lib/Either');
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const { TestProject } = require('./testProject');
+const { parsePlainInitializer } = require('../src');
+
+test('arrow function with parameters should use custom codec definition', async () => {
+  const files = {
+    '/api/v2/admin/migrateOrgShardKey.ts': `
+import * as t from 'io-ts';
+import { NonEmptyString } from './types';
+import { arrayFromArrayOrSingle } from '../../../utils';
+
+export const UpdateShardKeyRequestBody = {
+  shardKey: t.string,
+  collectionType: t.union([
+    t.literal('user'),
+    t.literal('enterprise'),
+    t.literal('enterpriseTemplate')
+  ]),
+  ids: arrayFromArrayOrSingle(NonEmptyString),
+  enterpriseUpdateUsers: t.boolean,
+} as const;
+`,
+    '/api/v2/admin/types.ts': `
+import * as t from 'io-ts';
+
+export const NonEmptyString = t.string;
+`,
+    '/utils/arrayFromArrayOrSingle.ts': `
+import * as t from 'io-ts';
+import { arrayFromSingle } from '@bitgo/public-types';
+
+export const arrayFromArrayOrSingle = <C extends t.Mixed>(codec: C) =>
+  t.union([t.array(codec), arrayFromSingle(codec)]);
+`,
+  };
+
+  const knownImports = {
+    '.': {
+      arrayFromArrayOrSingle: (_: any, innerSchema: any) =>
+        E.right({ type: 'array', items: innerSchema }),
+    },
+  };
+
+  const project = new TestProject(files, knownImports);
+  await project.parseEntryPoint('/api/v2/admin/migrateOrgShardKey.ts');
+  const sourceFile = project.get('/api/v2/admin/migrateOrgShardKey.ts');
+  
+  assert.ok(sourceFile !== undefined, 'Source file should exist');
+
+  const actual: any = {};
+  const errors: string[] = [];
+  
+  for (const symbol of sourceFile.symbols.declarations) {
+    if (symbol.init !== undefined) {
+      const result = parsePlainInitializer(project, sourceFile, symbol.init);
+      if (E.isLeft(result)) {
+        errors.push(result.left);
+      } else {
+        actual[symbol.name] = result.right;
+      }
+    }
+  }
+
+  assert.deepEqual(
+    errors, 
+    [],
+    `Expected no errors, but got "${errors[0]}"`
+  );
+  
+  assert.ok(
+    actual.UpdateShardKeyRequestBody?.type === 'object',
+    'Should parse UpdateShardKeyRequestBody as object'
+  );
+  
+  assert.ok(
+    actual.UpdateShardKeyRequestBody?.properties?.ids?.type === 'array',
+    'Should parse ids field as array (from custom codec definition)'
+  );
+});

packages/openapi-generator/test/openapi/arrowFunctionFallback.test.ts

@@ -0,0 +1,205 @@
+import { testCase } from './testHarness';
+
+// SUCCESS CASE: Parameter-less arrow function should be parsed
+testCase(
+  'parameter-less arrow function is parsed and inlined',
+  `
+    import * as t from 'io-ts';
+    
+    const StringFactory = () => t.string;
+    
+    export const MyCodec = t.type({
+      field: StringFactory(),
+    });
+  `,
+  {
+    openapi: '3.0.3',
+    info: {
+      title: 'Test',
+      version: '1.0.0',
+    },
+    paths: {},
+    components: {
+      schemas: {
+        MyCodec: {
+          title: 'MyCodec',
+          type: 'object',
+          properties: {
+            field: {
+              type: 'string',
+            },
+          },
+          required: ['field'],
+        },
+        StringFactory: {
+          title: 'StringFactory',
+        },
+      },
+    },
+  },
+);
+
+// SUCCESS CASE: Parameter-less with BlockStatement
+testCase(
+  'parameter-less arrow function with BlockStatement is parsed',
+  `
+    import * as t from 'io-ts';
+    
+    const ComplexFactory = () => {
+      return t.union([t.literal('true'), t.literal('false')]);
+    };
+    
+    export const MyCodec = t.type({
+      field: ComplexFactory(),
+    });
+  `,
+  {
+    openapi: '3.0.3',
+    info: {
+      title: 'Test',
+      version: '1.0.0',
+    },
+    paths: {},
+    components: {
+      schemas: {
+        MyCodec: {
+          title: 'MyCodec',
+          type: 'object',
+          properties: {
+            field: {
+              type: 'string',
+              enum: ['true', 'false'],
+            },
+          },
+          required: ['field'],
+        },
+        ComplexFactory: {
+          title: 'ComplexFactory',
+        },
+      },
+    },
+  },
+);
+
+// FALLBACK CASE: Arrow function with parameters should fallback to ref (not error)
+testCase(
+  'arrow function with parameters falls back to ref without error',
+  `
+    import * as t from 'io-ts';
+    
+    const optional = (codec) => t.union([codec, t.undefined]);
+    
+    export const MyCodec = t.type({
+      field: optional(t.string),
+    });
+  `,
+  {
+    openapi: '3.0.3',
+    info: {
+      title: 'Test',
+      version: '1.0.0',
+    },
+    paths: {},
+    components: {
+      schemas: {
+        MyCodec: {
+          title: 'MyCodec',
+          type: 'object',
+          properties: {
+            field: {
+              $ref: '#/components/schemas/optional',
+            },
+          },
+          required: ['field'],
+        },
+        optional: {
+          title: 'optional',
+        },
+      },
+    },
+  },
+);
+
+// FALLBACK CASE: Parameter-less calling function with parameters
+testCase(
+  'parameter-less function calling function with parameters falls back gracefully',
+  `
+    import * as t from 'io-ts';
+    
+    const optional = (codec) => t.union([codec, t.undefined]);
+    const makeOptionalString = () => optional(t.string);
+    
+    export const MyCodec = t.type({
+      field: makeOptionalString(),
+    });
+  `,
+  {
+    openapi: '3.0.3',
+    info: {
+      title: 'Test',
+      version: '1.0.0',
+    },
+    paths: {},
+    components: {
+      schemas: {
+        MyCodec: {
+          title: 'MyCodec',
+          type: 'object',
+          properties: {
+            field: {
+              $ref: '#/components/schemas/optional',
+            },
+          },
+          required: ['field'],
+        },
+        makeOptionalString: {
+          title: 'makeOptionalString',
+        },
+        optional: {
+          title: 'optional',
+        },
+      },
+    },
+  },
+);
+
+// FALLBACK CASE: BlockStatement without return should fallback (not error)
+testCase(
+  'BlockStatement without return falls back to ref without error',
+  `
+    import * as t from 'io-ts';
+    
+    const NoReturnFactory = () => {
+      const x = t.string;
+    };
+    
+    export const MyCodec = t.type({
+      field: NoReturnFactory(),
+    });
+  `,
+  {
+    openapi: '3.0.3',
+    info: {
+      title: 'Test',
+      version: '1.0.0',
+    },
+    paths: {},
+    components: {
+      schemas: {
+        MyCodec: {
+          title: 'MyCodec',
+          type: 'object',
+          properties: {
+            field: {
+              $ref: '#/components/schemas/NoReturnFactory',
+            },
+          },
+          required: ['field'],
+        },
+        NoReturnFactory: {
+          title: 'NoReturnFactory',
+        },
+      },
+    },
+  },
+);