ng-openapi 0.0.41-pr-8-feature-url-support-48813a8.0 → 0.0.42-pr-9-feature-http-resource-e6134bb.0

package/cli.cjs

@@ -29,7 +29,400 @@ var import_commander = require("commander");
 var path10 = __toESM(require("path"));
 var fs4 = __toESM(require("fs"));
 
-// src/lib/core/swagger-parser.ts
+// src/lib/core/generator.ts
+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) {
+  const cleaned = str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
+  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+}
+__name(camelCase, "camelCase");
+function pascalCase(str) {
+  return str.replace(/(?:^|[-_])([a-z])/g, (_, char) => char.toUpperCase());
+}
+__name(pascalCase, "pascalCase");
+
+// ../shared/src/utils/type.utils.ts
+function getTypeScriptType(schemaOrType, config, formatOrNullable, isNullable, context = "type") {
+  let schema;
+  let nullable;
+  if (typeof schemaOrType === "string" || schemaOrType === void 0) {
+    schema = {
+      type: schemaOrType,
+      format: typeof formatOrNullable === "string" ? formatOrNullable : void 0
+    };
+    nullable = typeof formatOrNullable === "boolean" ? formatOrNullable : isNullable;
+  } else {
+    schema = schemaOrType;
+    nullable = typeof formatOrNullable === "boolean" ? formatOrNullable : schema.nullable;
+  }
+  if (!schema) {
+    return "any";
+  }
+  if (schema.$ref) {
+    const refName = schema.$ref.split("/").pop();
+    return nullableType(pascalCase(refName), nullable);
+  }
+  if (schema.type === "array") {
+    const itemType = schema.items ? getTypeScriptType(schema.items, config, void 0, void 0, context) : "unknown";
+    return nullable ? `(${itemType}[] | null)` : `${itemType}[]`;
+  }
+  switch (schema.type) {
+    case "string":
+      if (schema.enum) {
+        return schema.enum.map((value) => typeof value === "string" ? `'${escapeString(value)}'` : String(value)).join(" | ");
+      }
+      if (schema.format === "date" || schema.format === "date-time") {
+        const dateType = config.options.dateType === "Date" ? "Date" : "string";
+        return nullableType(dateType, nullable);
+      }
+      if (schema.format === "binary") {
+        const binaryType = context === "type" ? "Blob" : "File";
+        return nullableType(binaryType, nullable);
+      }
+      if (schema.format === "uuid" || schema.format === "email" || schema.format === "uri" || schema.format === "hostname" || schema.format === "ipv4" || schema.format === "ipv6") {
+        return nullableType("string", nullable);
+      }
+      return nullableType("string", nullable);
+    case "number":
+    case "integer":
+      return nullableType("number", nullable);
+    case "boolean":
+      return nullableType("boolean", nullable);
+    case "object":
+      return nullableType(context === "type" ? "Record<string, unknown>" : "any", nullable);
+    case "null":
+      return "null";
+    default:
+      console.warn(`Unknown swagger type: ${schema.type}`);
+      return nullableType("any", nullable);
+  }
+}
+__name(getTypeScriptType, "getTypeScriptType");
+function nullableType(type, isNullable) {
+  return type + (isNullable ? " | null" : "");
+}
+__name(nullableType, "nullableType");
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+__name(escapeString, "escapeString");
+
+// ../shared/src/utils/functions/collect-used-types.ts
+function collectUsedTypes(operations) {
+  const usedTypes = /* @__PURE__ */ new Set();
+  operations.forEach((operation) => {
+    operation.parameters?.forEach((param) => {
+      collectTypesFromSchema(param.schema || param, usedTypes);
+    });
+    if (operation.requestBody) {
+      collectTypesFromRequestBody(operation.requestBody, usedTypes);
+    }
+    if (operation.responses) {
+      Object.values(operation.responses).forEach((response) => {
+        collectTypesFromResponse(response, usedTypes);
+      });
+    }
+  });
+  return usedTypes;
+}
+__name(collectUsedTypes, "collectUsedTypes");
+function collectTypesFromSchema(schema, usedTypes) {
+  if (!schema) return;
+  if (schema.$ref) {
+    const refName = schema.$ref.split("/").pop();
+    if (refName) {
+      usedTypes.add(pascalCase(refName));
+    }
+  }
+  if (schema.type === "array" && schema.items) {
+    collectTypesFromSchema(schema.items, usedTypes);
+  }
+  if (schema.type === "object" && schema.properties) {
+    Object.values(schema.properties).forEach((prop) => {
+      collectTypesFromSchema(prop, usedTypes);
+    });
+  }
+  if (schema.allOf) {
+    schema.allOf.forEach((subSchema) => {
+      collectTypesFromSchema(subSchema, usedTypes);
+    });
+  }
+  if (schema.oneOf) {
+    schema.oneOf.forEach((subSchema) => {
+      collectTypesFromSchema(subSchema, usedTypes);
+    });
+  }
+  if (schema.anyOf) {
+    schema.anyOf.forEach((subSchema) => {
+      collectTypesFromSchema(subSchema, usedTypes);
+    });
+  }
+}
+__name(collectTypesFromSchema, "collectTypesFromSchema");
+function collectTypesFromRequestBody(requestBody, usedTypes) {
+  const content = requestBody.content || {};
+  Object.values(content).forEach((mediaType) => {
+    if (mediaType.schema) {
+      collectTypesFromSchema(mediaType.schema, usedTypes);
+    }
+  });
+}
+__name(collectTypesFromRequestBody, "collectTypesFromRequestBody");
+function collectTypesFromResponse(response, usedTypes) {
+  const content = response.content || {};
+  Object.values(content).forEach((mediaType) => {
+    if (mediaType.schema) {
+      collectTypesFromSchema(mediaType.schema, usedTypes);
+    }
+  });
+}
+__name(collectTypesFromResponse, "collectTypesFromResponse");
+
+// ../shared/src/utils/functions/token-names.ts
+function getClientContextTokenName(clientName = "default") {
+  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  return `CLIENT_CONTEXT_TOKEN_${clientSuffix}`;
+}
+__name(getClientContextTokenName, "getClientContextTokenName");
+function getBasePathTokenName(clientName = "default") {
+  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  return `BASE_PATH_${clientSuffix}`;
+}
+__name(getBasePathTokenName, "getBasePathTokenName");
+
+// ../shared/src/utils/functions/duplicate-function-name.ts
+function hasDuplicateFunctionNames(arr) {
+  return new Set(arr.map((fn) => fn.getName())).size !== arr.length;
+}
+__name(hasDuplicateFunctionNames, "hasDuplicateFunctionNames");
+
+// ../shared/src/utils/functions/extract-paths.ts
+function extractPaths(swaggerPaths = {}, methods = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "options",
+  "head"
+]) {
+  const paths = [];
+  Object.entries(swaggerPaths).forEach(([path11, pathItem]) => {
+    methods.forEach((method) => {
+      if (pathItem[method]) {
+        const operation = pathItem[method];
+        paths.push({
+          path: path11,
+          method: method.toUpperCase(),
+          operationId: operation.operationId,
+          summary: operation.summary,
+          description: operation.description,
+          tags: operation.tags || [],
+          parameters: parseParameters(operation.parameters || [], pathItem.parameters || []),
+          requestBody: operation.requestBody,
+          responses: operation.responses || {}
+        });
+      }
+    });
+  });
+  return paths;
+}
+__name(extractPaths, "extractPaths");
+function parseParameters(operationParams, pathParams) {
+  const allParams = [
+    ...pathParams,
+    ...operationParams
+  ];
+  return allParams.map((param) => ({
+    name: param.name,
+    in: param.in,
+    required: param.required || param.in === "path",
+    schema: param.schema,
+    type: param.type,
+    format: param.format,
+    description: param.description
+  }));
+}
+__name(parseParameters, "parseParameters");
+
+// ../shared/src/utils/functions/extract-swagger-response-type.ts
+function getResponseTypeFromResponse(response, responseTypeMapping) {
+  const content = response.content || {};
+  if (Object.keys(content).length === 0) {
+    return "json";
+  }
+  const responseTypes = [];
+  for (const [contentType, mediaType] of Object.entries(content)) {
+    const schema = mediaType?.schema;
+    const mapping = responseTypeMapping || {};
+    if (mapping[contentType]) {
+      responseTypes.push({
+        type: mapping[contentType],
+        priority: 1,
+        contentType
+      });
+      continue;
+    }
+    if (schema?.format === "binary" || schema?.format === "byte") {
+      responseTypes.push({
+        type: "blob",
+        priority: 2,
+        contentType
+      });
+      continue;
+    }
+    if (schema?.type === "string" && (schema?.format === "binary" || schema?.format === "byte")) {
+      responseTypes.push({
+        type: "blob",
+        priority: 2,
+        contentType
+      });
+      continue;
+    }
+    const isPrimitive = isPrimitiveType(schema);
+    const inferredType = inferResponseTypeFromContentType(contentType);
+    let priority = 3;
+    let finalType = inferredType;
+    if (inferredType === "json" && isPrimitive) {
+      finalType = "text";
+      priority = 2;
+    } else if (inferredType === "json") {
+      priority = 2;
+    }
+    responseTypes.push({
+      type: finalType,
+      priority,
+      contentType,
+      isPrimitive
+    });
+  }
+  responseTypes.sort((a, b) => a.priority - b.priority);
+  return responseTypes[0]?.type || "json";
+}
+__name(getResponseTypeFromResponse, "getResponseTypeFromResponse");
+function isPrimitiveType(schema) {
+  if (!schema) return false;
+  const primitiveTypes = [
+    "string",
+    "number",
+    "integer",
+    "boolean"
+  ];
+  if (primitiveTypes.includes(schema.type)) {
+    return true;
+  }
+  if (schema.type === "array") {
+    return false;
+  }
+  if (schema.type === "object" || schema.properties) {
+    return false;
+  }
+  if (schema.$ref) {
+    return false;
+  }
+  if (schema.allOf || schema.oneOf || schema.anyOf) {
+    return false;
+  }
+  return false;
+}
+__name(isPrimitiveType, "isPrimitiveType");
+function inferResponseTypeFromContentType(contentType) {
+  const normalizedType = contentType.split(";")[0].trim().toLowerCase();
+  if (normalizedType.includes("json") || normalizedType === "application/ld+json" || normalizedType === "application/hal+json" || normalizedType === "application/vnd.api+json") {
+    return "json";
+  }
+  if (normalizedType.includes("xml") || normalizedType === "application/soap+xml" || normalizedType === "application/atom+xml" || normalizedType === "application/rss+xml") {
+    return "text";
+  }
+  if (normalizedType.startsWith("text/")) {
+    const binaryTextTypes = [
+      "text/rtf",
+      "text/cache-manifest",
+      "text/vcard",
+      "text/calendar"
+    ];
+    if (binaryTextTypes.includes(normalizedType)) {
+      return "blob";
+    }
+    return "text";
+  }
+  if (normalizedType === "application/x-www-form-urlencoded" || normalizedType === "multipart/form-data") {
+    return "text";
+  }
+  if (normalizedType === "application/javascript" || normalizedType === "application/typescript" || normalizedType === "application/css" || normalizedType === "application/yaml" || normalizedType === "application/x-yaml" || normalizedType === "application/toml") {
+    return "text";
+  }
+  if (normalizedType.startsWith("image/") || normalizedType.startsWith("audio/") || normalizedType.startsWith("video/") || normalizedType === "application/pdf" || normalizedType === "application/zip" || normalizedType.includes("octet-stream")) {
+    return "arraybuffer";
+  }
+  return "blob";
+}
+__name(inferResponseTypeFromContentType, "inferResponseTypeFromContentType");
+function getResponseType(response, config) {
+  const responseType = getResponseTypeFromResponse(response);
+  switch (responseType) {
+    case "blob":
+      return "Blob";
+    case "arraybuffer":
+      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";
+  }
+}
+__name(getResponseType, "getResponseType");
+
+// ../shared/src/config/constants.ts
+var disableLinting = `/* @ts-nocheck */
+/* eslint-disable */
+/* @noformat */
+/* @formatter:off */
+`;
+var authorComment = `/**
+* Generated by ng-openapi
+`;
+var defaultHeaderComment = disableLinting + authorComment;
+var TYPE_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated TypeScript interfaces from Swagger specification
+* Do not edit this file manually
+*/
+`;
+var SERVICE_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated service exports
+* Do not edit this file manually
+*/
+`;
+var SERVICE_GENERATOR_HEADER_COMMENT = /* @__PURE__ */ __name((controllerName) => defaultHeaderComment + `* Generated Angular service for ${controllerName} controller
+* Do not edit this file manually
+*/
+`, "SERVICE_GENERATOR_HEADER_COMMENT");
+var MAIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Entrypoint for the client
+* Do not edit this file manually
+*/
+`;
+var PROVIDER_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated provider functions for easy setup
+* Do not edit this file manually
+*/
+`;
+var BASE_INTERCEPTOR_HEADER_COMMENT = /* @__PURE__ */ __name((clientName) => defaultHeaderComment + `* Generated Base Interceptor for client ${clientName}
+* Do not edit this file manually
+*/
+`, "BASE_INTERCEPTOR_HEADER_COMMENT");
+
+// ../shared/src/core/swagger-parser.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var yaml = __toESM(require("js-yaml"));
@@ -70,7 +463,7 @@ var SwaggerParser = class _SwaggerParser {
       const response = await fetch(url, {
         method: "GET",
         headers: {
-          "Accept": "application/json, application/yaml, text/yaml, text/plain, */*",
+          Accept: "application/json, application/yaml, text/yaml, text/plain, */*",
           "User-Agent": "ng-openapi"
         },
         // 30 second timeout
@@ -186,47 +579,6 @@ var SwaggerParser = class _SwaggerParser {
   }
 };
 
-// src/lib/core/generator.ts
-var import_ts_morph6 = require("ts-morph");
-
-// src/lib/generators/type/type.generator.ts
-var import_ts_morph = require("ts-morph");
-
-// src/lib/config/constants.ts
-var disableLinting = `/* @ts-nocheck */
-/* eslint-disable */
-/* @noformat */
-/* @formatter:off */
-`;
-var authorComment = `/**
-* Generated by ng-openapi
-`;
-var defaultHeaderComment = disableLinting + authorComment;
-var TYPE_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated TypeScript interfaces from Swagger specification
-* Do not edit this file manually
-*/
-`;
-var SERVICE_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated service exports
-* Do not edit this file manually
-*/
-`;
-var SERVICE_GENERATOR_HEADER_COMMENT = /* @__PURE__ */ __name((controllerName) => defaultHeaderComment + `* Generated Angular service for ${controllerName} controller
-* Do not edit this file manually
-*/
-`, "SERVICE_GENERATOR_HEADER_COMMENT");
-var MAIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Entrypoint for the client
-* Do not edit this file manually
-*/
-`;
-var PROVIDER_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated provider functions for easy setup
-* Do not edit this file manually
-*/
-`;
-var BASE_INTERCEPTOR_HEADER_COMMENT = /* @__PURE__ */ __name((clientName) => defaultHeaderComment + `* Generated Base Interceptor for client ${clientName}
-* Do not edit this file manually
-*/
-`, "BASE_INTERCEPTOR_HEADER_COMMENT");
-
 // src/lib/generators/type/type.generator.ts
 var TypeGenerator = class _TypeGenerator {
   static {
@@ -269,6 +621,7 @@ var TypeGenerator = class _TypeGenerator {
       Object.entries(definitions).forEach(([name, definition]) => {
         this.generateInterface(name, definition);
       });
+      this.sourceFile.formatText();
       this.sourceFile.saveSync();
     } catch (error) {
       console.error("Error in generate():", error);
@@ -639,6 +992,7 @@ var TokenGenerator = class {
 `
       });
     }
+    sourceFile.formatText();
     sourceFile.saveSync();
   }
   getBasePathTokenName() {
@@ -792,6 +1146,7 @@ var FileDownloadGenerator = class {
     
     return fallbackFilename;`
     });
+    sourceFile.formatText();
     sourceFile.saveSync();
   }
 };
@@ -927,6 +1282,7 @@ var DateTransformerGenerator = class {
         }
       ]
     });
+    sourceFile.formatText();
     sourceFile.saveSync();
   }
 };
@@ -971,6 +1327,7 @@ var MainIndexGenerator = class {
         });
       }
     }
+    sourceFile.formatText();
     sourceFile.saveSync();
   }
 };
@@ -1069,6 +1426,7 @@ var ProviderGenerator = class {
       ]
     });
     this.addMainProviderFunction(sourceFile, basePathTokenName, interceptorsTokenName, baseInterceptorClassName);
+    sourceFile.formatText();
     sourceFile.saveSync();
   }
   addMainProviderFunction(sourceFile, basePathTokenName, interceptorsTokenName, baseInterceptorClassName) {
@@ -1298,6 +1656,7 @@ var BaseInterceptorGenerator = class {
         }
       ]
     });
+    sourceFile.formatText();
     sourceFile.saveSync();
   }
   getInterceptorsTokenName() {
@@ -1317,83 +1676,6 @@ var BaseInterceptorGenerator = class {
 var import_ts_morph5 = require("ts-morph");
 var path8 = __toESM(require("path"));
 
-// src/lib/utils/string.utils.ts
-function camelCase(str) {
-  const cleaned = str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
-  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
-}
-__name(camelCase, "camelCase");
-function pascalCase(str) {
-  return str.replace(/(?:^|[-_])([a-z])/g, (_, char) => char.toUpperCase());
-}
-__name(pascalCase, "pascalCase");
-
-// src/lib/utils/type.utils.ts
-function getTypeScriptType(schemaOrType, config, formatOrNullable, isNullable, context = "type") {
-  let schema;
-  let nullable;
-  if (typeof schemaOrType === "string" || schemaOrType === void 0) {
-    schema = {
-      type: schemaOrType,
-      format: typeof formatOrNullable === "string" ? formatOrNullable : void 0
-    };
-    nullable = typeof formatOrNullable === "boolean" ? formatOrNullable : isNullable;
-  } else {
-    schema = schemaOrType;
-    nullable = typeof formatOrNullable === "boolean" ? formatOrNullable : schema.nullable;
-  }
-  if (!schema) {
-    return "any";
-  }
-  if (schema.$ref) {
-    const refName = schema.$ref.split("/").pop();
-    return nullableType(pascalCase(refName), nullable);
-  }
-  if (schema.type === "array") {
-    const itemType = schema.items ? getTypeScriptType(schema.items, config, void 0, void 0, context) : "unknown";
-    return nullable ? `(${itemType}[] | null)` : `${itemType}[]`;
-  }
-  switch (schema.type) {
-    case "string":
-      if (schema.enum) {
-        return schema.enum.map((value) => typeof value === "string" ? `'${escapeString(value)}'` : String(value)).join(" | ");
-      }
-      if (schema.format === "date" || schema.format === "date-time") {
-        const dateType = config.options.dateType === "Date" ? "Date" : "string";
-        return nullableType(dateType, nullable);
-      }
-      if (schema.format === "binary") {
-        const binaryType = context === "type" ? "Blob" : "File";
-        return nullableType(binaryType, nullable);
-      }
-      if (schema.format === "uuid" || schema.format === "email" || schema.format === "uri" || schema.format === "hostname" || schema.format === "ipv4" || schema.format === "ipv6") {
-        return nullableType("string", nullable);
-      }
-      return nullableType("string", nullable);
-    case "number":
-    case "integer":
-      return nullableType("number", nullable);
-    case "boolean":
-      return nullableType("boolean", nullable);
-    case "object":
-      return nullableType(context === "type" ? "Record<string, unknown>" : "any", nullable);
-    case "null":
-      return "null";
-    default:
-      console.warn(`Unknown swagger type: ${schema.type}`);
-      return nullableType("any", nullable);
-  }
-}
-__name(getTypeScriptType, "getTypeScriptType");
-function nullableType(type, isNullable) {
-  return type + (isNullable ? " | null" : "");
-}
-__name(nullableType, "nullableType");
-function escapeString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-__name(escapeString, "escapeString");
-
 // src/lib/generators/service/service-method/service-method-body.generator.ts
 var ServiceMethodBodyGenerator = class {
   static {
@@ -1433,84 +1715,6 @@ var ServiceMethodBodyGenerator = class {
     const properties = operation.requestBody?.content?.["multipart/form-data"]?.schema?.properties || {};
     return Object.keys(properties);
   }
-  getResponseTypeFromResponse(response) {
-    const content = response.content || {};
-    if (Object.keys(content).length === 0) {
-      return "json";
-    }
-    const responseTypes = [];
-    for (const [contentType, mediaType] of Object.entries(content)) {
-      const schema = mediaType?.schema;
-      const mapping = this.config?.options?.responseTypeMapping || {};
-      if (mapping[contentType]) {
-        responseTypes.push({
-          type: mapping[contentType],
-          priority: 1,
-          contentType
-        });
-        continue;
-      }
-      if (schema?.format === "binary" || schema?.format === "byte") {
-        responseTypes.push({
-          type: "blob",
-          priority: 2,
-          contentType
-        });
-        continue;
-      }
-      if (schema?.type === "string" && (schema?.format === "binary" || schema?.format === "byte")) {
-        responseTypes.push({
-          type: "blob",
-          priority: 2,
-          contentType
-        });
-        continue;
-      }
-      const isPrimitive = this.isPrimitiveType(schema);
-      const inferredType = this.inferResponseTypeFromContentType(contentType);
-      let priority = 3;
-      let finalType = inferredType;
-      if (inferredType === "json" && isPrimitive) {
-        finalType = "text";
-        priority = 2;
-      } else if (inferredType === "json") {
-        priority = 2;
-      }
-      responseTypes.push({
-        type: finalType,
-        priority,
-        contentType,
-        isPrimitive
-      });
-    }
-    responseTypes.sort((a, b) => a.priority - b.priority);
-    return responseTypes[0]?.type || "json";
-  }
-  isPrimitiveType(schema) {
-    if (!schema) return false;
-    const primitiveTypes = [
-      "string",
-      "number",
-      "integer",
-      "boolean"
-    ];
-    if (primitiveTypes.includes(schema.type)) {
-      return true;
-    }
-    if (schema.type === "array") {
-      return false;
-    }
-    if (schema.type === "object" || schema.properties) {
-      return false;
-    }
-    if (schema.$ref) {
-      return false;
-    }
-    if (schema.allOf || schema.oneOf || schema.anyOf) {
-      return false;
-    }
-    return false;
-  }
   createGenerationContext(operation) {
     return {
       pathParams: operation.parameters?.filter((p) => p.in === "path") || [],
@@ -1647,7 +1851,7 @@ return this.httpClient.${httpMethod}(url, requestOptions);`;
     for (const statusCode of successResponses) {
       const response = operation.responses?.[statusCode];
       if (!response) continue;
-      return this.getResponseTypeFromResponse(response);
+      return getResponseTypeFromResponse(response);
     }
     return "json";
   }
@@ -1665,47 +1869,6 @@ return this.httpClient.${httpMethod}(url, requestOptions);`;
     ];
     return !invalidTypes.some((invalidType) => type.includes(invalidType));
   }
-  inferResponseTypeFromContentType(contentType) {
-    const normalizedType = contentType.split(";")[0].trim().toLowerCase();
-    if (normalizedType.includes("json") || normalizedType === "application/ld+json" || normalizedType === "application/hal+json" || normalizedType === "application/vnd.api+json") {
-      return "json";
-    }
-    if (normalizedType.includes("xml") || normalizedType === "application/soap+xml" || normalizedType === "application/atom+xml" || normalizedType === "application/rss+xml") {
-      return "text";
-    }
-    if (normalizedType.startsWith("text/")) {
-      const binaryTextTypes = [
-        "text/rtf",
-        "text/cache-manifest",
-        "text/vcard",
-        "text/calendar"
-      ];
-      if (binaryTextTypes.includes(normalizedType)) {
-        return "blob";
-      }
-      return "text";
-    }
-    if (normalizedType === "application/x-www-form-urlencoded" || normalizedType === "multipart/form-data") {
-      return "text";
-    }
-    if (normalizedType === "application/javascript" || normalizedType === "application/typescript" || normalizedType === "application/css" || normalizedType === "application/yaml" || normalizedType === "application/x-yaml" || normalizedType === "application/toml") {
-      return "text";
-    }
-    if (normalizedType.startsWith("image/") || normalizedType.startsWith("audio/") || normalizedType.startsWith("video/") || normalizedType === "application/pdf" || normalizedType === "application/zip" || normalizedType.includes("octet-stream")) {
-      return "arraybuffer";
-    }
-    return "blob";
-  }
-  generateContextHelper() {
-    return `
-/**
- * Creates HttpContext with client identification
- */
-private createContextWithClientId(existingContext?: HttpContext): HttpContext {
-    const context = existingContext || new HttpContext();
-    return context.set(this.clientContextToken, '${this.config.clientName || "default"}');
-}`;
-  }
 };
 
 // src/lib/generators/service/service-method/service-method-params.generator.ts
@@ -1770,7 +1933,7 @@ var ServiceMethodParamsGenerator = class {
         hasQuestionToken: !param.required
       });
     });
-    return params;
+    return params.sort((a, b) => Number(a.hasQuestionToken) - Number(b.hasQuestionToken));
   }
   addOptionsParameter() {
     return [
@@ -1882,7 +2045,7 @@ var ServiceMethodOverloadsGenerator = class {
     if (!response) {
       return "any";
     }
-    return this.getResponseType(response);
+    return getResponseType(response, this.config);
   }
   generateOverloadReturnType(responseType, observe) {
     switch (observe) {
@@ -1896,106 +2059,6 @@ var ServiceMethodOverloadsGenerator = class {
         throw new Error(`Unsupported observe type: ${observe}`);
     }
   }
-  getResponseTypeFromResponse(response) {
-    const content = response.content || {};
-    if (Object.keys(content).length === 0) {
-      return "json";
-    }
-    const responseTypes = [];
-    for (const [contentType, mediaType] of Object.entries(content)) {
-      const schema = mediaType?.schema;
-      const mapping = this.config?.options?.responseTypeMapping || {};
-      if (mapping[contentType]) {
-        responseTypes.push({
-          type: mapping[contentType],
-          priority: 1,
-          contentType
-        });
-        continue;
-      }
-      if (schema?.format === "binary" || schema?.format === "byte") {
-        responseTypes.push({
-          type: "blob",
-          priority: 2,
-          contentType
-        });
-        continue;
-      }
-      if (schema?.type === "string" && (schema?.format === "binary" || schema?.format === "byte")) {
-        responseTypes.push({
-          type: "blob",
-          priority: 2,
-          contentType
-        });
-        continue;
-      }
-      const isPrimitive = this.isPrimitiveType(schema);
-      const inferredType = this.inferResponseTypeFromContentType(contentType);
-      let priority = 3;
-      let finalType = inferredType;
-      if (inferredType === "json" && isPrimitive) {
-        finalType = "text";
-        priority = 2;
-      } else if (inferredType === "json") {
-        priority = 2;
-      }
-      responseTypes.push({
-        type: finalType,
-        priority,
-        contentType,
-        isPrimitive
-      });
-    }
-    responseTypes.sort((a, b) => a.priority - b.priority);
-    return responseTypes[0]?.type || "json";
-  }
-  isPrimitiveType(schema) {
-    if (!schema) return false;
-    const primitiveTypes = [
-      "string",
-      "number",
-      "integer",
-      "boolean"
-    ];
-    if (primitiveTypes.includes(schema.type)) {
-      return true;
-    }
-    if (schema.type === "array") {
-      return false;
-    }
-    if (schema.type === "object" || schema.properties) {
-      return false;
-    }
-    if (schema.$ref) {
-      return false;
-    }
-    if (schema.allOf || schema.oneOf || schema.anyOf) {
-      return false;
-    }
-    return false;
-  }
-  getResponseType(response) {
-    const responseType = this.getResponseTypeFromResponse(response);
-    switch (responseType) {
-      case "blob":
-        return "Blob";
-      case "arraybuffer":
-        return "ArrayBuffer";
-      case "text":
-        return "string";
-      case "json": {
-        const content = response.content || {};
-        for (const [contentType, mediaType] of Object.entries(content)) {
-          if (this.inferResponseTypeFromContentType(contentType) === "json" && mediaType?.schema) {
-            return getTypeScriptType(mediaType.schema, this.config, mediaType.schema.nullable);
-          }
-        }
-        return "any";
-      }
-      default:
-        return "any";
-    }
-  }
   determineResponseTypeForOperation(operation) {
     const successResponses = [
       "200",
@@ -2007,41 +2070,10 @@ var ServiceMethodOverloadsGenerator = class {
     for (const statusCode of successResponses) {
       const response = operation.responses?.[statusCode];
       if (!response) continue;
-      return this.getResponseTypeFromResponse(response);
+      return getResponseTypeFromResponse(response);
     }
     return "json";
   }
-  inferResponseTypeFromContentType(contentType) {
-    const normalizedType = contentType.split(";")[0].trim().toLowerCase();
-    if (normalizedType.includes("json") || normalizedType === "application/ld+json" || normalizedType === "application/hal+json" || normalizedType === "application/vnd.api+json") {
-      return "json";
-    }
-    if (normalizedType.includes("xml") || normalizedType === "application/soap+xml" || normalizedType === "application/atom+xml" || normalizedType === "application/rss+xml") {
-      return "text";
-    }
-    if (normalizedType.startsWith("text/")) {
-      const binaryTextTypes = [
-        "text/rtf",
-        "text/cache-manifest",
-        "text/vcard",
-        "text/calendar"
-      ];
-      if (binaryTextTypes.includes(normalizedType)) {
-        return "blob";
-      }
-      return "text";
-    }
-    if (normalizedType === "application/x-www-form-urlencoded" || normalizedType === "multipart/form-data") {
-      return "text";
-    }
-    if (normalizedType === "application/javascript" || normalizedType === "application/typescript" || normalizedType === "application/css" || normalizedType === "application/yaml" || normalizedType === "application/x-yaml" || normalizedType === "application/toml") {
-      return "text";
-    }
-    if (normalizedType.startsWith("image/") || normalizedType.startsWith("audio/") || normalizedType.startsWith("video/") || normalizedType === "application/pdf" || normalizedType === "application/zip" || normalizedType.includes("octet-stream")) {
-      return "arraybuffer";
-    }
-    return "blob";
-  }
 };
 
 // src/lib/generators/service/service-method.generator.ts
@@ -2124,7 +2156,7 @@ var ServiceGenerator = class _ServiceGenerator {
   }
   generate(outputRoot) {
     const outputDir = path8.join(outputRoot, "services");
-    const paths = this.extractPaths();
+    const paths = extractPaths(this.spec.paths);
     if (paths.length === 0) {
       console.warn("No API paths found in the specification");
       return;
@@ -2134,53 +2166,6 @@ var ServiceGenerator = class _ServiceGenerator {
       this.generateServiceFile(controllerName, operations, outputDir);
     });
   }
-  extractPaths() {
-    const paths = [];
-    const swaggerPaths = this.spec.paths || {};
-    Object.entries(swaggerPaths).forEach(([path11, pathItem]) => {
-      const methods = [
-        "get",
-        "post",
-        "put",
-        "patch",
-        "delete",
-        "options",
-        "head"
-      ];
-      methods.forEach((method) => {
-        if (pathItem[method]) {
-          const operation = pathItem[method];
-          paths.push({
-            path: path11,
-            method: method.toUpperCase(),
-            operationId: operation.operationId,
-            summary: operation.summary,
-            description: operation.description,
-            tags: operation.tags || [],
-            parameters: this.parseParameters(operation.parameters || [], pathItem.parameters || []),
-            requestBody: operation.requestBody,
-            responses: operation.responses || {}
-          });
-        }
-      });
-    });
-    return paths;
-  }
-  parseParameters(operationParams, pathParams) {
-    const allParams = [
-      ...pathParams,
-      ...operationParams
-    ];
-    return allParams.map((param) => ({
-      name: param.name,
-      in: param.in,
-      required: param.required || param.in === "path",
-      schema: param.schema,
-      type: param.type,
-      format: param.format,
-      description: param.description
-    }));
-  }
   groupPathsByController(paths) {
     const groups = {};
     paths.forEach((path11) => {
@@ -2207,79 +2192,15 @@ var ServiceGenerator = class _ServiceGenerator {
     const sourceFile = this.project.createSourceFile(filePath, "", {
       overwrite: true
     });
-    const usedTypes = this.collectUsedTypes(operations);
+    const usedTypes = collectUsedTypes(operations);
     this.addImports(sourceFile, usedTypes);
     this.addServiceClass(sourceFile, controllerName, operations);
+    sourceFile.formatText();
     sourceFile.saveSync();
   }
-  collectUsedTypes(operations) {
-    const usedTypes = /* @__PURE__ */ new Set();
-    operations.forEach((operation) => {
-      operation.parameters?.forEach((param) => {
-        this.collectTypesFromSchema(param.schema || param, usedTypes);
-      });
-      if (operation.requestBody) {
-        this.collectTypesFromRequestBody(operation.requestBody, usedTypes);
-      }
-      if (operation.responses) {
-        Object.values(operation.responses).forEach((response) => {
-          this.collectTypesFromResponse(response, usedTypes);
-        });
-      }
-    });
-    return usedTypes;
-  }
-  collectTypesFromSchema(schema, usedTypes) {
-    if (!schema) return;
-    if (schema.$ref) {
-      const refName = schema.$ref.split("/").pop();
-      if (refName) {
-        usedTypes.add(pascalCase(refName));
-      }
-    }
-    if (schema.type === "array" && schema.items) {
-      this.collectTypesFromSchema(schema.items, usedTypes);
-    }
-    if (schema.type === "object" && schema.properties) {
-      Object.values(schema.properties).forEach((prop) => {
-        this.collectTypesFromSchema(prop, usedTypes);
-      });
-    }
-    if (schema.allOf) {
-      schema.allOf.forEach((subSchema) => {
-        this.collectTypesFromSchema(subSchema, usedTypes);
-      });
-    }
-    if (schema.oneOf) {
-      schema.oneOf.forEach((subSchema) => {
-        this.collectTypesFromSchema(subSchema, usedTypes);
-      });
-    }
-    if (schema.anyOf) {
-      schema.anyOf.forEach((subSchema) => {
-        this.collectTypesFromSchema(subSchema, usedTypes);
-      });
-    }
-  }
-  collectTypesFromRequestBody(requestBody, usedTypes) {
-    const content = requestBody.content || {};
-    Object.values(content).forEach((mediaType) => {
-      if (mediaType.schema) {
-        this.collectTypesFromSchema(mediaType.schema, usedTypes);
-      }
-    });
-  }
-  collectTypesFromResponse(response, usedTypes) {
-    const content = response.content || {};
-    Object.values(content).forEach((mediaType) => {
-      if (mediaType.schema) {
-        this.collectTypesFromSchema(mediaType.schema, usedTypes);
-      }
-    });
-  }
   addImports(sourceFile, usedTypes) {
-    const basePathTokenName = this.getBasePathTokenName();
-    const clientContextTokenName = this.getClientContextTokenName();
+    const basePathTokenName = getBasePathTokenName(this.config.clientName);
+    const clientContextTokenName = getClientContextTokenName(this.config.clientName);
     sourceFile.addImportDeclarations([
       {
         namedImports: [
@@ -2295,7 +2216,8 @@ var ServiceGenerator = class _ServiceGenerator {
           "HttpHeaders",
           "HttpContext",
           "HttpResponse",
-          "HttpEvent"
+          "HttpEvent",
+          "HttpContextToken"
         ],
         moduleSpecifier: "@angular/common/http"
       },
@@ -2322,8 +2244,8 @@ var ServiceGenerator = class _ServiceGenerator {
   }
   addServiceClass(sourceFile, controllerName, operations) {
     const className = `${controllerName}Service`;
-    const basePathTokenName = this.getBasePathTokenName();
-    const clientContextTokenName = this.getClientContextTokenName();
+    const basePathTokenName = getBasePathTokenName(this.config.clientName);
+    const clientContextTokenName = getClientContextTokenName(this.config.clientName);
     sourceFile.insertText(0, SERVICE_GENERATOR_HEADER_COMMENT(controllerName));
     const serviceClass = sourceFile.addClass({
       name: className,
@@ -2353,7 +2275,7 @@ var ServiceGenerator = class _ServiceGenerator {
     });
     serviceClass.addProperty({
       name: "clientContextToken",
-      type: "any",
+      type: "HttpContextToken<string>",
       scope: import_ts_morph5.Scope.Private,
       isReadonly: true,
       initializer: clientContextTokenName
@@ -2369,30 +2291,16 @@ var ServiceGenerator = class _ServiceGenerator {
         }
       ],
       returnType: "HttpContext",
-      statements: `
-const context = existingContext || new HttpContext();
+      statements: `const context = existingContext || new HttpContext();
 return context.set(this.clientContextToken, '${this.config.clientName || "default"}');`
     });
     operations.forEach((operation) => {
       this.methodGenerator.addServiceMethod(serviceClass, operation);
     });
-    if (this.hasDuplicateMethodNames(serviceClass.getMethods())) {
+    if (hasDuplicateFunctionNames(serviceClass.getMethods())) {
       throw new Error(`Duplicate method names found in service class ${className}. Please ensure unique method names for each operation.`);
     }
   }
-  getClientContextTokenName() {
-    const clientName = this.config.clientName || "default";
-    const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-    return `CLIENT_CONTEXT_TOKEN_${clientSuffix}`;
-  }
-  getBasePathTokenName() {
-    const clientName = this.config.clientName || "default";
-    const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-    return `BASE_PATH_${clientSuffix}`;
-  }
-  hasDuplicateMethodNames(arr) {
-    return new Set(arr.map((method) => method.getName())).size !== arr.length;
-  }
 };
 
 // src/lib/generators/service/service-index.generator.ts
@@ -2497,6 +2405,14 @@ async function generateFromConfig(config) {
       const baseInterceptorGenerator = new BaseInterceptorGenerator(project, config.clientName);
       baseInterceptorGenerator.generate(outputPath);
     }
+    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);
+      }
+      console.log(`\u2705 Plugins are generated`);
+    }
     const mainIndexGenerator = new MainIndexGenerator(project, config);
     mainIndexGenerator.generateMainIndex(outputPath);
     const sourceInfo = `from ${inputType}: ${config.input}`;
@@ -2521,7 +2437,7 @@ async function generateFromConfig(config) {
 __name(generateFromConfig, "generateFromConfig");
 
 // package.json
-var version = "0.0.40";
+var version = "0.0.41";
 
 // src/lib/cli.ts
 var program = new import_commander.Command();