fix: export inlined enums from components

.changeset/tame-tips-travel.md

@@ -0,0 +1,5 @@
+---
+"@hey-api/openapi-ts": patch
+---
+
+fix: export inlined enums from components

packages/openapi-ts/src/openApi/v3/parser/getModel.ts

@@ -1,7 +1,9 @@
+import { unescapeName } from '../../../utils/escape';
 import type { Model, ModelMeta } from '../../common/interfaces/client';
 import { getDefault } from '../../common/parser/getDefault';
 import { getEnums } from '../../common/parser/getEnums';
 import { getPattern } from '../../common/parser/getPattern';
+import { ensureValidTypeScriptJavaScriptIdentifier } from '../../common/parser/sanitize';
 import { getType } from '../../common/parser/type';
 import type { OpenApi } from '../interfaces/OpenApi';
 import type { OpenApiSchema } from '../interfaces/OpenApiSchema';
@@ -21,12 +23,17 @@
 
 export const getModel = ({
   definition,
+  initialValues = {},
   isDefinition = false,
   meta,
   openApi,
   parentDefinition = null,
 }: {
   definition: OpenApiSchema;
+  /**
+   * Pass through initial model values
+   */
+  initialValues?: Partial<Model>;
   isDefinition?: boolean;
   meta?: ModelMeta;
   openApi: OpenApi;
@@ -68,6 +75,7 @@
     template: null,
     type: 'unknown',
     uniqueItems: definition.uniqueItems,
+    ...initialValues,
   };
 
   if (definition.$ref) {
@@ -90,6 +98,14 @@
       model.export = 'enum';
       model.type = 'string';
       model.default = getDefault(definition, model);
+      if (!model.meta) {
+        model.meta = {
+          $ref: `enum/${model.name}`,
+          name: ensureValidTypeScriptJavaScriptIdentifier(
+            unescapeName(model.name),
+          ),
+        };
+      }
       return model;
     }
   }
@@ -115,7 +131,11 @@
           (definition) => !getDefinitionTypes(definition).includes('array'),
         )
       ) {
-        return getModel({ definition: definition.items, openApi });
+        return getModel({
+          definition: definition.items,
+          openApi,
+          parentDefinition: definition,
+        });
       }
     }
 
@@ -128,7 +148,11 @@
           anyOf: definition.items,
         }
       : definition.items;
-    const arrayItems = getModel({ definition: arrayItemsDefinition, openApi });
+    const arrayItems = getModel({
+      definition: arrayItemsDefinition,
+      openApi,
+      parentDefinition: definition,
+    });
     model.base = arrayItems.base;
     model.export = 'array';
     model.$refs = [...model.$refs, ...arrayItems.$refs];

packages/openapi-ts/src/openApi/v3/parser/getModelProperties.ts

@@ -26,7 +26,11 @@ export const getAdditionalPropertiesModel = (
     typeof definition.additionalProperties === 'object'
       ? definition.additionalProperties
       : {};
-  const apModel = getModel({ definition: ap, openApi });
+  const apModel = getModel({
+    definition: ap,
+    openApi,
+    parentDefinition: definition,
+  });
 
   if (ap.$ref) {
     const apType = getType({ type: ap.$ref });
@@ -74,7 +78,7 @@ export const getModelProperties = (
   getModel: GetModelFn,
   parent?: Model,
 ): Model[] => {
-  const models: Model[] = [];
+  let models: Model[] = [];
   const discriminator = findOneOfParentDiscriminator(openApi, parent);
 
   Object.entries(definition.properties ?? {}).forEach(
@@ -118,53 +122,51 @@ export const getModelProperties = (
       };
 
       if (parent && discriminator?.propertyName == propertyName) {
-        models.push({
-          ...propertyValues,
-          $refs: [],
-          base: `'${mapPropertyValue(discriminator, parent)}'`,
-          enum: [],
-          enums: [],
-          export: 'reference',
-          imports: [],
-          isNullable: isDefinitionNullable(property),
-          link: null,
-          properties: [],
-          template: null,
-          type: 'string',
-        });
+        models = [
+          ...models,
+          {
+            ...propertyValues,
+            $refs: [],
+            base: `'${mapPropertyValue(discriminator, parent)}'`,
+            enum: [],
+            enums: [],
+            export: 'reference',
+            imports: [],
+            isNullable: isDefinitionNullable(property),
+            link: null,
+            properties: [],
+            template: null,
+            type: 'string',
+          },
+        ];
       } else if (property.$ref) {
         const model = getType({ type: property.$ref });
-        models.push({
-          ...propertyValues,
-          $refs: model.$refs,
-          base: model.base,
-          enum: [],
-          enums: [],
-          export: 'reference',
-          imports: model.imports,
-          isNullable: model.isNullable || isDefinitionNullable(property),
-          link: null,
-          properties: [],
-          template: model.template,
-          type: model.type,
-        });
+        models = [
+          ...models,
+          {
+            ...propertyValues,
+            $refs: model.$refs,
+            base: model.base,
+            enum: [],
+            enums: [],
+            export: 'reference',
+            imports: model.imports,
+            isNullable: model.isNullable || isDefinitionNullable(property),
+            link: null,
+            properties: [],
+            template: model.template,
+            type: model.type,
+          },
+        ];
       } else {
-        const model = getModel({ definition: property, openApi });
-        models.push({
-          ...propertyValues,
-          $refs: model.$refs,
-          base: model.base,
-          default: model.default,
-          enum: model.enum,
-          enums: model.enums,
-          export: model.export,
-          imports: model.imports,
-          isNullable: model.isNullable || isDefinitionNullable(property),
-          link: model.link,
-          properties: model.properties,
-          template: model.template,
-          type: model.type,
+        const model = getModel({
+          definition: property,
+          initialValues: propertyValues,
+          openApi,
+          parentDefinition: definition,
         });
+        model.isNullable = model.isNullable || isDefinitionNullable(property);
+        models = [...models, model];
       }
     },
   );

packages/openapi-ts/src/openApi/v3/parser/getOperationParameter.ts

@@ -1,8 +1,10 @@
+import { unescapeName } from '../../../utils/escape';
 import type { OperationParameter } from '../../common/interfaces/client';
 import { getDefault } from '../../common/parser/getDefault';
 import { getPattern } from '../../common/parser/getPattern';
 import { getRef } from '../../common/parser/getRef';
 import { getOperationParameterName } from '../../common/parser/operation';
+import { ensureValidTypeScriptJavaScriptIdentifier } from '../../common/parser/sanitize';
 import { getType } from '../../common/parser/type';
 import type { OpenApi } from '../interfaces/OpenApi';
 import type { OpenApiParameter } from '../interfaces/OpenApiParameter';
@@ -14,7 +16,7 @@ export const getOperationParameter = (
   openApi: OpenApi,
   parameter: OpenApiParameter,
 ): OperationParameter => {
-  const operationParameter: OperationParameter = {
+  let operationParameter: OperationParameter = {
     $refs: [],
     base: 'unknown',
     deprecated: parameter.deprecated === true,
@@ -74,39 +76,48 @@ export const getOperationParameter = (
       return operationParameter;
     } else {
       const model = getModel({ definition: schema, openApi });
-      operationParameter.export = model.export;
-      operationParameter.type = model.type;
-      operationParameter.base = model.base;
-      operationParameter.template = model.template;
-      operationParameter.link = model.link;
-      operationParameter.isReadOnly = model.isReadOnly;
-      operationParameter.isRequired =
-        operationParameter.isRequired || model.isRequired;
-      operationParameter.isNullable =
-        operationParameter.isNullable || model.isNullable;
-      operationParameter.format = model.format;
-      operationParameter.maximum = model.maximum;
-      operationParameter.exclusiveMaximum = model.exclusiveMaximum;
-      operationParameter.minimum = model.minimum;
-      operationParameter.exclusiveMinimum = model.exclusiveMinimum;
-      operationParameter.multipleOf = model.multipleOf;
-      operationParameter.maxLength = model.maxLength;
-      operationParameter.minLength = model.minLength;
-      operationParameter.maxItems = model.maxItems;
-      operationParameter.minItems = model.minItems;
-      operationParameter.uniqueItems = model.uniqueItems;
-      operationParameter.maxProperties = model.maxProperties;
-      operationParameter.minProperties = model.minProperties;
-      operationParameter.pattern = getPattern(model.pattern);
+      operationParameter = {
+        ...operationParameter,
+        $refs: [...operationParameter.$refs, ...model.$refs],
+        base: model.base,
+        enum: [...operationParameter.enum, ...model.enum],
+        enums: [...operationParameter.enums, ...model.enums],
+        exclusiveMaximum: model.exclusiveMaximum,
+        exclusiveMinimum: model.exclusiveMinimum,
+        export: model.export,
+        format: model.format,
+        imports: [...operationParameter.imports, ...model.imports],
+        isNullable: operationParameter.isNullable || model.isNullable,
+        isReadOnly: model.isReadOnly,
+        isRequired: operationParameter.isRequired || model.isRequired,
+        link: model.link,
+        maxItems: model.maxItems,
+        maxLength: model.maxLength,
+        maxProperties: model.maxProperties,
+        maximum: model.maximum,
+        minItems: model.minItems,
+        minLength: model.minLength,
+        minProperties: model.minProperties,
+        minimum: model.minimum,
+        multipleOf: model.multipleOf,
+        pattern: getPattern(model.pattern),
+        properties: [...operationParameter.properties, ...model.properties],
+        template: model.template,
+        type: model.type,
+        uniqueItems: model.uniqueItems,
+      };
+      if (
+        (operationParameter.enum.length || operationParameter.enums.length) &&
+        !operationParameter.meta
+      ) {
+        operationParameter.meta = {
+          $ref: `enum/${operationParameter.name}`,
+          name: ensureValidTypeScriptJavaScriptIdentifier(
+            unescapeName(operationParameter.name),
+          ),
+        };
+      }
       operationParameter.default = model.default;
-      operationParameter.$refs = [...operationParameter.$refs, ...model.$refs];
-      operationParameter.imports = [
-        ...operationParameter.imports,
-        ...model.imports,
-      ];
-      operationParameter.enum.push(...model.enum);
-      operationParameter.enums.push(...model.enums);
-      operationParameter.properties.push(...model.properties);
       return operationParameter;
     }
   }

packages/openapi-ts/src/openApi/v3/parser/getRequiredPropertiesFromComposition.ts

@@ -22,7 +22,11 @@ export const getRequiredPropertiesFromComposition = (
           ...getModel({ definition: schema, openApi }).properties,
         ];
       }
-      return [...properties, ...getModel({ definition, openApi }).properties];
+      return [
+        ...properties,
+        ...getModel({ definition, openApi, parentDefinition: definition })
+          .properties,
+      ];
     }, [] as Model[])
     .filter(
       (property) => !property.isRequired && required.includes(property.name),

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

@@ -97,16 +97,7 @@
   model.enums.forEach((enumerator) => processEnum(client, enumerator, onNode));
 };
 
-const processEnum = (
-  client: Client,
-  model: Model,
-  onNode: OnNode,
-  isExported: boolean = false,
-) => {
-  if (!isExported) {
-    return;
-  }
-
+const processEnum = (client: Client, model: Model, onNode: OnNode) => {
   const config = getConfig();
 
   const properties: Record<string | number, unknown> = {};
@@ -186,7 +177,7 @@
     case 'interface':
       return processComposition(client, model, onNode);
     case 'enum':
-      return processEnum(client, model, onNode, true);
+      return processEnum(client, model, onNode);
     default:
       return processType(client, model, onNode);
   }