ng-openapi 0.1.10 → 0.1.11-beta.0

package/cli.cjs

@@ -44,10 +44,13 @@ var fs4 = __toESM(require("fs"));
 var path11 = __toESM(require("path"));
 
 // package.json
-var version = "0.1.9";
+var version = "0.1.10";
 
 // src/lib/core/generator.ts
-var import_ts_morph5 = require("ts-morph");
+var import_ts_morph6 = require("ts-morph");
+
+// src/lib/generators/type/type.generator.ts
+var import_ts_morph = require("ts-morph");
 
 // ../shared/src/utils/string.utils.ts
 function camelCase(str) {
@@ -620,6 +623,13 @@ var TypeGenerator = class {
   sourceFile;
   generatedTypes = /* @__PURE__ */ new Set();
   config;
+  // Performance caches
+  pascalCaseCache = /* @__PURE__ */ new Map();
+  sanitizedNameCache = /* @__PURE__ */ new Map();
+  typeResolutionCache = /* @__PURE__ */ new Map();
+  // Batch collection for AST operations
+  statements = [];
+  deferredTypes = /* @__PURE__ */ new Map();
   constructor(parser, project, config, outputRoot) {
     this.config = config;
     this.project = project;
@@ -636,45 +646,44 @@ var TypeGenerator = class {
         console.warn("No definitions found in swagger file");
         return;
       }
-      this.sourceFile.insertText(0, TYPE_GENERATOR_HEADER_COMMENT);
-      await Promise.all(Object.entries(definitions).map(([name, definition]) => this.generateInterface(name, definition)));
-      this.generateSdkTypes();
-      this.sourceFile.formatText();
-      this.sourceFile.saveSync();
+      this.collectAllTypeStructures(definitions);
+      this.collectSdkTypes();
+      this.applyBatchUpdates();
+      await this.finalize();
     } catch (error) {
       console.error("Error in generate():", error);
       throw new Error(`Failed to generate types: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
-  async generateInterface(name, definition) {
-    const interfaceName = this.pascalCaseForEnums(name);
-    if (this.generatedTypes.has(interfaceName)) {
-      return;
-    }
-    this.generatedTypes.add(interfaceName);
+  collectAllTypeStructures(definitions) {
+    Object.keys(definitions).forEach((name) => {
+      const interfaceName = this.getCachedPascalCase(name);
+      this.generatedTypes.add(interfaceName);
+    });
+    Object.entries(definitions).forEach(([name, definition]) => {
+      this.collectTypeStructure(name, definition);
+    });
+    this.deferredTypes.forEach((definition, name) => {
+      this.collectTypeStructure(name, definition);
+    });
+  }
+  collectTypeStructure(name, definition) {
+    const interfaceName = this.getCachedPascalCase(name) ?? "";
     if (definition.enum) {
-      this.generateEnum(interfaceName, definition);
-      return;
-    }
-    if (definition.allOf) {
-      this.generateCompositeType(interfaceName, definition);
-      return;
+      this.collectEnumStructure(interfaceName, definition);
+    } else if (definition.allOf) {
+      this.collectCompositeTypeStructure(interfaceName, definition);
+    } else {
+      this.collectInterfaceStructure(interfaceName, definition);
     }
-    const interfaceDeclaration = this.sourceFile.addInterface({
-      name: interfaceName,
-      isExported: true,
-      docs: definition.description ? [
-        definition.description
-      ] : void 0
-    });
-    this.addInterfaceProperties(interfaceDeclaration, definition);
   }
-  generateEnum(name, definition) {
+  collectEnumStructure(name, definition) {
     if (!definition.enum?.length) return;
     const isStringEnum = definition.enum.some((value) => typeof value === "string");
     if (isStringEnum) {
       const unionType = definition.enum.map((value) => typeof value === "string" ? `'${this.escapeString(value)}'` : String(value)).join(" | ");
-      this.sourceFile.addTypeAlias({
+      this.statements.push({
+        kind: import_ts_morph.StructureKind.TypeAlias,
         name,
         type: unionType,
         isExported: true,
@@ -682,53 +691,43 @@ var TypeGenerator = class {
           definition.description
         ] : void 0
       });
-    } else if (definition.description && this.config.options.generateEnumBasedOnDescription) {
-      const enumDeclaration = this.sourceFile.addEnum({
-        name,
-        isExported: true
-      });
-      try {
-        const enumValueObjects = JSON.parse(definition.description);
-        enumValueObjects.forEach((enumValueObject) => {
-          enumDeclaration.addMember({
-            name: enumValueObject.Name,
-            value: enumValueObject.Value
-          });
-        });
-      } catch (e) {
-        console.error(`Failed to parse enum description for ${name}`);
-        definition.enum.forEach((value) => {
-          const enumKey = this.toEnumKey(value);
-          enumDeclaration.addMember({
-            name: enumKey,
-            value
-          });
-        });
-      }
     } else {
-      const enumDeclaration = this.sourceFile.addEnum({
+      const members = this.buildEnumMembers(definition);
+      this.statements.push({
+        kind: import_ts_morph.StructureKind.Enum,
         name,
         isExported: true,
         docs: definition.description ? [
           definition.description
-        ] : void 0
-      });
-      definition.enum.forEach((value) => {
-        const enumKey = this.toEnumKey(value);
-        enumDeclaration.addMember({
-          name: enumKey,
-          value
-        });
+        ] : void 0,
+        members
       });
     }
   }
-  generateCompositeType(name, definition) {
+  buildEnumMembers(definition) {
+    if (definition.description && this.config.options.generateEnumBasedOnDescription) {
+      try {
+        const enumValueObjects = JSON.parse(definition.description);
+        return enumValueObjects.map((obj) => ({
+          name: obj.Name,
+          value: obj.Value
+        }));
+      } catch {
+      }
+    }
+    return definition.enum?.map((value) => ({
+      name: this.toEnumKey(value),
+      value
+    }));
+  }
+  collectCompositeTypeStructure(name, definition) {
     let typeExpression = "";
     if (definition.allOf) {
-      const types = definition.allOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown");
+      const types = definition.allOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown");
       typeExpression = types.length > 0 ? types.join(" & ") : "Record<string, unknown>";
     }
-    this.sourceFile.addTypeAlias({
+    this.statements.push({
+      kind: import_ts_morph.StructureKind.TypeAlias,
       name,
       type: typeExpression,
       isExported: true,
@@ -737,37 +736,29 @@ var TypeGenerator = class {
       ] : void 0
     });
   }
-  addInterfaceProperties(interfaceDeclaration, definition) {
-    if (!definition.properties && definition.additionalProperties === false) {
-      interfaceDeclaration.addIndexSignature({
-        keyName: "key",
-        keyType: "string",
-        returnType: "never"
-      });
-      return;
-    }
-    if (!definition.properties && definition.additionalProperties === true) {
-      interfaceDeclaration.addIndexSignature({
-        keyName: "key",
-        keyType: "string",
-        returnType: "any"
-      });
-      return;
-    }
+  collectInterfaceStructure(name, definition) {
+    const properties = this.buildInterfaceProperties(definition);
+    this.statements.push({
+      kind: import_ts_morph.StructureKind.Interface,
+      name,
+      isExported: true,
+      docs: definition.description ? [
+        definition.description
+      ] : void 0,
+      properties,
+      indexSignatures: this.buildIndexSignatures(definition)
+    });
+  }
+  buildInterfaceProperties(definition) {
     if (!definition.properties) {
-      interfaceDeclaration.addIndexSignature({
-        keyName: "key",
-        keyType: "string",
-        returnType: "unknown"
-      });
-      return;
+      return [];
     }
-    Object.entries(definition.properties).forEach(([propertyName, property]) => {
+    return Object.entries(definition.properties).map(([propertyName, property]) => {
       const isRequired = definition.required?.includes(propertyName) ?? false;
       const isReadOnly = property.readOnly;
-      const propertyType = this.resolveSwaggerType(property);
-      const sanitizedName = this.sanitizePropertyName(propertyName);
-      interfaceDeclaration.addProperty({
+      const propertyType = this.resolveSwaggerTypeCached(property);
+      const sanitizedName = this.getCachedSanitizedName(propertyName);
+      return {
         name: sanitizedName,
         type: propertyType,
         isReadonly: isReadOnly,
@@ -775,9 +766,48 @@ var TypeGenerator = class {
         docs: property.description ? [
           property.description
         ] : void 0
-      });
+      };
     });
   }
+  buildIndexSignatures(definition) {
+    if (!definition.properties && definition.additionalProperties === false) {
+      return [
+        {
+          keyName: "key",
+          keyType: "string",
+          returnType: "never"
+        }
+      ];
+    }
+    if (!definition.properties && definition.additionalProperties === true) {
+      return [
+        {
+          keyName: "key",
+          keyType: "string",
+          returnType: "any"
+        }
+      ];
+    }
+    if (!definition.properties) {
+      return [
+        {
+          keyName: "key",
+          keyType: "string",
+          returnType: "unknown"
+        }
+      ];
+    }
+    return [];
+  }
+  resolveSwaggerTypeCached(schema) {
+    const cacheKey = JSON.stringify(schema);
+    if (this.typeResolutionCache.has(cacheKey)) {
+      return this.typeResolutionCache.get(cacheKey);
+    }
+    const result = this.resolveSwaggerType(schema);
+    this.typeResolutionCache.set(cacheKey, result);
+    return result;
+  }
   resolveSwaggerType(schema) {
     if (schema.$ref) {
       return this.resolveReference(schema.$ref);
@@ -786,13 +816,13 @@ var TypeGenerator = class {
       return schema.enum.map((value) => typeof value === "string" ? `'${this.escapeString(value)}'` : String(value)).join(" | ");
     }
     if (schema.allOf) {
-      return schema.allOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown").join(" & ") || "Record";
+      return schema.allOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown").join(" & ") || "Record<string, unknown>";
     }
     if (schema.oneOf) {
-      return schema.oneOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
+      return schema.oneOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
     }
     if (schema.anyOf) {
-      return schema.anyOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
+      return schema.anyOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
     }
     if (schema.type === "array") {
       const itemType = schema.items ? this.getArrayItemType(schema.items) : "unknown";
@@ -803,7 +833,7 @@ var TypeGenerator = class {
         return this.generateInlineObjectType(schema);
       }
       if (schema.additionalProperties) {
-        const valueType = typeof schema.additionalProperties === "object" ? this.resolveSwaggerType(schema.additionalProperties) : "unknown";
+        const valueType = typeof schema.additionalProperties === "object" ? this.resolveSwaggerTypeCached(schema.additionalProperties) : "unknown";
         return `Record<string, ${valueType}>`;
       }
       return "Record<string, unknown>";
@@ -813,7 +843,7 @@ var TypeGenerator = class {
   generateInlineObjectType(definition) {
     if (!definition.properties) {
       if (definition.additionalProperties) {
-        const additionalType = typeof definition.additionalProperties === "object" ? this.resolveSwaggerType(definition.additionalProperties) : "unknown";
+        const additionalType = typeof definition.additionalProperties === "object" ? this.resolveSwaggerTypeCached(definition.additionalProperties) : "unknown";
         return `Record<string, ${additionalType}>`;
       }
       return "Record<string, unknown>";
@@ -821,29 +851,101 @@ var TypeGenerator = class {
     const properties = Object.entries(definition.properties).map(([key, prop]) => {
       const isRequired = definition.required?.includes(key) ?? false;
       const questionMark = isRequired ? "" : "?";
-      const sanitizedKey = this.sanitizePropertyName(key);
-      return `${sanitizedKey}${questionMark}: ${this.resolveSwaggerType(prop)}`;
+      const sanitizedKey = this.getCachedSanitizedName(key);
+      return `${sanitizedKey}${questionMark}: ${this.resolveSwaggerTypeCached(prop)}`;
     }).join("; ");
     return `{ ${properties} }`;
   }
   resolveReference(ref) {
-    try {
-      const refDefinition = this.parser.resolveReference(ref);
-      const refName = ref.split("/").pop();
-      if (!refName) {
-        console.warn(`Invalid reference format: ${ref}`);
-        return "unknown";
+    const refName = ref.split("/").pop();
+    if (!refName) {
+      console.warn(`Invalid reference format: ${ref}`);
+      return "unknown";
+    }
+    return this.getCachedPascalCase(refName);
+  }
+  collectSdkTypes() {
+    const { response } = this.config.options.validation ?? {};
+    const typeParameters = [
+      "TResponseType extends 'arraybuffer' | 'blob' | 'json' | 'text'"
+    ];
+    const properties = [
+      {
+        name: "headers",
+        type: "HttpHeaders",
+        hasQuestionToken: true
+      },
+      {
+        name: "reportProgress",
+        type: "boolean",
+        hasQuestionToken: true
+      },
+      {
+        name: "responseType",
+        type: "TResponseType",
+        hasQuestionToken: true
+      },
+      {
+        name: "withCredentials",
+        type: "boolean",
+        hasQuestionToken: true
+      },
+      {
+        name: "context",
+        type: "HttpContext",
+        hasQuestionToken: true
       }
-      const typeName = this.pascalCaseForEnums(refName);
-      if (refDefinition && !this.generatedTypes.has(typeName)) {
-        this.generateInterface(refName, refDefinition);
+    ];
+    if (response) {
+      properties.push({
+        name: "parse",
+        type: "(response: unknown) => TReturnType",
+        hasQuestionToken: true
+      });
+      typeParameters.push("TReturnType");
+    }
+    this.statements.push({
+      kind: import_ts_morph.StructureKind.Interface,
+      name: "RequestOptions",
+      isExported: true,
+      typeParameters,
+      properties,
+      docs: [
+        "Request Options for Angular HttpClient requests"
+      ]
+    });
+  }
+  applyBatchUpdates() {
+    this.sourceFile.insertText(0, TYPE_GENERATOR_HEADER_COMMENT);
+    this.sourceFile.addImportDeclarations([
+      {
+        namedImports: [
+          "HttpContext",
+          "HttpHeaders"
+        ],
+        moduleSpecifier: "@angular/common/http"
       }
-      return typeName;
-    } catch (error) {
-      console.warn(`Failed to resolve reference ${ref}:`, error);
-      return "unknown";
+    ]);
+    this.sourceFile.addStatements(this.statements);
+  }
+  async finalize() {
+    this.sourceFile.formatText();
+    await this.sourceFile.save();
+  }
+  // Cached helper methods
+  getCachedPascalCase(str) {
+    if (!this.pascalCaseCache.has(str)) {
+      this.pascalCaseCache.set(str, this.pascalCaseForEnums(str));
+    }
+    return this.pascalCaseCache.get(str);
+  }
+  getCachedSanitizedName(name) {
+    if (!this.sanitizedNameCache.has(name)) {
+      this.sanitizedNameCache.set(name, this.sanitizePropertyName(name));
     }
+    return this.sanitizedNameCache.get(name);
   }
+  // Original helper methods
   mapSwaggerTypeToTypeScript(type, format, isNullable) {
     if (!type) return "unknown";
     switch (type) {
@@ -890,78 +992,19 @@ var TypeGenerator = class {
   }
   getArrayItemType(items) {
     if (Array.isArray(items)) {
-      const types = items.map((item) => this.resolveSwaggerType(item));
+      const types = items.map((item) => this.resolveSwaggerTypeCached(item));
       return `[${types.join(", ")}]`;
     } else {
-      return this.resolveSwaggerType(items);
+      return this.resolveSwaggerTypeCached(items);
     }
   }
   escapeString(str) {
     return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   }
-  generateSdkTypes() {
-    this.sourceFile.addImportDeclarations([
-      {
-        namedImports: [
-          "HttpContext",
-          "HttpHeaders"
-        ],
-        moduleSpecifier: "@angular/common/http"
-      }
-    ]);
-    const { response } = this.config.options.validation ?? {};
-    const typeParameters = [
-      "TResponseType extends 'arraybuffer' | 'blob' | 'json' | 'text'"
-    ];
-    const properties = [
-      {
-        name: "headers",
-        type: "HttpHeaders",
-        hasQuestionToken: true
-      },
-      {
-        name: "reportProgress",
-        type: "boolean",
-        hasQuestionToken: true
-      },
-      {
-        name: "responseType",
-        type: "TResponseType",
-        hasQuestionToken: true
-      },
-      {
-        name: "withCredentials",
-        type: "boolean",
-        hasQuestionToken: true
-      },
-      {
-        name: "context",
-        type: "HttpContext",
-        hasQuestionToken: true
-      }
-    ];
-    if (response) {
-      properties.push({
-        name: "parse",
-        type: "(response: unknown) => TReturnType",
-        hasQuestionToken: true
-      });
-      typeParameters.push("TReturnType");
-    }
-    this.sourceFile.addInterface({
-      name: "RequestOptions",
-      isExported: true,
-      typeParameters,
-      properties,
-      docs: [
-        "Request Options for Angular HttpClient requests"
-      ]
-    });
-  }
 };
 
 // src/lib/generators/utility/token.generator.ts
-var import_ts_morph = require("ts-morph");
+var import_ts_morph2 = require("ts-morph");
 var path2 = __toESM(require("path"));
 var TokenGenerator = class {
   static {
@@ -997,7 +1040,7 @@ var TokenGenerator = class {
     const clientContextTokenName = this.getClientContextTokenName();
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
       declarations: [
         {
           name: basePathTokenName,
@@ -1014,7 +1057,7 @@ var TokenGenerator = class {
     });
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
       declarations: [
         {
           name: interceptorsTokenName,
@@ -1031,7 +1074,7 @@ var TokenGenerator = class {
     });
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
       declarations: [
         {
           name: clientContextTokenName,
@@ -1046,7 +1089,7 @@ var TokenGenerator = class {
     if (this.clientName === "default") {
       sourceFile.addVariableStatement({
         isExported: true,
-        declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+        declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
         declarations: [
           {
             name: "BASE_PATH",
@@ -1060,7 +1103,7 @@ var TokenGenerator = class {
       });
       sourceFile.addVariableStatement({
         isExported: true,
-        declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+        declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
         declarations: [
           {
             name: "CLIENT_CONTEXT_TOKEN",
@@ -1233,7 +1276,7 @@ var FileDownloadGenerator = class {
 };
 
 // src/lib/generators/utility/date-transformer.generator.ts
-var import_ts_morph2 = require("ts-morph");
+var import_ts_morph3 = require("ts-morph");
 var path4 = __toESM(require("path"));
 var DateTransformerGenerator = class {
   static {
@@ -1279,7 +1322,7 @@ var DateTransformerGenerator = class {
     });
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph3.VariableDeclarationKind.Const,
       declarations: [
         {
           name: "ISO_DATE_REGEX",
@@ -1621,7 +1664,7 @@ return makeEnvironmentProviders(providers);`;
 };
 
 // src/lib/generators/utility/base-interceptor.generator.ts
-var import_ts_morph3 = require("ts-morph");
+var import_ts_morph4 = require("ts-morph");
 var path7 = __toESM(require("path"));
 var BaseInterceptorGenerator = class {
   static {
@@ -1690,14 +1733,14 @@ var BaseInterceptorGenerator = class {
         {
           name: "httpInterceptors",
           type: "HttpInterceptor[]",
-          scope: import_ts_morph3.Scope.Private,
+          scope: import_ts_morph4.Scope.Private,
           isReadonly: true,
           initializer: `inject(${interceptorsTokenName})`
         },
         {
           name: "clientContextToken",
           type: "HttpContextToken<string>",
-          scope: import_ts_morph3.Scope.Private,
+          scope: import_ts_morph4.Scope.Private,
           isReadonly: true,
           initializer: clientContextTokenName
         }
@@ -1754,7 +1797,7 @@ var BaseInterceptorGenerator = class {
 };
 
 // src/lib/generators/service/service.generator.ts
-var import_ts_morph4 = require("ts-morph");
+var import_ts_morph5 = require("ts-morph");
 var path8 = __toESM(require("path"));
 
 // src/lib/generators/service/service-method/service-method-body.generator.ts
@@ -2331,27 +2374,27 @@ var ServiceGenerator = class {
     serviceClass.addProperty({
       name: "httpClient",
       type: "HttpClient",
-      scope: import_ts_morph4.Scope.Private,
+      scope: import_ts_morph5.Scope.Private,
       isReadonly: true,
       initializer: "inject(HttpClient)"
     });
     serviceClass.addProperty({
       name: "basePath",
       type: "string",
-      scope: import_ts_morph4.Scope.Private,
+      scope: import_ts_morph5.Scope.Private,
       isReadonly: true,
       initializer: `inject(${basePathTokenName})`
     });
     serviceClass.addProperty({
       name: "clientContextToken",
       type: "HttpContextToken<string>",
-      scope: import_ts_morph4.Scope.Private,
+      scope: import_ts_morph5.Scope.Private,
       isReadonly: true,
       initializer: clientContextTokenName
     });
     serviceClass.addMethod({
       name: "createContextWithClientId",
-      scope: import_ts_morph4.Scope.Private,
+      scope: import_ts_morph5.Scope.Private,
       parameters: [
         {
           name: "existingContext",
@@ -2436,11 +2479,11 @@ async function generateFromConfig(config) {
     });
   }
   try {
-    const project = new import_ts_morph5.Project({
+    const project = new import_ts_morph6.Project({
       compilerOptions: {
         declaration: true,
-        target: import_ts_morph5.ScriptTarget.ES2022,
-        module: import_ts_morph5.ModuleKind.Preserve,
+        target: import_ts_morph6.ScriptTarget.ES2022,
+        module: import_ts_morph6.ModuleKind.Preserve,
         strict: true,
         ...config.compilerOptions
       }

package/index.js

@@ -105,7 +105,10 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/core/generator.ts
-var import_ts_morph5 = require("ts-morph");
+var import_ts_morph6 = require("ts-morph");
+
+// src/lib/generators/type/type.generator.ts
+var import_ts_morph = require("ts-morph");
 
 // ../shared/src/utils/string.utils.ts
 function camelCase(str) {
@@ -723,6 +726,13 @@ var _TypeGenerator = class _TypeGenerator {
     __publicField(this, "sourceFile");
     __publicField(this, "generatedTypes", /* @__PURE__ */ new Set());
     __publicField(this, "config");
+    // Performance caches
+    __publicField(this, "pascalCaseCache", /* @__PURE__ */ new Map());
+    __publicField(this, "sanitizedNameCache", /* @__PURE__ */ new Map());
+    __publicField(this, "typeResolutionCache", /* @__PURE__ */ new Map());
+    // Batch collection for AST operations
+    __publicField(this, "statements", []);
+    __publicField(this, "deferredTypes", /* @__PURE__ */ new Map());
     this.config = config;
     this.project = project;
     this.parser = parser;
@@ -739,49 +749,47 @@ var _TypeGenerator = class _TypeGenerator {
           console.warn("No definitions found in swagger file");
           return;
         }
-        this.sourceFile.insertText(0, TYPE_GENERATOR_HEADER_COMMENT);
-        yield Promise.all(Object.entries(definitions).map(([name, definition]) => this.generateInterface(name, definition)));
-        this.generateSdkTypes();
-        this.sourceFile.formatText();
-        this.sourceFile.saveSync();
+        this.collectAllTypeStructures(definitions);
+        this.collectSdkTypes();
+        this.applyBatchUpdates();
+        yield this.finalize();
       } catch (error) {
         console.error("Error in generate():", error);
         throw new Error(`Failed to generate types: ${error instanceof Error ? error.message : "Unknown error"}`);
       }
     });
   }
-  generateInterface(name, definition) {
-    return __async(this, null, function* () {
-      const interfaceName = this.pascalCaseForEnums(name);
-      if (this.generatedTypes.has(interfaceName)) {
-        return;
-      }
+  collectAllTypeStructures(definitions) {
+    Object.keys(definitions).forEach((name) => {
+      const interfaceName = this.getCachedPascalCase(name);
       this.generatedTypes.add(interfaceName);
-      if (definition.enum) {
-        this.generateEnum(interfaceName, definition);
-        return;
-      }
-      if (definition.allOf) {
-        this.generateCompositeType(interfaceName, definition);
-        return;
-      }
-      const interfaceDeclaration = this.sourceFile.addInterface({
-        name: interfaceName,
-        isExported: true,
-        docs: definition.description ? [
-          definition.description
-        ] : void 0
-      });
-      this.addInterfaceProperties(interfaceDeclaration, definition);
+    });
+    Object.entries(definitions).forEach(([name, definition]) => {
+      this.collectTypeStructure(name, definition);
+    });
+    this.deferredTypes.forEach((definition, name) => {
+      this.collectTypeStructure(name, definition);
     });
   }
-  generateEnum(name, definition) {
+  collectTypeStructure(name, definition) {
+    var _a;
+    const interfaceName = (_a = this.getCachedPascalCase(name)) != null ? _a : "";
+    if (definition.enum) {
+      this.collectEnumStructure(interfaceName, definition);
+    } else if (definition.allOf) {
+      this.collectCompositeTypeStructure(interfaceName, definition);
+    } else {
+      this.collectInterfaceStructure(interfaceName, definition);
+    }
+  }
+  collectEnumStructure(name, definition) {
     var _a;
     if (!((_a = definition.enum) == null ? void 0 : _a.length)) return;
     const isStringEnum = definition.enum.some((value) => typeof value === "string");
     if (isStringEnum) {
       const unionType = definition.enum.map((value) => typeof value === "string" ? `'${this.escapeString(value)}'` : String(value)).join(" | ");
-      this.sourceFile.addTypeAlias({
+      this.statements.push({
+        kind: import_ts_morph.StructureKind.TypeAlias,
         name,
         type: unionType,
         isExported: true,
@@ -789,53 +797,44 @@ var _TypeGenerator = class _TypeGenerator {
           definition.description
         ] : void 0
       });
-    } else if (definition.description && this.config.options.generateEnumBasedOnDescription) {
-      const enumDeclaration = this.sourceFile.addEnum({
-        name,
-        isExported: true
-      });
-      try {
-        const enumValueObjects = JSON.parse(definition.description);
-        enumValueObjects.forEach((enumValueObject) => {
-          enumDeclaration.addMember({
-            name: enumValueObject.Name,
-            value: enumValueObject.Value
-          });
-        });
-      } catch (e) {
-        console.error(`Failed to parse enum description for ${name}`);
-        definition.enum.forEach((value) => {
-          const enumKey = this.toEnumKey(value);
-          enumDeclaration.addMember({
-            name: enumKey,
-            value
-          });
-        });
-      }
     } else {
-      const enumDeclaration = this.sourceFile.addEnum({
+      const members = this.buildEnumMembers(definition);
+      this.statements.push({
+        kind: import_ts_morph.StructureKind.Enum,
         name,
         isExported: true,
         docs: definition.description ? [
           definition.description
-        ] : void 0
-      });
-      definition.enum.forEach((value) => {
-        const enumKey = this.toEnumKey(value);
-        enumDeclaration.addMember({
-          name: enumKey,
-          value
-        });
+        ] : void 0,
+        members
       });
     }
   }
-  generateCompositeType(name, definition) {
+  buildEnumMembers(definition) {
+    var _a;
+    if (definition.description && this.config.options.generateEnumBasedOnDescription) {
+      try {
+        const enumValueObjects = JSON.parse(definition.description);
+        return enumValueObjects.map((obj) => ({
+          name: obj.Name,
+          value: obj.Value
+        }));
+      } catch (e) {
+      }
+    }
+    return (_a = definition.enum) == null ? void 0 : _a.map((value) => ({
+      name: this.toEnumKey(value),
+      value
+    }));
+  }
+  collectCompositeTypeStructure(name, definition) {
     let typeExpression = "";
     if (definition.allOf) {
-      const types = definition.allOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown");
+      const types = definition.allOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown");
       typeExpression = types.length > 0 ? types.join(" & ") : "Record<string, unknown>";
     }
-    this.sourceFile.addTypeAlias({
+    this.statements.push({
+      kind: import_ts_morph.StructureKind.TypeAlias,
       name,
       type: typeExpression,
       isExported: true,
@@ -844,38 +843,30 @@ var _TypeGenerator = class _TypeGenerator {
       ] : void 0
     });
   }
-  addInterfaceProperties(interfaceDeclaration, definition) {
-    if (!definition.properties && definition.additionalProperties === false) {
-      interfaceDeclaration.addIndexSignature({
-        keyName: "key",
-        keyType: "string",
-        returnType: "never"
-      });
-      return;
-    }
-    if (!definition.properties && definition.additionalProperties === true) {
-      interfaceDeclaration.addIndexSignature({
-        keyName: "key",
-        keyType: "string",
-        returnType: "any"
-      });
-      return;
-    }
+  collectInterfaceStructure(name, definition) {
+    const properties = this.buildInterfaceProperties(definition);
+    this.statements.push({
+      kind: import_ts_morph.StructureKind.Interface,
+      name,
+      isExported: true,
+      docs: definition.description ? [
+        definition.description
+      ] : void 0,
+      properties,
+      indexSignatures: this.buildIndexSignatures(definition)
+    });
+  }
+  buildInterfaceProperties(definition) {
     if (!definition.properties) {
-      interfaceDeclaration.addIndexSignature({
-        keyName: "key",
-        keyType: "string",
-        returnType: "unknown"
-      });
-      return;
+      return [];
     }
-    Object.entries(definition.properties).forEach(([propertyName, property]) => {
+    return Object.entries(definition.properties).map(([propertyName, property]) => {
       var _a, _b;
       const isRequired = (_b = (_a = definition.required) == null ? void 0 : _a.includes(propertyName)) != null ? _b : false;
       const isReadOnly = property.readOnly;
-      const propertyType = this.resolveSwaggerType(property);
-      const sanitizedName = this.sanitizePropertyName(propertyName);
-      interfaceDeclaration.addProperty({
+      const propertyType = this.resolveSwaggerTypeCached(property);
+      const sanitizedName = this.getCachedSanitizedName(propertyName);
+      return {
         name: sanitizedName,
         type: propertyType,
         isReadonly: isReadOnly,
@@ -883,9 +874,48 @@ var _TypeGenerator = class _TypeGenerator {
         docs: property.description ? [
           property.description
         ] : void 0
-      });
+      };
     });
   }
+  buildIndexSignatures(definition) {
+    if (!definition.properties && definition.additionalProperties === false) {
+      return [
+        {
+          keyName: "key",
+          keyType: "string",
+          returnType: "never"
+        }
+      ];
+    }
+    if (!definition.properties && definition.additionalProperties === true) {
+      return [
+        {
+          keyName: "key",
+          keyType: "string",
+          returnType: "any"
+        }
+      ];
+    }
+    if (!definition.properties) {
+      return [
+        {
+          keyName: "key",
+          keyType: "string",
+          returnType: "unknown"
+        }
+      ];
+    }
+    return [];
+  }
+  resolveSwaggerTypeCached(schema) {
+    const cacheKey = JSON.stringify(schema);
+    if (this.typeResolutionCache.has(cacheKey)) {
+      return this.typeResolutionCache.get(cacheKey);
+    }
+    const result = this.resolveSwaggerType(schema);
+    this.typeResolutionCache.set(cacheKey, result);
+    return result;
+  }
   resolveSwaggerType(schema) {
     if (schema.$ref) {
       return this.resolveReference(schema.$ref);
@@ -894,13 +924,13 @@ var _TypeGenerator = class _TypeGenerator {
       return schema.enum.map((value) => typeof value === "string" ? `'${this.escapeString(value)}'` : String(value)).join(" | ");
     }
     if (schema.allOf) {
-      return schema.allOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown").join(" & ") || "Record";
+      return schema.allOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown").join(" & ") || "Record<string, unknown>";
     }
     if (schema.oneOf) {
-      return schema.oneOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
+      return schema.oneOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
     }
     if (schema.anyOf) {
-      return schema.anyOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
+      return schema.anyOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
     }
     if (schema.type === "array") {
       const itemType = schema.items ? this.getArrayItemType(schema.items) : "unknown";
@@ -911,7 +941,7 @@ var _TypeGenerator = class _TypeGenerator {
         return this.generateInlineObjectType(schema);
       }
       if (schema.additionalProperties) {
-        const valueType = typeof schema.additionalProperties === "object" ? this.resolveSwaggerType(schema.additionalProperties) : "unknown";
+        const valueType = typeof schema.additionalProperties === "object" ? this.resolveSwaggerTypeCached(schema.additionalProperties) : "unknown";
         return `Record<string, ${valueType}>`;
       }
       return "Record<string, unknown>";
@@ -921,7 +951,7 @@ var _TypeGenerator = class _TypeGenerator {
   generateInlineObjectType(definition) {
     if (!definition.properties) {
       if (definition.additionalProperties) {
-        const additionalType = typeof definition.additionalProperties === "object" ? this.resolveSwaggerType(definition.additionalProperties) : "unknown";
+        const additionalType = typeof definition.additionalProperties === "object" ? this.resolveSwaggerTypeCached(definition.additionalProperties) : "unknown";
         return `Record<string, ${additionalType}>`;
       }
       return "Record<string, unknown>";
@@ -930,29 +960,104 @@ var _TypeGenerator = class _TypeGenerator {
       var _a, _b;
       const isRequired = (_b = (_a = definition.required) == null ? void 0 : _a.includes(key)) != null ? _b : false;
       const questionMark = isRequired ? "" : "?";
-      const sanitizedKey = this.sanitizePropertyName(key);
-      return `${sanitizedKey}${questionMark}: ${this.resolveSwaggerType(prop)}`;
+      const sanitizedKey = this.getCachedSanitizedName(key);
+      return `${sanitizedKey}${questionMark}: ${this.resolveSwaggerTypeCached(prop)}`;
     }).join("; ");
     return `{ ${properties} }`;
   }
   resolveReference(ref) {
-    try {
-      const refDefinition = this.parser.resolveReference(ref);
-      const refName = ref.split("/").pop();
-      if (!refName) {
-        console.warn(`Invalid reference format: ${ref}`);
-        return "unknown";
+    const refName = ref.split("/").pop();
+    if (!refName) {
+      console.warn(`Invalid reference format: ${ref}`);
+      return "unknown";
+    }
+    return this.getCachedPascalCase(refName);
+  }
+  collectSdkTypes() {
+    var _a;
+    const { response } = (_a = this.config.options.validation) != null ? _a : {};
+    const typeParameters = [
+      "TResponseType extends 'arraybuffer' | 'blob' | 'json' | 'text'"
+    ];
+    const properties = [
+      {
+        name: "headers",
+        type: "HttpHeaders",
+        hasQuestionToken: true
+      },
+      {
+        name: "reportProgress",
+        type: "boolean",
+        hasQuestionToken: true
+      },
+      {
+        name: "responseType",
+        type: "TResponseType",
+        hasQuestionToken: true
+      },
+      {
+        name: "withCredentials",
+        type: "boolean",
+        hasQuestionToken: true
+      },
+      {
+        name: "context",
+        type: "HttpContext",
+        hasQuestionToken: true
       }
-      const typeName = this.pascalCaseForEnums(refName);
-      if (refDefinition && !this.generatedTypes.has(typeName)) {
-        this.generateInterface(refName, refDefinition);
+    ];
+    if (response) {
+      properties.push({
+        name: "parse",
+        type: "(response: unknown) => TReturnType",
+        hasQuestionToken: true
+      });
+      typeParameters.push("TReturnType");
+    }
+    this.statements.push({
+      kind: import_ts_morph.StructureKind.Interface,
+      name: "RequestOptions",
+      isExported: true,
+      typeParameters,
+      properties,
+      docs: [
+        "Request Options for Angular HttpClient requests"
+      ]
+    });
+  }
+  applyBatchUpdates() {
+    this.sourceFile.insertText(0, TYPE_GENERATOR_HEADER_COMMENT);
+    this.sourceFile.addImportDeclarations([
+      {
+        namedImports: [
+          "HttpContext",
+          "HttpHeaders"
+        ],
+        moduleSpecifier: "@angular/common/http"
       }
-      return typeName;
-    } catch (error) {
-      console.warn(`Failed to resolve reference ${ref}:`, error);
-      return "unknown";
+    ]);
+    this.sourceFile.addStatements(this.statements);
+  }
+  finalize() {
+    return __async(this, null, function* () {
+      this.sourceFile.formatText();
+      yield this.sourceFile.save();
+    });
+  }
+  // Cached helper methods
+  getCachedPascalCase(str) {
+    if (!this.pascalCaseCache.has(str)) {
+      this.pascalCaseCache.set(str, this.pascalCaseForEnums(str));
     }
+    return this.pascalCaseCache.get(str);
   }
+  getCachedSanitizedName(name) {
+    if (!this.sanitizedNameCache.has(name)) {
+      this.sanitizedNameCache.set(name, this.sanitizePropertyName(name));
+    }
+    return this.sanitizedNameCache.get(name);
+  }
+  // Original helper methods
   mapSwaggerTypeToTypeScript(type, format, isNullable) {
     if (!type) return "unknown";
     switch (type) {
@@ -999,81 +1104,21 @@ var _TypeGenerator = class _TypeGenerator {
   }
   getArrayItemType(items) {
     if (Array.isArray(items)) {
-      const types = items.map((item) => this.resolveSwaggerType(item));
+      const types = items.map((item) => this.resolveSwaggerTypeCached(item));
       return `[${types.join(", ")}]`;
     } else {
-      return this.resolveSwaggerType(items);
+      return this.resolveSwaggerTypeCached(items);
     }
   }
   escapeString(str) {
     return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   }
-  generateSdkTypes() {
-    var _a;
-    this.sourceFile.addImportDeclarations([
-      {
-        namedImports: [
-          "HttpContext",
-          "HttpHeaders"
-        ],
-        moduleSpecifier: "@angular/common/http"
-      }
-    ]);
-    const { response } = (_a = this.config.options.validation) != null ? _a : {};
-    const typeParameters = [
-      "TResponseType extends 'arraybuffer' | 'blob' | 'json' | 'text'"
-    ];
-    const properties = [
-      {
-        name: "headers",
-        type: "HttpHeaders",
-        hasQuestionToken: true
-      },
-      {
-        name: "reportProgress",
-        type: "boolean",
-        hasQuestionToken: true
-      },
-      {
-        name: "responseType",
-        type: "TResponseType",
-        hasQuestionToken: true
-      },
-      {
-        name: "withCredentials",
-        type: "boolean",
-        hasQuestionToken: true
-      },
-      {
-        name: "context",
-        type: "HttpContext",
-        hasQuestionToken: true
-      }
-    ];
-    if (response) {
-      properties.push({
-        name: "parse",
-        type: "(response: unknown) => TReturnType",
-        hasQuestionToken: true
-      });
-      typeParameters.push("TReturnType");
-    }
-    this.sourceFile.addInterface({
-      name: "RequestOptions",
-      isExported: true,
-      typeParameters,
-      properties,
-      docs: [
-        "Request Options for Angular HttpClient requests"
-      ]
-    });
-  }
 };
 __name(_TypeGenerator, "TypeGenerator");
 var TypeGenerator = _TypeGenerator;
 
 // src/lib/generators/utility/token.generator.ts
-var import_ts_morph = require("ts-morph");
+var import_ts_morph2 = require("ts-morph");
 var path2 = __toESM(require("path"));
 var _TokenGenerator = class _TokenGenerator {
   constructor(project, clientName = "default") {
@@ -1106,7 +1151,7 @@ var _TokenGenerator = class _TokenGenerator {
     const clientContextTokenName = this.getClientContextTokenName();
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
       declarations: [
         {
           name: basePathTokenName,
@@ -1123,7 +1168,7 @@ var _TokenGenerator = class _TokenGenerator {
     });
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
       declarations: [
         {
           name: interceptorsTokenName,
@@ -1140,7 +1185,7 @@ var _TokenGenerator = class _TokenGenerator {
     });
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
       declarations: [
         {
           name: clientContextTokenName,
@@ -1155,7 +1200,7 @@ var _TokenGenerator = class _TokenGenerator {
     if (this.clientName === "default") {
       sourceFile.addVariableStatement({
         isExported: true,
-        declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+        declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
         declarations: [
           {
             name: "BASE_PATH",
@@ -1169,7 +1214,7 @@ var _TokenGenerator = class _TokenGenerator {
       });
       sourceFile.addVariableStatement({
         isExported: true,
-        declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+        declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
         declarations: [
           {
             name: "CLIENT_CONTEXT_TOKEN",
@@ -1343,7 +1388,7 @@ __name(_FileDownloadGenerator, "FileDownloadGenerator");
 var FileDownloadGenerator = _FileDownloadGenerator;
 
 // src/lib/generators/utility/date-transformer.generator.ts
-var import_ts_morph2 = require("ts-morph");
+var import_ts_morph3 = require("ts-morph");
 var path4 = __toESM(require("path"));
 var _DateTransformerGenerator = class _DateTransformerGenerator {
   constructor(project) {
@@ -1386,7 +1431,7 @@ var _DateTransformerGenerator = class _DateTransformerGenerator {
     });
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph3.VariableDeclarationKind.Const,
       declarations: [
         {
           name: "ISO_DATE_REGEX",
@@ -1728,7 +1773,7 @@ __name(_ProviderGenerator, "ProviderGenerator");
 var ProviderGenerator = _ProviderGenerator;
 
 // src/lib/generators/utility/base-interceptor.generator.ts
-var import_ts_morph3 = require("ts-morph");
+var import_ts_morph4 = require("ts-morph");
 var path7 = __toESM(require("path"));
 var _project, _clientName;
 var _BaseInterceptorGenerator = class _BaseInterceptorGenerator {
@@ -1795,14 +1840,14 @@ var _BaseInterceptorGenerator = class _BaseInterceptorGenerator {
         {
           name: "httpInterceptors",
           type: "HttpInterceptor[]",
-          scope: import_ts_morph3.Scope.Private,
+          scope: import_ts_morph4.Scope.Private,
           isReadonly: true,
           initializer: `inject(${interceptorsTokenName})`
         },
         {
           name: "clientContextToken",
           type: "HttpContextToken<string>",
-          scope: import_ts_morph3.Scope.Private,
+          scope: import_ts_morph4.Scope.Private,
           isReadonly: true,
           initializer: clientContextTokenName
         }
@@ -1863,7 +1908,7 @@ __name(_BaseInterceptorGenerator, "BaseInterceptorGenerator");
 var BaseInterceptorGenerator = _BaseInterceptorGenerator;
 
 // src/lib/generators/service/service.generator.ts
-var import_ts_morph4 = require("ts-morph");
+var import_ts_morph5 = require("ts-morph");
 var path8 = __toESM(require("path"));
 
 // src/lib/generators/service/service-method/service-method-body.generator.ts
@@ -2448,27 +2493,27 @@ var _ServiceGenerator = class _ServiceGenerator {
     serviceClass.addProperty({
       name: "httpClient",
       type: "HttpClient",
-      scope: import_ts_morph4.Scope.Private,
+      scope: import_ts_morph5.Scope.Private,
       isReadonly: true,
       initializer: "inject(HttpClient)"
     });
     serviceClass.addProperty({
       name: "basePath",
       type: "string",
-      scope: import_ts_morph4.Scope.Private,
+      scope: import_ts_morph5.Scope.Private,
       isReadonly: true,
       initializer: `inject(${basePathTokenName})`
     });
     serviceClass.addProperty({
       name: "clientContextToken",
       type: "HttpContextToken<string>",
-      scope: import_ts_morph4.Scope.Private,
+      scope: import_ts_morph5.Scope.Private,
       isReadonly: true,
       initializer: clientContextTokenName
     });
     serviceClass.addMethod({
       name: "createContextWithClientId",
-      scope: import_ts_morph4.Scope.Private,
+      scope: import_ts_morph5.Scope.Private,
       parameters: [
         {
           name: "existingContext",
@@ -2556,11 +2601,11 @@ function generateFromConfig(config) {
       });
     }
     try {
-      const project = new import_ts_morph5.Project({
+      const project = new import_ts_morph6.Project({
         compilerOptions: __spreadValues({
           declaration: true,
-          target: import_ts_morph5.ScriptTarget.ES2022,
-          module: import_ts_morph5.ModuleKind.Preserve,
+          target: import_ts_morph6.ScriptTarget.ES2022,
+          module: import_ts_morph6.ModuleKind.Preserve,
           strict: true
         }, config.compilerOptions)
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-openapi",
-  "version": "0.1.10",
+  "version": "0.1.11-beta.0",
   "description": "Generate Angular services and TypeScript types from OpenAPI/Swagger specifications",
   "keywords": [
     "ng-openapi",