Merge pull request #1241 from hey-api/feat/input-filter

feat: add `input.include` option

.changeset/tidy-eyes-flash.md

···
+---
+'@hey-api/openapi-ts': minor
+---
+
+feat: add input.include option

docs/.vitepress/config/en.ts

···
       },
       {
         items: [
-          { link: '/about', text: 'Philosophy' },
+          { link: '/openapi-ts/migrating', text: 'Migrating' },
           { link: '/license', text: 'License' },
+          { link: '/about', text: 'Philosophy' },
           { link: '/contributing', text: 'Contributing' },
-          { link: '/openapi-ts/migrating', text: 'Migrating' },
         ],
         text: '@hey-api',
       },

docs/openapi-ts/configuration.md

···
 We use [`@apidevtools/json-schema-ref-parser`](https://github.com/APIDevTools/json-schema-ref-parser) to resolve file locations. Please note that accessing a HTTPS URL on localhost has a known [workaround](https://github.com/hey-api/openapi-ts/issues/276).
 :::
 
+## Filters
+
+::: warning
+Filters work only with the [experimental parser](#parser) which is currently an opt-in feature.
+:::
+
+If you work with large specifications and want to generate output from their subset, set `input.include` to a valid regular expression string.
+
+```js
+export default {
+  client: '@hey-api/client-fetch',
+  experimentalParser: true, // [!code ++]
+  input: {
+    include: '^(#/components/schemas/foo|#/paths/api/v1/foo/get)$', // [!code ++]
+    path: 'path/to/openapi.json',
+  },
+  output: 'src/client',
+};
+```
+
+The configuration above will process only the schema named `foo` and `GET` operation for the `/api/v1/foo` path.
+
 ## Output
 
 Output is the next thing to define. It can be either a string pointing to the destination folder or a configuration object containing the destination folder path and optional settings (these are described below).
···
 Plugins are responsible for generating artifacts from your input. By default, Hey API will generate TypeScript interfaces, JSON Schemas, and services from your OpenAPI specification. You can add, remove, or customize any of the plugins. In fact, we highly encourage you to do so!
 
 You can learn more on the [Output](/openapi-ts/output) page.
+
+## Parser
+
+If you're using OpenAPI 3.0 or newer, we encourage you to try out the experimental parser. In the future it will become the default parser, but until it's been tested it's an opt-in feature. To try it out, set the `experimentalParser` flag in your configuration to `true`.
+
+::: code-group
+
+```js [config]
+export default {
+  client: '@hey-api/client-fetch',
+  experimentalParser: true, // [!code ++]
+  input: 'path/to/openapi.json',
+  output: 'src/client',
+};
+```
+
+```sh [cli]
+npx @hey-api/openapi-ts -i path/to/openapi.json -o src/client -c @hey-api/client-fetch -e
+```
+
+:::
+
+The experimental parser produces a cleaner output while being faster than the legacy parser. It also supports features such as [Filters](#filters) and more will be added in the future.
+
+The legacy parser will remain enabled for the [legacy clients](/openapi-ts/clients/legacy) regardless of the `experimentalParser` flag value. However, it's unlikely to receive any further updates.
 
 ## Config API
 

docs/openapi-ts/migrating.md

···
 
 This config option is deprecated and will be removed.
 
+## v0.55.0
+
+This release adds the ability to filter your OpenAPI specification before it's processed. This feature will be useful if you are working with a large specification and are interested in generating output only from a small subset.
+
+This feature is available only in the experimental parser. In the future, this will become the default parser. To opt-in to the experimental parser, set the `experimentalParser` flag in your configuration to `true`.
+
+### Deprecated `include` in `@hey-api/types`
+
+This config option is deprecated and will be removed when the experimental parser becomes the default.
+
+### Deprecated `filter` in `@hey-api/services`
+
+This config option is deprecated and will be removed when the experimental parser becomes the default.
+
+### Added `input.include` option
+
+This config option can be used to replace the deprecated options. It accepts a regular expression string matching against references within the bundled specification.
+
+```js
+export default {
+  client: '@hey-api/client-fetch',
+  experimentalParser: true,
+  input: {
+    include: '^(#/components/schemas/foo|#/paths/api/v1/foo/get)$', // [!code ++]
+    path: 'path/to/openapi.json',
+  },
+  output: 'src/client',
+};
+```
+
+The configuration above will process only the schema named `foo` and `GET` operation for the `/api/v1/foo` path.
+
 ## v0.54.0
 
 This release makes plugins first-class citizens. In order to achieve that, the following breaking changes were introduced.

docs/openapi-ts/output.md

···
 Learn about files generated with `@hey-api/openapi-ts`.
 
 ::: tip
-
 Your actual output depends on your Hey API configuration. It may contain a different number of files and their contents might differ.
-
 :::
 
 ## Overview

packages/openapi-ts/src/generate/__tests__/class.spec.ts

···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       name: 'AppClient',
       output: {
         path: '',

packages/openapi-ts/src/generate/__tests__/core.spec.ts

···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       name: 'AppClient',
       output: {
         path: '',
···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       name: 'AppClient',
       output: {
         path: '',
···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       name: 'AppClient',
       output: {
         path: '',

packages/openapi-ts/src/generate/__tests__/index.spec.ts

···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       output: {
         path: '',
       },

packages/openapi-ts/src/generate/__tests__/output.spec.ts

···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       output: {
         format: 'prettier',
         path: './dist',

packages/openapi-ts/src/generate/output.ts

···
   templates,
 }: {
   client: Client;
-  openApi: OpenApi;
+  openApi: unknown;
   templates: Templates;
 }): Promise<void> => {
   const config = getConfig();
+
+  const spec = openApi as OpenApi;
 
   // TODO: parser - move to config.input
   if (client) {
···
   }
 
   // deprecated files
-  await generateLegacyClientClass(openApi, outputPath, client, templates);
+  await generateLegacyClientClass(spec, outputPath, client, templates);
   await generateLegacyCore(
     path.resolve(config.output.path, 'core'),
     client,
···
     plugin._handlerLegacy({
       client,
       files,
-      openApi,
+      openApi: spec,
       plugin: plugin as never,
     });
   }

packages/openapi-ts/src/index.ts

···
+import { existsSync } from 'node:fs';
 import path from 'node:path';
 
+import $RefParser from '@apidevtools/json-schema-ref-parser';
 import { loadConfig } from 'c12';
 import { sync } from 'cross-spawn';
 
···
   legacyNameFromConfig,
   setConfig,
 } from './utils/config';
-import { getOpenApiSpec } from './utils/getOpenApiSpec';
 import { registerHandlebarTemplates } from './utils/handlebars';
 import { Performance, PerformanceReport } from './utils/performance';
 import { postProcessClient } from './utils/postprocess';
···
   return client;
 };
 
+const getInput = (userConfig: ClientConfig): Config['input'] => {
+  let input: Config['input'] = {
+    path: '',
+  };
+  if (typeof userConfig.input === 'string') {
+    input.path = userConfig.input;
+  } else if (userConfig.input && userConfig.input.path) {
+    input = {
+      ...input,
+      ...userConfig.input,
+    };
+  } else {
+    input = {
+      ...input,
+      path: userConfig.input,
+    };
+  }
+  return input;
+};
+
 const getOutput = (userConfig: ClientConfig): Config['output'] => {
   let output: Config['output'] = {
     format: false,
···
   };
 };
 
+const getSpec = async ({ config }: { config: Config }) => {
+  let spec: unknown = config.input.path;
+
+  if (typeof config.input.path === 'string') {
+    const absolutePathOrUrl = existsSync(config.input.path)
+      ? path.resolve(config.input.path)
+      : config.input.path;
+    spec = await $RefParser.bundle(absolutePathOrUrl, absolutePathOrUrl, {});
+  }
+
+  return spec;
+};
+
 const initConfigs = async (userConfig: UserConfig): Promise<Config[]> => {
   let configurationFile: string | undefined = undefined;
   if (userConfig.configFile) {
···
       dryRun = false,
       exportCore = true,
       experimentalParser = false,
-      input,
       name,
       request,
       useOptions = true,
···
       console.warn('userConfig:', userConfig);
     }
 
+    const input = getInput(userConfig);
     const output = getOutput(userConfig);
 
-    if (!input) {
+    if (!input.path) {
       throw new Error(
         '🚫 missing input - which OpenAPI specification should we use to generate your client?',
       );
···
   Performance.end('handlebars');
 
   const pCreateClient = (config: Config) => async () => {
-    Performance.start('openapi');
-    const openApi =
-      typeof config.input === 'string'
-        ? await getOpenApiSpec(config.input)
-        : (config.input as unknown as Awaited<
-            ReturnType<typeof getOpenApiSpec>
-          >);
-    Performance.end('openapi');
+    Performance.start('spec');
+    const spec = await getSpec({ config });
+    Performance.end('spec');
 
     let client: Client | undefined;
     let context: IRContext | undefined;
···
       context = parseExperimental({
         config,
         parserConfig,
-        spec: openApi,
+        spec,
       });
     }
 
     // fallback to legacy parser
     if (!context) {
       const parsed = parseLegacy({
-        openApi,
+        openApi: spec,
         parserConfig,
       });
       client = postProcessClient(parsed);
···
     if (context) {
       await generateOutput({ context });
     } else if (client) {
-      await generateLegacyOutput({ client, openApi, templates });
+      await generateLegacyOutput({ client, openApi: spec, templates });
     }
     Performance.end('generator');
 

packages/openapi-ts/src/openApi/3.0.x/parser/index.ts

···
 import type { IRContext } from '../../../ir/context';
+import { canProcessRef } from '../../shared/utils/filter';
 import type {
   OpenApiV3_0_X,
   ParameterObject,
···
 
 export const parseV3_0_X = (context: IRContext<OpenApiV3_0_X>) => {
   const operationIds = new Map<string, string>();
+
+  const regexp = context.config.input.include
+    ? new RegExp(context.config.input.include)
+    : undefined;
 
   for (const path in context.spec.paths) {
     const pathItem = context.spec.paths[path as keyof PathsObject];
···
       path: path as keyof PathsObject,
     };
 
-    if (finalPathItem.delete) {
+    const $refDelete = `#/paths${path}/delete`;
+    if (finalPathItem.delete && canProcessRef($refDelete, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'delete',
···
       });
     }
 
-    if (finalPathItem.get) {
+    const $refGet = `#/paths${path}/get`;
+    if (finalPathItem.get && canProcessRef($refGet, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'get',
···
       });
     }
 
-    if (finalPathItem.head) {
+    const $refHead = `#/paths${path}/head`;
+    if (finalPathItem.head && canProcessRef($refHead, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'head',
···
       });
     }
 
-    if (finalPathItem.options) {
+    const $refOptions = `#/paths${path}/options`;
+    if (finalPathItem.options && canProcessRef($refOptions, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'options',
···
       });
     }
 
-    if (finalPathItem.patch) {
+    const $refPatch = `#/paths${path}/patch`;
+    if (finalPathItem.patch && canProcessRef($refPatch, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'patch',
···
       });
     }
 
-    if (finalPathItem.post) {
+    const $refPost = `#/paths${path}/post`;
+    if (finalPathItem.post && canProcessRef($refPost, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'post',
···
       });
     }
 
-    if (finalPathItem.put) {
+    const $refPut = `#/paths${path}/put`;
+    if (finalPathItem.put && canProcessRef($refPut, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'put',
···
       });
     }
 
-    if (finalPathItem.trace) {
+    const $refTrace = `#/paths${path}/trace`;
+    if (finalPathItem.trace && canProcessRef($refTrace, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'trace',
···
   // TODO: parser - handle more component types, old parser handles only parameters and schemas
   if (context.spec.components) {
     for (const name in context.spec.components.parameters) {
+      const $ref = `#/components/parameters/${name}`;
+      if (!canProcessRef($ref, regexp)) {
+        continue;
+      }
+
       const parameterOrReference = context.spec.components.parameters[name];
       const parameter =
         '$ref' in parameterOrReference
···
     }
 
     for (const name in context.spec.components.schemas) {
+      const $ref = `#/components/schemas/${name}`;
+      if (!canProcessRef($ref, regexp)) {
+        continue;
+      }
+
       const schema = context.spec.components.schemas[name];
 
       parseSchema({

packages/openapi-ts/src/openApi/3.0.x/parser/operation.ts

···
   operationIds: Map<string, string>;
   path: keyof IRPathsObject;
 }) => {
-  const operationKey = `${method.toUpperCase()} ${path}`;
-
-  // TODO: parser - move services to plugin, cleaner syntax
-  if (
-    !context.parserConfig.filterFn.operation({
-      config: context.config,
-      operationKey,
-    })
-  ) {
-    return;
-  }
-
   // TODO: parser - support throw on duplicate
   if (operation.operationId) {
+    const operationKey = `${method.toUpperCase()} ${path}`;
+
     if (operationIds.has(operation.operationId)) {
       console.warn(
         `❗️ Duplicate operationId: ${operation.operationId} in ${operationKey}. Please ensure your operation IDs are unique. This behavior is not supported and will likely lead to unexpected results.`,

packages/openapi-ts/src/openApi/3.1.x/parser/index.ts

···
 import type { IRContext } from '../../../ir/context';
+import { canProcessRef } from '../../shared/utils/filter';
 import type {
   OpenApiV3_1_X,
   ParameterObject,
···
 
 export const parseV3_1_X = (context: IRContext<OpenApiV3_1_X>) => {
   const operationIds = new Map<string, string>();
+
+  const regexp = context.config.input.include
+    ? new RegExp(context.config.input.include)
+    : undefined;
 
   for (const path in context.spec.paths) {
     const pathItem = context.spec.paths[path as keyof PathsObject];
···
         path: path as keyof PathsObject,
       };
 
-    if (finalPathItem.delete) {
+    const $refDelete = `#/paths${path}/delete`;
+    if (finalPathItem.delete && canProcessRef($refDelete, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'delete',
···
       });
     }
 
-    if (finalPathItem.get) {
+    const $refGet = `#/paths${path}/get`;
+    if (finalPathItem.get && canProcessRef($refGet, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'get',
···
       });
     }
 
-    if (finalPathItem.head) {
+    const $refHead = `#/paths${path}/head`;
+    if (finalPathItem.head && canProcessRef($refHead, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'head',
···
       });
     }
 
-    if (finalPathItem.options) {
+    const $refOptions = `#/paths${path}/options`;
+    if (finalPathItem.options && canProcessRef($refOptions, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'options',
···
       });
     }
 
-    if (finalPathItem.patch) {
+    const $refPatch = `#/paths${path}/patch`;
+    if (finalPathItem.patch && canProcessRef($refPatch, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'patch',
···
       });
     }
 
-    if (finalPathItem.post) {
+    const $refPost = `#/paths${path}/post`;
+    if (finalPathItem.post && canProcessRef($refPost, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'post',
···
       });
     }
 
-    if (finalPathItem.put) {
+    const $refPut = `#/paths${path}/put`;
+    if (finalPathItem.put && canProcessRef($refPut, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'put',
···
       });
     }
 
-    if (finalPathItem.trace) {
+    const $refTrace = `#/paths${path}/trace`;
+    if (finalPathItem.trace && canProcessRef($refTrace, regexp)) {
       parseOperation({
         ...operationArgs,
         method: 'trace',
···
   // TODO: parser - handle more component types, old parser handles only parameters and schemas
   if (context.spec.components) {
     for (const name in context.spec.components.parameters) {
+      const $ref = `#/components/parameters/${name}`;
+      if (!canProcessRef($ref, regexp)) {
+        continue;
+      }
+
       const parameterOrReference = context.spec.components.parameters[name];
       const parameter =
         '$ref' in parameterOrReference
···
     }
 
     for (const name in context.spec.components.schemas) {
+      const $ref = `#/components/schemas/${name}`;
+      if (!canProcessRef($ref, regexp)) {
+        continue;
+      }
+
       const schema = context.spec.components.schemas[name];
 
       parseSchema({

packages/openapi-ts/src/openApi/3.1.x/parser/operation.ts

···
   operationIds: Map<string, string>;
   path: keyof IRPathsObject;
 }) => {
-  const operationKey = `${method.toUpperCase()} ${path}`;
-
-  // TODO: parser - move services to plugin, cleaner syntax
-  if (
-    !context.parserConfig.filterFn.operation({
-      config: context.config,
-      operationKey,
-    })
-  ) {
-    return;
-  }
-
   // TODO: parser - support throw on duplicate
   if (operation.operationId) {
+    const operationKey = `${method.toUpperCase()} ${path}`;
+
     if (operationIds.has(operation.operationId)) {
       console.warn(
         `❗️ Duplicate operationId: ${operation.operationId} in ${operationKey}. Please ensure your operation IDs are unique. This behavior is not supported and will likely lead to unexpected results.`,

packages/openapi-ts/src/openApi/__tests__/index.spec.ts

···
 
   it('throws on unknown version', () => {
     expect(() =>
-      // @ts-expect-error
       parseLegacy({ openApi: { foo: 'bar' }, parserConfig }),
     ).toThrow(
       `Unsupported OpenAPI specification: ${JSON.stringify({ foo: 'bar' }, null, 2)}`,

packages/openapi-ts/src/openApi/index.ts

···
   openApi,
   parserConfig,
 }: {
-  openApi: OpenApi;
+  openApi: unknown;
   parserConfig: ParserConfig;
 }): Client {
+  const spec = openApi as OpenApi;
+
   setParserConfig(parserConfig);
 
-  if ('openapi' in openApi) {
-    return parseV3(openApi);
+  if ('openapi' in spec) {
+    return parseV3(spec);
   }
 
-  if ('swagger' in openApi) {
-    return parseV2(openApi);
+  if ('swagger' in spec) {
+    return parseV2(spec);
   }
 
   throw new Error(
-    `Unsupported OpenAPI specification: ${JSON.stringify(openApi, null, 2)}`,
+    `Unsupported OpenAPI specification: ${JSON.stringify(spec, null, 2)}`,
   );
 }
 

packages/openapi-ts/src/openApi/shared/utils/filter.ts

···
+export const canProcessRef = ($ref: string, regexp?: RegExp): boolean => {
+  if (!regexp) {
+    return true;
+  }
+
+  regexp.lastIndex = 0;
+  return regexp.test($ref);
+};

packages/openapi-ts/src/plugins/@hey-api/schemas/__tests__/schemas.spec.ts

···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       name: 'AppClient',
       output: {
         path: '',
···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       name: 'AppClient',
       output: {
         path: '',

packages/openapi-ts/src/plugins/@hey-api/services/__tests__/services.spec.ts

···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       output: {
         path: '',
       },
···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       output: {
         path: '',
       },
···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       output: {
         path: '',
       },
···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       output: {
         path: '',
       },

packages/openapi-ts/src/plugins/@hey-api/services/types.d.ts

···
    * results will be included in the output. The input pattern this
    * string will be tested against is `{method} {path}`. For example,
    * you can match `POST /api/v1/foo` with `^POST /api/v1/foo$`.
+   *
+   * This option does not work with the experimental parser.
+   *
+   * @deprecated
    */
   filter?: string;
   /**

packages/openapi-ts/src/plugins/@hey-api/types/__tests__/types.spec.ts

···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       name: 'AppClient',
       output: {
         path: '',

packages/openapi-ts/src/plugins/@hey-api/types/types.d.ts

···
    */
   enums?: 'javascript' | 'typescript' | 'typescript+namespace' | false;
   /**
-   * Include only types matching regular expression
+   * Include only types matching regular expression.
+   *
+   * This option does not work with the experimental parser.
+   *
+   * @deprecated
    */
   include?: string;
   /**

packages/openapi-ts/src/types/config.ts

···
 import type { ClientPlugins, UserPlugins } from '../plugins/';
-import type { ArrayOfObjectsToObjectMap, ExtractArrayOfObjects } from './utils';
+import type {
+  ArrayOfObjectsToObjectMap,
+  ExtractArrayOfObjects,
+  ExtractWithDiscriminator,
+} from './utils';
 
 export const CLIENTS = [
   '@hey-api/client-axios',
···
    */
   exportCore?: boolean;
   /**
-   * The relative location of the OpenAPI spec
+   * Path to the OpenAPI specification. This can be either local or remote path.
+   * Both JSON and YAML file formats are supported. You can also pass the parsed
+   * object directly if you're fetching the file yourself.
+   *
+   * Alternatively, you can define a configuration object with more options.
    */
-  input: string | Record<string, unknown>;
+  input:
+    | string
+    | Record<string, unknown>
+    | {
+        /**
+         * Process only parts matching the regular expression. You can select both
+         * operations and components by reference within the bundled input.
+         *
+         * @example
+         * operation: '^#/paths/api/v1/foo/get$'
+         * schema: '^#/components/schemas/Foo$'
+         */
+        include?: string;
+        /**
+         * Path to the OpenAPI specification. This can be either local or remote path.
+         * Both JSON and YAML file formats are supported. You can also pass the parsed
+         * object directly if you're fetching the file yourself.
+         */
+        path: string | Record<string, unknown>;
+      };
   /**
    * Custom client class name. Please note this option is deprecated and
    * will be removed in favor of clients.
···
 
 export type Config = Omit<
   Required<ClientConfig>,
-  'base' | 'client' | 'name' | 'output' | 'plugins' | 'request'
+  'base' | 'client' | 'input' | 'name' | 'output' | 'plugins' | 'request'
 > &
   Pick<ClientConfig, 'base' | 'name' | 'request'> & {
     client: Extract<Required<ClientConfig>['client'], object>;
-    output: Extract<Required<ClientConfig>['output'], object>;
+    input: ExtractWithDiscriminator<ClientConfig['input'], { path: unknown }>;
+    output: Extract<ClientConfig['output'], object>;
     pluginOrder: ReadonlyArray<ClientPlugins['name']>;
     plugins: ArrayOfObjectsToObjectMap<
       ExtractArrayOfObjects<ReadonlyArray<ClientPlugins>, { name: string }>,

packages/openapi-ts/src/types/utils.ts

···
 import type { TypeScriptFile } from '../generate/files';
 
-type ExtractFromArray<T, Discriminator> = T extends Discriminator ? T : never;
+export type ExtractWithDiscriminator<T, Discriminator> = T extends Discriminator
+  ? T
+  : never;
 
 /**
  * Accepts an array of elements union and attempts to extract only objects.
···
  */
 export type ExtractArrayOfObjects<T, Discriminator> =
   T extends Array<infer U>
-    ? Array<ExtractFromArray<U, Discriminator>>
+    ? Array<ExtractWithDiscriminator<U, Discriminator>>
     : T extends ReadonlyArray<infer U>
-      ? ReadonlyArray<ExtractFromArray<U, Discriminator>>
+      ? ReadonlyArray<ExtractWithDiscriminator<U, Discriminator>>
       : never;
 
 export type Files = Record<string, TypeScriptFile>;

packages/openapi-ts/src/utils/__tests__/handlebars.spec.ts

···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       output: {
         format: 'prettier',
         path: '',
···
       dryRun: false,
       experimentalParser: false,
       exportCore: true,
-      input: '',
+      input: {
+        path: '',
+      },
       output: {
         format: 'prettier',
         path: '',

packages/openapi-ts/src/utils/__tests__/parse.spec.ts

···
     dryRun: true,
     experimentalParser: false,
     exportCore: false,
-    input: '',
+    input: {
+      path: '',
+    },
     output: {
       path: '',
     },

packages/openapi-ts/src/utils/getOpenApiSpec.ts

···
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-
-import $RefParser from '@apidevtools/json-schema-ref-parser';
-
-import type { OpenApi } from '../openApi';
-
-/**
- * Load and parse te open api spec. If the file extension is ".yml" or ".yaml"
- * we will try to parse the file as a YAML spec, otherwise we will fall back
- * on parsing the file as JSON.
- * @param location: Path or url
- */
-export const getOpenApiSpec = async (location: string) => {
-  const absolutePathOrUrl = existsSync(location)
-    ? path.resolve(location)
-    : location;
-  const schema = (await $RefParser.bundle(
-    absolutePathOrUrl,
-    absolutePathOrUrl,
-    {},
-  )) as OpenApi;
-  return schema;
-};

packages/openapi-ts/test/3.0.x.spec.ts

···
       }),
       description: 'allows arbitrary properties on objects',
     },
+    {
+      config: createConfig({
+        input: 'enum-escape.json',
+        output: 'enum-escape',
+      }),
+      description: 'escapes enum values',
+    },
   ];
 
   it.each(scenarios)('$description', async ({ config }) => {

packages/openapi-ts/test/3.1.x.spec.ts

···
     },
     {
       config: createConfig({
+        input: 'enum-escape.json',
+        output: 'enum-escape',
+      }),
+      description: 'escapes enum values',
+    },
+    {
+      config: createConfig({
         input: 'object-properties-all-of.json',
         output: 'object-properties-all-of',
       }),

packages/openapi-ts/test/__snapshots__/3.0.x/enum-escape/index.ts

···
+// This file is auto-generated by @hey-api/openapi-ts
+export * from './types.gen';

packages/openapi-ts/test/__snapshots__/3.0.x/enum-escape/types.gen.ts

···
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type Foo = {
+    foo?: "foo'bar" | 'foo"bar';
+};
+
+export type Bar = "foo'bar" | 'foo"bar';

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@hey-api/services/default/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/services.gen.ts

···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
     public static callWithDescriptions<ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) {
         return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
             ...options,
-            url: '/api/v{api-version}/descriptions/'
+            url: '/api/v{api-version}/descriptions'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/requestBody/'
+            url: '/api/v{api-version}/requestBody'
         });
     }
     
···
                 'Content-Type': null,
                 ...options?.headers
             },
-            url: '/api/v{api-version}/formData/'
+            url: '/api/v{api-version}/formData'
         });
     }
     

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/services.gen.ts

···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
     public static callWithDescriptions<ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) {
         return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
             ...options,
-            url: '/api/v{api-version}/descriptions/'
+            url: '/api/v{api-version}/descriptions'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/requestBody/'
+            url: '/api/v{api-version}/requestBody'
         });
     }
     
···
                 'Content-Type': null,
                 ...options?.headers
             },
-            url: '/api/v{api-version}/formData/'
+            url: '/api/v{api-version}/formData'
         });
     }
     

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/services.gen.ts

···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
     public static callWithDescriptions<ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) {
         return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
             ...options,
-            url: '/api/v{api-version}/descriptions/'
+            url: '/api/v{api-version}/descriptions'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/requestBody/'
+            url: '/api/v{api-version}/requestBody'
         });
     }
     
···
                 'Content-Type': null,
                 ...options?.headers
             },
-            url: '/api/v{api-version}/formData/'
+            url: '/api/v{api-version}/formData'
         });
     }
     

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/services.gen.ts

···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
     public static callWithDescriptions<ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) {
         return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
             ...options,
-            url: '/api/v{api-version}/descriptions/'
+            url: '/api/v{api-version}/descriptions'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/requestBody/'
+            url: '/api/v{api-version}/requestBody'
         });
     }
     
···
                 'Content-Type': null,
                 ...options?.headers
             },
-            url: '/api/v{api-version}/formData/'
+            url: '/api/v{api-version}/formData'
         });
     }
     

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/services.gen.ts

···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
     public static callWithDescriptions<ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) {
         return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
             ...options,
-            url: '/api/v{api-version}/descriptions/'
+            url: '/api/v{api-version}/descriptions'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/requestBody/'
+            url: '/api/v{api-version}/requestBody'
         });
     }
     
···
                 'Content-Type': null,
                 ...options?.headers
             },
-            url: '/api/v{api-version}/formData/'
+            url: '/api/v{api-version}/formData'
         });
     }
     

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/enum-escape/index.ts

···
+// This file is auto-generated by @hey-api/openapi-ts
+export * from './types.gen';

packages/openapi-ts/test/__snapshots__/3.1.x/enum-escape/types.gen.ts

···
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type Foo = {
+    foo?: "foo'bar" | 'foo"bar';
+};
+
+export type Bar = "foo'bar" | 'foo"bar';

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@hey-api/services/default/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/services.gen.ts

···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
     public static callWithDescriptions<ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) {
         return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
             ...options,
-            url: '/api/v{api-version}/descriptions/'
+            url: '/api/v{api-version}/descriptions'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/requestBody/'
+            url: '/api/v{api-version}/requestBody'
         });
     }
     
···
                 'Content-Type': null,
                 ...options?.headers
             },
-            url: '/api/v{api-version}/formData/'
+            url: '/api/v{api-version}/formData'
         });
     }
     

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/services.gen.ts

···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
     public static callWithDescriptions<ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) {
         return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
             ...options,
-            url: '/api/v{api-version}/descriptions/'
+            url: '/api/v{api-version}/descriptions'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/requestBody/'
+            url: '/api/v{api-version}/requestBody'
         });
     }
     
···
                 'Content-Type': null,
                 ...options?.headers
             },
-            url: '/api/v{api-version}/formData/'
+            url: '/api/v{api-version}/formData'
         });
     }
     

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/services.gen.ts

···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
     public static callWithDescriptions<ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) {
         return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
             ...options,
-            url: '/api/v{api-version}/descriptions/'
+            url: '/api/v{api-version}/descriptions'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/requestBody/'
+            url: '/api/v{api-version}/requestBody'
         });
     }
     
···
                 'Content-Type': null,
                 ...options?.headers
             },
-            url: '/api/v{api-version}/formData/'
+            url: '/api/v{api-version}/formData'
         });
     }
     

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/services.gen.ts

···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
     public static callWithDescriptions<ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) {
         return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
             ...options,
-            url: '/api/v{api-version}/descriptions/'
+            url: '/api/v{api-version}/descriptions'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/requestBody/'
+            url: '/api/v{api-version}/requestBody'
         });
     }
     
···
                 'Content-Type': null,
                 ...options?.headers
             },
-            url: '/api/v{api-version}/formData/'
+            url: '/api/v{api-version}/formData'
         });
     }
     

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/services.gen.ts

···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/parameters/'
+            url: '/api/v{api-version}/parameters'
         });
     }
     
···
     public static callWithDescriptions<ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) {
         return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
             ...options,
-            url: '/api/v{api-version}/descriptions/'
+            url: '/api/v{api-version}/descriptions'
         });
     }
     
···
                 'Content-Type': 'application/json',
                 ...options?.headers
             },
-            url: '/api/v{api-version}/requestBody/'
+            url: '/api/v{api-version}/requestBody'
         });
     }
     
···
                 'Content-Type': null,
                 ...options?.headers
             },
-            url: '/api/v{api-version}/formData/'
+            url: '/api/v{api-version}/formData'
         });
     }
     

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/services.gen.ts

···
 export const callWithDescriptions = <ThrowOnError extends boolean = false>(options?: Options<CallWithDescriptionsData, ThrowOnError>) => {
     return (options?.client ?? client).post<unknown, unknown, ThrowOnError>({
         ...options,
-        url: '/api/v{api-version}/descriptions/'
+        url: '/api/v{api-version}/descriptions'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/parameters/'
+        url: '/api/v{api-version}/parameters'
     });
 };
 
···
             'Content-Type': 'application/json',
             ...options?.headers
         },
-        url: '/api/v{api-version}/requestBody/'
+        url: '/api/v{api-version}/requestBody'
     });
 };
 
···
             'Content-Type': null,
             ...options?.headers
         },
-        url: '/api/v{api-version}/formData/'
+        url: '/api/v{api-version}/formData'
     });
 };
 

packages/openapi-ts/test/sample.cjs

···
     },
     // debug: true,
     experimentalParser: true,
-    input: './test/spec/3.0.x/full.json',
-    // input: 'https://mongodb-mms-prod-build-server.s3.amazonaws.com/openapi/2caffd88277a4e27c95dcefc7e3b6a63a3b03297-v2-2023-11-15.json',
+    input: {
+      include:
+        '^(#/components/schemas/import|#/paths/api/v{api-version}/simple/options)$',
+      path: './test/spec/3.1.x/full.json',
+      // path: 'https://mongodb-mms-prod-build-server.s3.amazonaws.com/openapi/2caffd88277a4e27c95dcefc7e3b6a63a3b03297-v2-2023-11-15.json',
+    },
     // name: 'foo',
     output: {
       // format: 'prettier',
···
       // },
       {
         // asClass: true,
-        // filter: '^GET /api/v{api-version}/simple:operation$',
+        // include...
         name: '@hey-api/services',
         // serviceNameBuilder: '^Parameters',
       },
···
         // enums: 'typescript',
         // enums: 'typescript+namespace',
         // enums: 'javascript',
-        // include:
-        //   '^(_400|CompositionWithOneOfAndProperties)',
         name: '@hey-api/types',
         // style: 'PascalCase',
         // tree: false,
       },
-      '@tanstack/react-query',
+      // '@tanstack/react-query',
       // 'zod',
     ],
     // useOptions: false,

packages/openapi-ts/test/spec/3.0.x/enum-escape.json

···
+{
+  "openapi": "3.0.2",
+  "info": {
+    "title": "OpenAPI 3.0.2 enum escape example",
+    "version": "1"
+  },
+  "components": {
+    "schemas": {
+      "Foo": {
+        "type": "object",
+        "properties": {
+          "foo": {
+            "enum": ["foo'bar", "foo\"bar"],
+            "type": "string"
+          }
+        }
+      },
+      "Bar": {
+        "enum": ["foo'bar", "foo\"bar"],
+        "type": "string"
+      }
+    }
+  }
+}

packages/openapi-ts/test/spec/3.0.x/full.json

···
         }
       ]
     },
-    "/api/v{api-version}/descriptions/": {
+    "/api/v{api-version}/descriptions": {
       "post": {
         "tags": ["Descriptions"],
         "operationId": "CallWithDescriptions",
···
         }
       }
     },
-    "/api/v{api-version}/parameters/": {
+    "/api/v{api-version}/parameters": {
       "get": {
         "tags": ["Parameters"],
         "operationId": "GetCallWithOptionalParam",
···
         }
       }
     },
-    "/api/v{api-version}/requestBody/": {
+    "/api/v{api-version}/requestBody": {
       "post": {
         "tags": ["RequestBody"],
         "parameters": [
···
         }
       }
     },
-    "/api/v{api-version}/formData/": {
+    "/api/v{api-version}/formData": {
       "post": {
         "tags": ["FormData"],
         "parameters": [

packages/openapi-ts/test/spec/3.1.x/enum-escape.json

···
+{
+  "openapi": "3.1.1",
+  "info": {
+    "title": "OpenAPI 3.1.1 enum escape example",
+    "version": "1"
+  },
+  "components": {
+    "schemas": {
+      "Foo": {
+        "type": "object",
+        "properties": {
+          "foo": {
+            "enum": ["foo'bar", "foo\"bar"],
+            "type": "string"
+          }
+        }
+      },
+      "Bar": {
+        "enum": ["foo'bar", "foo\"bar"],
+        "type": "string"
+      }
+    }
+  }
+}

packages/openapi-ts/test/spec/3.1.x/full.json

···
         }
       ]
     },
-    "/api/v{api-version}/descriptions/": {
+    "/api/v{api-version}/descriptions": {
       "post": {
         "tags": ["Descriptions"],
         "operationId": "CallWithDescriptions",
···
         }
       }
     },
-    "/api/v{api-version}/parameters/": {
+    "/api/v{api-version}/parameters": {
       "get": {
         "tags": ["Parameters"],
         "operationId": "GetCallWithOptionalParam",
···
         }
       }
     },
-    "/api/v{api-version}/requestBody/": {
+    "/api/v{api-version}/requestBody": {
       "post": {
         "tags": ["RequestBody"],
         "parameters": [
···
         }
       }
     },
-    "/api/v{api-version}/formData/": {
+    "/api/v{api-version}/formData": {
       "post": {
         "tags": ["FormData"],
         "parameters": [