feat: add OpenAPI 2.0.x experimental parser

.changeset/nasty-comics-smoke.md

@@ -0,0 +1,5 @@
+---
+'@hey-api/openapi-ts': patch
+---
+
+fix: preserve leading indicators in enum keys

packages/openapi-ts/src/compiler/typedef.ts

@@ -226,7 +226,7 @@ export const createTypeArrayNode = (
 ) => {
   const node = createTypeReferenceNode({
     typeArguments: [
-      // @ts-ignore
+      // @ts-expect-error
       Array.isArray(types) ? createTypeUnionNode({ types }) : types,
     ],
     typeName: 'Array',

packages/openapi-ts/src/index.ts

@@ -13,7 +13,7 @@ import { sync } from 'cross-spawn';
 import { generateLegacyOutput, generateOutput } from './generate/output';
 import { ensureDirSync } from './generate/utils';
 import type { IR } from './ir/types';
-import { parseExperimental, parseLegacy } from './openApi';
+import { parseLegacy, parseOpenApiSpec } from './openApi';
 import type { ClientPlugins, UserPlugins } from './plugins';
 import { defaultPluginConfigs } from './plugins';
 import type {
@@ -619,7 +619,7 @@ export async function createClient(
           !isLegacyClient(config) &&
           !legacyNameFromConfig(config)
         ) {
-          context = parseExperimental({ config, spec: data });
+          context = parseOpenApiSpec({ config, spec: data });
         }
 
         // fallback to legacy parser

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

@@ -0,0 +1,2 @@
+export { parseV2_0_X } from './parser';
+export type { OpenApiV2_0_X } from './types/spec';

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

@@ -0,0 +1,239 @@
+import type { IR } from '../../../ir/types';
+import { canProcessRef } from '../../shared/utils/filter';
+import { mergeParametersObjects } from '../../shared/utils/parameter';
+import type {
+  OpenApiV2_0_X,
+  OperationObject,
+  PathItemObject,
+  PathsObject,
+  SecuritySchemeObject,
+} from '../types/spec';
+import { parseOperation } from './operation';
+import { parametersArrayToObject } from './parameter';
+import { parseSchema } from './schema';
+
+type PathKeys<T extends keyof PathsObject = keyof PathsObject> =
+  keyof T extends infer K ? (K extends `/${string}` ? K : never) : never;
+
+export const parseV2_0_X = (context: IR.Context<OpenApiV2_0_X>) => {
+  const operationIds = new Map<string, string>();
+  const securitySchemesMap = new Map<string, SecuritySchemeObject>();
+
+  const excludeRegExp = context.config.input.exclude
+    ? new RegExp(context.config.input.exclude)
+    : undefined;
+  const includeRegExp = context.config.input.include
+    ? new RegExp(context.config.input.include)
+    : undefined;
+
+  const shouldProcessRef = ($ref: string) =>
+    canProcessRef({
+      $ref,
+      excludeRegExp,
+      includeRegExp,
+    });
+
+  // TODO: parser - support security schemas
+
+  if (context.spec.definitions) {
+    for (const name in context.spec.definitions) {
+      const $ref = `#/definitions/${name}`;
+      if (!shouldProcessRef($ref)) {
+        continue;
+      }
+
+      const schema = context.spec.definitions[name]!;
+
+      parseSchema({
+        $ref,
+        context,
+        schema,
+      });
+    }
+  }
+
+  for (const path in context.spec.paths) {
+    if (path.startsWith('x-')) {
+      continue;
+    }
+
+    const pathItem = context.spec.paths[path as PathKeys]!;
+
+    const finalPathItem = pathItem.$ref
+      ? {
+          ...context.resolveRef<PathItemObject>(pathItem.$ref),
+          ...pathItem,
+        }
+      : pathItem;
+
+    const commonOperation: OperationObject = {
+      consumes: context.spec.consumes,
+      produces: context.spec.produces,
+      responses: {},
+      security: context.spec.security,
+    };
+    const operationArgs: Omit<Parameters<typeof parseOperation>[0], 'method'> =
+      {
+        context,
+        operation: {
+          ...commonOperation,
+          id: '',
+          parameters: parametersArrayToObject({
+            context,
+            operation: commonOperation,
+            parameters: finalPathItem.parameters,
+          }),
+        },
+        operationIds,
+        path: path as PathKeys,
+        securitySchemesMap,
+      };
+
+    const $refDelete = `#/paths${path}/delete`;
+    if (finalPathItem.delete && shouldProcessRef($refDelete)) {
+      const parameters = mergeParametersObjects({
+        source: parametersArrayToObject({
+          context,
+          operation: finalPathItem.delete,
+          parameters: finalPathItem.delete.parameters,
+        }),
+        target: operationArgs.operation.parameters,
+      });
+      parseOperation({
+        ...operationArgs,
+        method: 'delete',
+        operation: {
+          ...operationArgs.operation,
+          ...finalPathItem.delete,
+          parameters,
+        },
+      });
+    }
+
+    const $refGet = `#/paths${path}/get`;
+    if (finalPathItem.get && shouldProcessRef($refGet)) {
+      const parameters = mergeParametersObjects({
+        source: parametersArrayToObject({
+          context,
+          operation: finalPathItem.get,
+          parameters: finalPathItem.get.parameters,
+        }),
+        target: operationArgs.operation.parameters,
+      });
+      parseOperation({
+        ...operationArgs,
+        method: 'get',
+        operation: {
+          ...operationArgs.operation,
+          ...finalPathItem.get,
+          parameters,
+        },
+      });
+    }
+
+    const $refHead = `#/paths${path}/head`;
+    if (finalPathItem.head && shouldProcessRef($refHead)) {
+      const parameters = mergeParametersObjects({
+        source: parametersArrayToObject({
+          context,
+          operation: finalPathItem.head,
+          parameters: finalPathItem.head.parameters,
+        }),
+        target: operationArgs.operation.parameters,
+      });
+      parseOperation({
+        ...operationArgs,
+        method: 'head',
+        operation: {
+          ...operationArgs.operation,
+          ...finalPathItem.head,
+          parameters,
+        },
+      });
+    }
+
+    const $refOptions = `#/paths${path}/options`;
+    if (finalPathItem.options && shouldProcessRef($refOptions)) {
+      const parameters = mergeParametersObjects({
+        source: parametersArrayToObject({
+          context,
+          operation: finalPathItem.options,
+          parameters: finalPathItem.options.parameters,
+        }),
+        target: operationArgs.operation.parameters,
+      });
+      parseOperation({
+        ...operationArgs,
+        method: 'options',
+        operation: {
+          ...operationArgs.operation,
+          ...finalPathItem.options,
+          parameters,
+        },
+      });
+    }
+
+    const $refPatch = `#/paths${path}/patch`;
+    if (finalPathItem.patch && shouldProcessRef($refPatch)) {
+      const parameters = mergeParametersObjects({
+        source: parametersArrayToObject({
+          context,
+          operation: finalPathItem.patch,
+          parameters: finalPathItem.patch.parameters,
+        }),
+        target: operationArgs.operation.parameters,
+      });
+      parseOperation({
+        ...operationArgs,
+        method: 'patch',
+        operation: {
+          ...operationArgs.operation,
+          ...finalPathItem.patch,
+          parameters,
+        },
+      });
+    }
+
+    const $refPost = `#/paths${path}/post`;
+    if (finalPathItem.post && shouldProcessRef($refPost)) {
+      const parameters = mergeParametersObjects({
+        source: parametersArrayToObject({
+          context,
+          operation: finalPathItem.post,
+          parameters: finalPathItem.post.parameters,
+        }),
+        target: operationArgs.operation.parameters,
+      });
+      parseOperation({
+        ...operationArgs,
+        method: 'post',
+        operation: {
+          ...operationArgs.operation,
+          ...finalPathItem.post,
+          parameters,
+        },
+      });
+    }
+
+    const $refPut = `#/paths${path}/put`;
+    if (finalPathItem.put && shouldProcessRef($refPut)) {
+      const parameters = mergeParametersObjects({
+        source: parametersArrayToObject({
+          context,
+          operation: finalPathItem.put,
+          parameters: finalPathItem.put.parameters,
+        }),
+        target: operationArgs.operation.parameters,
+      });
+      parseOperation({
+        ...operationArgs,
+        method: 'put',
+        operation: {
+          ...operationArgs.operation,
+          ...finalPathItem.put,
+          parameters,
+        },
+      });
+    }
+  }
+};

packages/openapi-ts/src/openApi/2.0.x/parser/mediaType.ts

@@ -0,0 +1,70 @@
+import type { IRMediaType } from '../../../ir/mediaType';
+import {
+  isMediaTypeFileLike,
+  mediaTypeToIrMediaType,
+} from '../../../ir/mediaType';
+import type {
+  ReferenceObject,
+  ResponseObject,
+  SchemaObject,
+} from '../types/spec';
+
+interface Content {
+  mediaType: string;
+  schema: SchemaObject | ReferenceObject | undefined;
+  type: IRMediaType | undefined;
+}
+
+export const contentToSchema = ({
+  content,
+}: {
+  content: Content;
+}): SchemaObject | undefined => {
+  const { mediaType, schema } = content;
+
+  if (schema && '$ref' in schema) {
+    return {
+      allOf: [{ ...schema }],
+    };
+  }
+
+  if (!schema) {
+    if (isMediaTypeFileLike({ mediaType })) {
+      return {
+        format: 'binary',
+        type: 'string',
+      };
+    }
+    return;
+  }
+
+  if (
+    schema.type === 'string' &&
+    !schema.format &&
+    isMediaTypeFileLike({ mediaType })
+  ) {
+    return {
+      ...schema,
+      format: 'binary',
+    };
+  }
+
+  return schema;
+};
+
+export const mediaTypeObject = ({
+  mimeTypes,
+  response,
+}: {
+  mimeTypes: ReadonlyArray<string> | undefined;
+  response: Pick<ResponseObject, 'schema'>;
+}): Content | undefined => {
+  // return the first supported MIME type
+  for (const mediaType of mimeTypes ?? []) {
+    return {
+      mediaType,
+      schema: response.schema,
+      type: mediaTypeToIrMediaType({ mediaType }),
+    };
+  }
+};