ng-openapi 0.1.9 → 0.1.11-beta.0

package/cli.cjs

@@ -24,10 +24,27 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../shared/src/utils/functions/is-url.ts
+function isUrl(input) {
+  try {
+    const url = new URL(input);
+    return [
+      "http:",
+      "https:"
+    ].includes(url.protocol);
+  } catch {
+    return false;
+  }
+}
+__name(isUrl, "isUrl");
+
 // src/lib/cli.ts
 var import_commander = require("commander");
-var path11 = __toESM(require("path"));
 var fs4 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+
+// package.json
+var version = "0.1.10";
 
 // src/lib/core/generator.ts
 var import_ts_morph6 = require("ts-morph");
@@ -37,12 +54,11 @@ var import_ts_morph = require("ts-morph");
 
 // ../shared/src/utils/string.utils.ts
 function camelCase(str) {
-  const cleaned = str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
-  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+  return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toLowerCase());
 }
 __name(camelCase, "camelCase");
 function pascalCase(str) {
-  return str.replace(/(?:^|[-_])([a-z])/g, (_, char) => char.toUpperCase());
+  return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toUpperCase());
 }
 __name(pascalCase, "pascalCase");
 
@@ -366,6 +382,12 @@ function inferResponseTypeFromContentType(contentType) {
 __name(inferResponseTypeFromContentType, "inferResponseTypeFromContentType");
 function getResponseType(response, config) {
   const responseType = getResponseTypeFromResponse(response);
+  const content = response.content || {};
+  for (const [contentType, mediaType] of Object.entries(content)) {
+    if (mediaType?.schema) {
+      return getTypeScriptType(mediaType.schema, config, mediaType.schema.nullable);
+    }
+  }
   switch (responseType) {
     case "blob":
       return "Blob";
@@ -373,15 +395,6 @@ function getResponseType(response, config) {
       return "ArrayBuffer";
     case "text":
       return "string";
-    case "json": {
-      const content = response.content || {};
-      for (const [contentType, mediaType] of Object.entries(content)) {
-        if (inferResponseTypeFromContentType(contentType) === "json" && mediaType?.schema) {
-          return getTypeScriptType(mediaType.schema, config, mediaType.schema.nullable);
-        }
-      }
-      return "any";
-    }
     default:
       return "any";
   }
@@ -455,22 +468,6 @@ var BASE_INTERCEPTOR_HEADER_COMMENT = /* @__PURE__ */ __name((clientName) => def
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var yaml = __toESM(require("js-yaml"));
-
-// ../shared/src/utils/functions/is-url.ts
-function isUrl(input) {
-  try {
-    const url = new URL(input);
-    return [
-      "http:",
-      "https:"
-    ].includes(url.protocol);
-  } catch {
-    return false;
-  }
-}
-__name(isUrl, "isUrl");
-
-// ../shared/src/core/swagger-parser.ts
 var SwaggerParser = class _SwaggerParser {
   static {
     __name(this, "SwaggerParser");
@@ -617,7 +614,7 @@ var SwaggerParser = class _SwaggerParser {
 };
 
 // src/lib/generators/type/type.generator.ts
-var TypeGenerator = class _TypeGenerator {
+var TypeGenerator = class {
   static {
     __name(this, "TypeGenerator");
   }
@@ -626,75 +623,67 @@ var TypeGenerator = class _TypeGenerator {
   sourceFile;
   generatedTypes = /* @__PURE__ */ new Set();
   config;
-  constructor(parser, outputRoot, 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;
-    const outputPath = outputRoot + "/models/index.ts";
-    this.project = new import_ts_morph.Project({
-      compilerOptions: {
-        declaration: true,
-        target: import_ts_morph.ScriptTarget.ES2022,
-        module: import_ts_morph.ModuleKind.Preserve,
-        strict: true,
-        ...this.config.compilerOptions
-      }
-    });
+    this.project = project;
     this.parser = parser;
+    const outputPath = outputRoot + "/models/index.ts";
     this.sourceFile = this.project.createSourceFile(outputPath, "", {
       overwrite: true
     });
   }
-  static async create(swaggerPathOrUrl, outputRoot, config) {
-    const parser = await SwaggerParser.create(swaggerPathOrUrl, config);
-    return new _TypeGenerator(parser, outputRoot, config);
-  }
-  generate() {
+  async generate() {
     try {
       const definitions = this.parser.getDefinitions();
       if (!definitions || Object.keys(definitions).length === 0) {
         console.warn("No definitions found in swagger file");
         return;
       }
-      this.sourceFile.insertText(0, TYPE_GENERATOR_HEADER_COMMENT);
-      Object.entries(definitions).forEach(([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"}`);
     }
   }
-  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,
@@ -702,53 +691,43 @@ 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) {
+    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,
@@ -757,33 +736,29 @@ 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) {
-      console.warn(`No properties found for interface ${interfaceDeclaration.getName()}`);
-      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,
@@ -791,9 +766,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);
@@ -802,13 +816,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";
@@ -819,7 +833,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>";
@@ -829,7 +843,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>";
@@ -837,29 +851,101 @@ var TypeGenerator = class _TypeGenerator {
     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) {
@@ -906,74 +992,15 @@ 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() {
-    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
@@ -2187,7 +2214,10 @@ var ServiceMethodGenerator = class {
       parameters,
       returnType,
       statements: methodBody,
-      overloads: methodOverLoads
+      overloads: methodOverLoads,
+      docs: operation.description ? [
+        operation.description
+      ] : void 0
     });
   }
   generateMethodName(operation) {
@@ -2207,15 +2237,17 @@ var ServiceMethodGenerator = class {
     if (operation.operationId) {
       return camelCase(operation.operationId);
     }
-    const method = operation.method.toLowerCase();
-    const pathParts = operation.path.split("/").filter((p) => p && !p.startsWith("{"));
-    const resource = pathParts[pathParts.length - 1] || "resource";
-    return `${method}${pascalCase(resource)}`;
+    const method = pascalCase(operation.method.toLowerCase());
+    const pathParts = operation.path.split("/").map((str) => {
+      return pascalCase(pascalCase(str).replace(/[^a-zA-Z0-9]/g, ""));
+    });
+    const resource = pathParts.join("") || "resource";
+    return `${camelCase(resource)}${method}`;
   }
 };
 
 // src/lib/generators/service/service.generator.ts
-var ServiceGenerator = class _ServiceGenerator {
+var ServiceGenerator = class {
   static {
     __name(this, "ServiceGenerator");
   }
@@ -2235,11 +2267,7 @@ var ServiceGenerator = class _ServiceGenerator {
     }
     this.methodGenerator = new ServiceMethodGenerator(config);
   }
-  static async create(swaggerPathOrUrl, project, config) {
-    const parser = await SwaggerParser.create(swaggerPathOrUrl, config);
-    return new _ServiceGenerator(parser, project, config);
-  }
-  generate(outputRoot) {
+  async generate(outputRoot) {
     const outputDir = path8.join(outputRoot, "services");
     const paths = extractPaths(this.spec.paths);
     if (paths.length === 0) {
@@ -2247,9 +2275,7 @@ var ServiceGenerator = class _ServiceGenerator {
       return;
     }
     const controllerGroups = this.groupPathsByController(paths);
-    Object.entries(controllerGroups).forEach(([controllerName, operations]) => {
-      this.generateServiceFile(controllerName, operations, outputDir);
-    });
+    await Promise.all(Object.entries(controllerGroups).map(([controllerName, operations]) => this.generateServiceFile(controllerName, operations, outputDir)));
   }
   groupPathsByController(paths) {
     const groups = {};
@@ -2271,7 +2297,7 @@ var ServiceGenerator = class _ServiceGenerator {
     });
     return groups;
   }
-  generateServiceFile(controllerName, operations, outputDir) {
+  async generateServiceFile(controllerName, operations, outputDir) {
     const fileName = `${camelCase(controllerName)}.service.ts`;
     const filePath = path8.join(outputDir, fileName);
     const sourceFile = this.project.createSourceFile(filePath, "", {
@@ -2463,8 +2489,9 @@ async function generateFromConfig(config) {
       }
     });
     console.log(`\u{1F4E1} Processing OpenAPI specification from ${inputType}: ${config.input}`);
-    const typeGenerator = await TypeGenerator.create(config.input, outputPath, config);
-    typeGenerator.generate();
+    const swaggerParser = await SwaggerParser.create(config.input, config);
+    const typeGenerator = new TypeGenerator(swaggerParser, project, config, outputPath);
+    await typeGenerator.generate();
     console.log(`\u2705 TypeScript interfaces generated`);
     if (generateServices) {
       const tokenGenerator = new TokenGenerator(project, config.clientName);
@@ -2475,8 +2502,8 @@ async function generateFromConfig(config) {
       }
       const fileDownloadHelper = new FileDownloadGenerator(project);
       fileDownloadHelper.generate(outputPath);
-      const serviceGenerator = await ServiceGenerator.create(config.input, project, config);
-      serviceGenerator.generate(outputPath);
+      const serviceGenerator = new ServiceGenerator(swaggerParser, project, config);
+      await serviceGenerator.generate(outputPath);
       const indexGenerator = new ServiceIndexGenerator(project);
       indexGenerator.generateIndex(outputPath);
       console.log(`\u2705 Angular services generated`);
@@ -2487,9 +2514,9 @@ async function generateFromConfig(config) {
     }
     if (config.plugins?.length) {
       for (const plugin of config.plugins) {
-        const PluginClass = plugin;
-        const pluginGenerator = await PluginClass.create(config.input, project, config);
-        pluginGenerator.generate(outputPath);
+        const generatorClass = plugin;
+        const pluginGenerator = new generatorClass(swaggerParser, project, config);
+        await pluginGenerator.generate(outputPath);
       }
       console.log(`\u2705 Plugins are generated`);
     }
@@ -2516,9 +2543,6 @@ async function generateFromConfig(config) {
 }
 __name(generateFromConfig, "generateFromConfig");
 
-// package.json
-var version = "0.1.8";
-
 // src/lib/cli.ts
 var program = new import_commander.Command();
 async function loadConfigFile(configPath) {
@@ -2550,6 +2574,7 @@ async function loadConfigFile(configPath) {
 }
 __name(loadConfigFile, "loadConfigFile");
 async function generateFromOptions(options) {
+  const timestamp = (/* @__PURE__ */ new Date()).getTime();
   try {
     if (options.config) {
       const config = await loadConfigFile(options.config);
@@ -2574,6 +2599,9 @@ async function generateFromOptions(options) {
     console.log("\u2728 Generation completed successfully!");
   } catch (error) {
     console.error("\u274C Generation failed:", error instanceof Error ? error.message : error);
+  } finally {
+    const duration = ((/* @__PURE__ */ new Date()).getTime() - timestamp) / 1e3;
+    console.log(`\u23F1\uFE0F  Duration: ${duration.toFixed(2)} seconds`);
     process.exit(1);
   }
 }