ng-openapi 0.1.9 → 0.1.11-beta.0

package/index.js

@@ -112,16 +112,15 @@ 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 kebabCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[-_\s]+/g, "-").toLowerCase();
 }
 __name(kebabCase, "kebabCase");
 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");
 
@@ -447,6 +446,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 == null ? void 0 : mediaType.schema) {
+      return getTypeScriptType(mediaType.schema, config, mediaType.schema.nullable);
+    }
+  }
   switch (responseType) {
     case "blob":
       return "Blob";
@@ -454,15 +459,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 == null ? void 0 : mediaType.schema)) {
-          return getTypeScriptType(mediaType.schema, config, mediaType.schema.nullable);
-        }
-      }
-      return "any";
-    }
     default:
       return "any";
   }
@@ -724,82 +720,76 @@ var SwaggerParser = _SwaggerParser;
 
 // src/lib/generators/type/type.generator.ts
 var _TypeGenerator = class _TypeGenerator {
-  constructor(parser, outputRoot, config) {
+  constructor(parser, project, config, outputRoot) {
     __publicField(this, "project");
     __publicField(this, "parser");
     __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;
-    const outputPath = outputRoot + "/models/index.ts";
-    this.project = new import_ts_morph.Project({
-      compilerOptions: __spreadValues({
-        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 create(swaggerPathOrUrl, outputRoot, config) {
+  generate() {
     return __async(this, null, function* () {
-      const parser = yield SwaggerParser.create(swaggerPathOrUrl, config);
-      return new _TypeGenerator(parser, outputRoot, config);
+      try {
+        const definitions = this.parser.getDefinitions();
+        if (!definitions || Object.keys(definitions).length === 0) {
+          console.warn("No definitions found in swagger file");
+          return;
+        }
+        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"}`);
+      }
     });
   }
-  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();
-    } catch (error) {
-      console.error("Error in generate():", error);
-      throw new Error(`Failed to generate types: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
+  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);
+    });
   }
-  generateInterface(name, definition) {
-    const interfaceName = this.pascalCaseForEnums(name);
-    if (this.generatedTypes.has(interfaceName)) {
-      return;
-    }
-    this.generatedTypes.add(interfaceName);
+  collectTypeStructure(name, definition) {
+    var _a;
+    const interfaceName = (_a = this.getCachedPascalCase(name)) != null ? _a : "";
     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) {
     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,
@@ -807,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,
@@ -862,34 +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) {
-      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]) => {
       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,
@@ -897,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);
@@ -908,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";
@@ -925,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>";
@@ -935,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>";
@@ -944,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) {
@@ -1013,75 +1104,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() {
-    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;
@@ -2299,7 +2330,10 @@ var _ServiceMethodGenerator = class _ServiceMethodGenerator {
       parameters,
       returnType,
       statements: methodBody,
-      overloads: methodOverLoads
+      overloads: methodOverLoads,
+      docs: operation.description ? [
+        operation.description
+      ] : void 0
     });
   }
   generateMethodName(operation) {
@@ -2319,10 +2353,12 @@ var _ServiceMethodGenerator = class _ServiceMethodGenerator {
     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}`;
   }
 };
 __name(_ServiceMethodGenerator, "ServiceMethodGenerator");
@@ -2346,22 +2382,16 @@ var _ServiceGenerator = class _ServiceGenerator {
     }
     this.methodGenerator = new ServiceMethodGenerator(config);
   }
-  static create(swaggerPathOrUrl, project, config) {
-    return __async(this, null, function* () {
-      const parser = yield SwaggerParser.create(swaggerPathOrUrl, config);
-      return new _ServiceGenerator(parser, project, config);
-    });
-  }
   generate(outputRoot) {
-    const outputDir = path8.join(outputRoot, "services");
-    const paths = extractPaths(this.spec.paths);
-    if (paths.length === 0) {
-      console.warn("No API paths found in the specification");
-      return;
-    }
-    const controllerGroups = this.groupPathsByController(paths);
-    Object.entries(controllerGroups).forEach(([controllerName, operations]) => {
-      this.generateServiceFile(controllerName, operations, outputDir);
+    return __async(this, null, function* () {
+      const outputDir = path8.join(outputRoot, "services");
+      const paths = extractPaths(this.spec.paths);
+      if (paths.length === 0) {
+        console.warn("No API paths found in the specification");
+        return;
+      }
+      const controllerGroups = this.groupPathsByController(paths);
+      yield Promise.all(Object.entries(controllerGroups).map(([controllerName, operations]) => this.generateServiceFile(controllerName, operations, outputDir)));
     });
   }
   groupPathsByController(paths) {
@@ -2385,16 +2415,18 @@ var _ServiceGenerator = class _ServiceGenerator {
     return groups;
   }
   generateServiceFile(controllerName, operations, outputDir) {
-    const fileName = `${camelCase(controllerName)}.service.ts`;
-    const filePath = path8.join(outputDir, fileName);
-    const sourceFile = this.project.createSourceFile(filePath, "", {
-      overwrite: true
+    return __async(this, null, function* () {
+      const fileName = `${camelCase(controllerName)}.service.ts`;
+      const filePath = path8.join(outputDir, fileName);
+      const sourceFile = this.project.createSourceFile(filePath, "", {
+        overwrite: true
+      });
+      const usedTypes = collectUsedTypes(operations);
+      this.addImports(sourceFile, usedTypes);
+      this.addServiceClass(sourceFile, controllerName, operations);
+      sourceFile.formatText();
+      sourceFile.saveSync();
     });
-    const usedTypes = collectUsedTypes(operations);
-    this.addImports(sourceFile, usedTypes);
-    this.addServiceClass(sourceFile, controllerName, operations);
-    sourceFile.formatText();
-    sourceFile.saveSync();
   }
   addImports(sourceFile, usedTypes) {
     const basePathTokenName = getBasePathTokenName(this.config.clientName);
@@ -2578,8 +2610,9 @@ function generateFromConfig(config) {
         }, config.compilerOptions)
       });
       console.log(`\u{1F4E1} Processing OpenAPI specification from ${inputType}: ${config.input}`);
-      const typeGenerator = yield TypeGenerator.create(config.input, outputPath, config);
-      typeGenerator.generate();
+      const swaggerParser = yield SwaggerParser.create(config.input, config);
+      const typeGenerator = new TypeGenerator(swaggerParser, project, config, outputPath);
+      yield typeGenerator.generate();
       console.log(`\u2705 TypeScript interfaces generated`);
       if (generateServices) {
         const tokenGenerator = new TokenGenerator(project, config.clientName);
@@ -2590,8 +2623,8 @@ function generateFromConfig(config) {
         }
         const fileDownloadHelper = new FileDownloadGenerator(project);
         fileDownloadHelper.generate(outputPath);
-        const serviceGenerator = yield ServiceGenerator.create(config.input, project, config);
-        serviceGenerator.generate(outputPath);
+        const serviceGenerator = new ServiceGenerator(swaggerParser, project, config);
+        yield serviceGenerator.generate(outputPath);
         const indexGenerator = new ServiceIndexGenerator(project);
         indexGenerator.generateIndex(outputPath);
         console.log(`\u2705 Angular services generated`);
@@ -2602,9 +2635,9 @@ function generateFromConfig(config) {
       }
       if ((_b = config.plugins) == null ? void 0 : _b.length) {
         for (const plugin of config.plugins) {
-          const PluginClass = plugin;
-          const pluginGenerator = yield PluginClass.create(config.input, project, config);
-          pluginGenerator.generate(outputPath);
+          const generatorClass = plugin;
+          const pluginGenerator = new generatorClass(swaggerParser, project, config);
+          yield pluginGenerator.generate(outputPath);
         }
         console.log(`\u2705 Plugins are generated`);
       }