ng-openapi 0.0.21 → 0.0.23

package/cli.cjs

@@ -7,6 +7,10 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,8 +27,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/lib/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  generateFromOptions: () => generateFromOptions
+});
+module.exports = __toCommonJS(cli_exports);
 var import_commander = require("commander");
 var path8 = __toESM(require("path"));
 var fs4 = __toESM(require("fs"));
@@ -402,8 +412,10 @@ var TokenGenerator = class {
     __name(this, "TokenGenerator");
   }
   project;
-  constructor(project) {
+  config;
+  constructor(project, config) {
     this.project = project;
+    this.config = config;
   }
   generate(outputDir) {
     const tokensDir = path.join(outputDir, "tokens");
@@ -417,23 +429,55 @@ var TokenGenerator = class {
       ],
       moduleSpecifier: "@angular/core"
     });
+    const clientName = this.config.clientName || "DEFAULT";
+    const upperCaseClientName = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     sourceFile.addVariableStatement({
       isExported: true,
       declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
       declarations: [
         {
-          name: "BASE_PATH",
-          initializer: `new InjectionToken<string>('BASE_PATH', {
+          name: `${upperCaseClientName}_BASE_PATH`,
+          initializer: `new InjectionToken<string>('${upperCaseClientName}_BASE_PATH', {
   providedIn: 'root',
-  factory: () => '/api', // Default fallback
+  factory: () => '/api',
 })`
         }
       ],
       leadingTrivia: `/**
- * Injection token for the base API path
+ * Base path token for ${clientName} client
+ */
+`
+    });
+    sourceFile.addVariableStatement({
+      isExported: true,
+      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarations: [
+        {
+          name: `${upperCaseClientName}_HTTP_CLIENT`,
+          initializer: `new InjectionToken<HttpClient>('${upperCaseClientName}_HTTP_CLIENT')`
+        }
+      ],
+      leadingTrivia: `/**
+ * HTTP client token for ${clientName} client
  */
 `
     });
+    if (!this.config.clientName) {
+      sourceFile.addVariableStatement({
+        isExported: true,
+        declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+        declarations: [
+          {
+            name: "BASE_PATH",
+            initializer: `${upperCaseClientName}_BASE_PATH`
+          }
+        ],
+        leadingTrivia: `/**
+ * @deprecated Use ${upperCaseClientName}_BASE_PATH instead
+ */
+`
+      });
+    }
     sourceFile.saveSync();
   }
 };
@@ -799,6 +843,9 @@ function getTypeScriptType(schemaOrType, config, formatOrNullable, isNullable, c
   }
   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);
@@ -830,6 +877,10 @@ 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 {
@@ -1695,6 +1746,8 @@ var ServiceGenerator = class {
     });
   }
   addImports(sourceFile, usedTypes) {
+    const clientName = this.config.clientName || "DEFAULT";
+    const upperCaseClientName = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     sourceFile.addImportDeclarations([
       {
         namedImports: [
@@ -1722,11 +1775,15 @@ var ServiceGenerator = class {
       },
       {
         namedImports: [
-          "BASE_PATH"
+          `${upperCaseClientName}_BASE_PATH`,
+          `${upperCaseClientName}_HTTP_CLIENT`
         ],
         moduleSpecifier: "../tokens"
       }
     ]);
+    if (!this.config.clientName) {
+      sourceFile.getImportDeclaration("../tokens")?.addNamedImport("BASE_PATH");
+    }
     if (usedTypes.size > 0) {
       sourceFile.addImportDeclaration({
         namedImports: Array.from(usedTypes).sort(),
@@ -1736,6 +1793,8 @@ var ServiceGenerator = class {
   }
   addServiceClass(sourceFile, controllerName, operations) {
     const className = `${controllerName}Service`;
+    const clientName = this.config.clientName || "DEFAULT";
+    const upperCaseClientName = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     sourceFile.insertText(0, SERVICE_GENERATOR_HEADER_COMMENT(controllerName));
     const serviceClass = sourceFile.addClass({
       name: className,
@@ -1754,14 +1813,14 @@ var ServiceGenerator = class {
       type: "HttpClient",
       scope: import_ts_morph3.Scope.Private,
       isReadonly: true,
-      initializer: "inject(HttpClient)"
+      initializer: `inject(${upperCaseClientName}_HTTP_CLIENT, { optional: true }) ?? inject(HttpClient)`
     });
     serviceClass.addProperty({
       name: "basePath",
       type: "string",
       scope: import_ts_morph3.Scope.Private,
       isReadonly: true,
-      initializer: "inject(BASE_PATH)"
+      initializer: `inject(${upperCaseClientName}_BASE_PATH)`
     });
     operations.forEach((operation) => {
       this.methodGenerator.addServiceMethod(serviceClass, operation);
@@ -1825,24 +1884,34 @@ var ProviderGenerator = class {
       overwrite: true
     });
     sourceFile.insertText(0, PROVIDER_GENERATOR_HEADER_COMMENT);
+    const clientName = this.config.clientName || "Default";
+    const pascalClientName = this.pascalCase(clientName);
+    const upperCaseClientName = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     sourceFile.addImportDeclarations([
       {
         namedImports: [
           "EnvironmentProviders",
           "Provider",
-          "makeEnvironmentProviders"
+          "makeEnvironmentProviders",
+          "Type",
+          "Injector",
+          "inject"
         ],
         moduleSpecifier: "@angular/core"
       },
       {
         namedImports: [
-          "HTTP_INTERCEPTORS"
+          "HttpClient",
+          "HttpInterceptor",
+          "HttpHandler",
+          "HttpRequest"
         ],
         moduleSpecifier: "@angular/common/http"
       },
       {
         namedImports: [
-          "BASE_PATH"
+          `${upperCaseClientName}_BASE_PATH`,
+          `${upperCaseClientName}_HTTP_CLIENT`
         ],
         moduleSpecifier: "./tokens"
       }
@@ -1856,10 +1925,10 @@ var ProviderGenerator = class {
       });
     }
     sourceFile.addInterface({
-      name: "NgOpenapiConfig",
+      name: `${pascalClientName}Config`,
       isExported: true,
       docs: [
-        "Configuration options for ng-openapi providers"
+        `Configuration options for ${clientName} API client`
       ],
       properties: [
         {
@@ -1869,6 +1938,14 @@ var ProviderGenerator = class {
             "Base API URL"
           ]
         },
+        {
+          name: "interceptors",
+          type: "Type<HttpInterceptor>[]",
+          hasQuestionToken: true,
+          docs: [
+            "HTTP interceptors to apply to this client's requests"
+          ]
+        },
         {
           name: "enableDateTransform",
           type: "boolean",
@@ -1879,105 +1956,102 @@ var ProviderGenerator = class {
         }
       ]
     });
-    this.addMainProviderFunction(sourceFile);
-    this.addAsyncProviderFunction(sourceFile);
+    this.addInterceptorChainHelper(sourceFile);
+    this.addClientProviderFunction(sourceFile, pascalClientName, upperCaseClientName);
     sourceFile.saveSync();
   }
-  addMainProviderFunction(sourceFile) {
-    const hasDateInterceptor = this.config.options.dateType === "Date";
-    const functionBody = `
-const providers: Provider[] = [
-    // Base path token
-    {
-        provide: BASE_PATH,
-        useValue: config.basePath
-    }
-];
-
-${hasDateInterceptor ? `// Add date interceptor if enabled (default: true)
-if (config.enableDateTransform !== false) {
-    providers.push({
-        provide: HTTP_INTERCEPTORS,
-        useClass: DateInterceptor,
-        multi: true
-    });
-}` : `// Date transformation not available (dateType: 'string' was used in generation)`}
-
-return makeEnvironmentProviders(providers);`;
+  addInterceptorChainHelper(sourceFile) {
     sourceFile.addFunction({
-      name: "provideNgOpenapi",
-      isExported: true,
+      name: "createHttpClientWithInterceptors",
       docs: [
-        "Provides all necessary configuration for ng-openapi generated services",
-        "",
-        "@example",
-        "```typescript",
-        "// In your app.config.ts",
-        "import { provideNgOpenapi } from './api/providers';",
-        "",
-        "export const appConfig: ApplicationConfig = {",
-        "  providers: [",
-        "    provideNgOpenapi({",
-        "      basePath: 'https://api.example.com'",
-        "    }),",
-        "    // other providers...",
-        "  ]",
-        "};",
-        "```"
+        "Creates an HttpClient with a custom interceptor chain"
       ],
       parameters: [
         {
-          name: "config",
-          type: "NgOpenapiConfig"
+          name: "baseClient",
+          type: "HttpClient"
+        },
+        {
+          name: "interceptors",
+          type: "HttpInterceptor[]"
         }
       ],
-      returnType: "EnvironmentProviders",
-      statements: functionBody
+      returnType: "HttpClient",
+      statements: `
+if (!interceptors.length) {
+    return baseClient;
+}
+
+// Create a custom handler that applies interceptors in sequence
+let handler = baseClient.handler;
+
+// Apply interceptors in reverse order (last interceptor wraps the original handler)
+for (let i = interceptors.length - 1; i >= 0; i--) {
+    const currentHandler = handler;
+    const interceptor = interceptors[i];
+    
+    handler = {
+        handle: (req: HttpRequest<any>) => interceptor.intercept(req, currentHandler)
+    };
+}
+
+// Return a new HttpClient with the custom handler
+return new (baseClient.constructor as any)(handler);`
     });
   }
-  addAsyncProviderFunction(sourceFile) {
+  addClientProviderFunction(sourceFile, pascalClientName, upperCaseClientName) {
     const hasDateInterceptor = this.config.options.dateType === "Date";
     const functionBody = `
-const providers: Provider[] = [];
-
-// Handle async base path
-if (typeof config.basePath === 'string') {
-    providers.push({
-        provide: BASE_PATH,
+const providers: Provider[] = [
+    // Base path token
+    {
+        provide: ${upperCaseClientName}_BASE_PATH,
         useValue: config.basePath
-    });
-} else {
-    providers.push({
-        provide: BASE_PATH,
-        useFactory: config.basePath
-    });
-}
-
-${hasDateInterceptor ? `// Add date interceptor if enabled (default: true)
-if (config.enableDateTransform !== false) {
-    providers.push({
-        provide: HTTP_INTERCEPTORS,
-        useClass: DateInterceptor,
-        multi: true
-    });
-}` : `// Date transformation not available (dateType: 'string' was used in generation)`}
+    },
+    
+    // HTTP client with custom interceptors
+    {
+        provide: ${upperCaseClientName}_HTTP_CLIENT,
+        useFactory: (baseClient: HttpClient, injector: Injector) => {
+            const interceptorInstances: HttpInterceptor[] = [];
+            
+            // Add custom interceptors
+            if (config.interceptors?.length) {
+                config.interceptors.forEach(interceptorClass => {
+                    interceptorInstances.push(injector.get(interceptorClass));
+                });
+            }
+            
+            ${hasDateInterceptor ? `
+            // Add date interceptor if enabled (default: true)
+            if (config.enableDateTransform !== false) {
+                interceptorInstances.push(injector.get(DateInterceptor));
+            }` : ""}
+            
+            return createHttpClientWithInterceptors(baseClient, interceptorInstances);
+        },
+        deps: [HttpClient, Injector]
+    }
+];
 
 return makeEnvironmentProviders(providers);`;
     sourceFile.addFunction({
-      name: "provideNgOpenapiAsync",
+      name: `provide${pascalClientName}`,
       isExported: true,
       docs: [
-        "Alternative function for cases where you need to handle async configuration",
+        `Provides configuration for ${pascalClientName} API client`,
         "",
         "@example",
         "```typescript",
-        "// In your app.config.ts",
-        "import { provideNgOpenapiAsync } from './api/providers';",
+        `// In your app.config.ts`,
+        `import { provide${pascalClientName} } from './api/providers';`,
+        `import { AuthInterceptor } from './interceptors/auth.interceptor';`,
         "",
         "export const appConfig: ApplicationConfig = {",
         "  providers: [",
-        "    provideNgOpenapiAsync({",
-        "      basePath: () => import('./config').then(c => c.apiConfig.baseUrl)",
+        `    provide${pascalClientName}({`,
+        "      basePath: 'https://api.example.com',",
+        "      interceptors: [AuthInterceptor]",
         "    }),",
         "    // other providers...",
         "  ]",
@@ -1987,16 +2061,16 @@ return makeEnvironmentProviders(providers);`;
       parameters: [
         {
           name: "config",
-          type: `{
-  basePath: string | (() => Promise<string>);
-  enableDateTransform?: boolean;
-}`
+          type: `${pascalClientName}Config`
         }
       ],
       returnType: "EnvironmentProviders",
       statements: functionBody
     });
   }
+  pascalCase(str) {
+    return str.replace(/(?:^|[-_])([a-z])/g, (_, char) => char.toUpperCase());
+  }
 };
 
 // src/lib/core/generator.ts
@@ -2026,7 +2100,7 @@ async function generateFromConfig(config) {
     typeGenerator.generate();
     console.log(`\u2705 TypeScript interfaces generated`);
     if (generateServices) {
-      const tokenGenerator = new TokenGenerator(project);
+      const tokenGenerator = new TokenGenerator(project, config);
       tokenGenerator.generate(outputPath);
       if (config.options.dateType === "Date") {
         const dateTransformer = new DateTransformerGenerator(project);
@@ -2059,6 +2133,94 @@ async function generateFromConfig(config) {
 }
 __name(generateFromConfig, "generateFromConfig");
 
+// package.json
+var package_default = {
+  name: "ng-openapi",
+  version: "0.0.22",
+  description: "Generate Angular services and TypeScript types from OpenAPI/Swagger specifications",
+  keywords: [
+    "angular",
+    "openapi",
+    "swagger",
+    "codegen",
+    "typescript",
+    "generator",
+    "code-generator",
+    "api",
+    "rest",
+    "http",
+    "cli"
+  ],
+  author: {
+    name: "Tareq Jami",
+    email: "info@jami-it.de",
+    url: "http://tareqjami.de"
+  },
+  license: "MIT",
+  homepage: "https://ng-openapi.dev/",
+  bugs: {
+    url: "https://github.com/ng-openapi/ng-openapi/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ng-openapi/ng-openapi.git",
+    directory: "packages/ng-openapi"
+  },
+  funding: {
+    type: "github",
+    url: "https://github.com/sponsors/ng-openapi"
+  },
+  main: "./index.cjs",
+  module: "./index.js",
+  types: "./index.d.ts",
+  bin: {
+    "ng-openapi": "./cli.cjs"
+  },
+  files: [
+    "index.js",
+    "index.cjs",
+    "index.d.ts",
+    "cli.cjs",
+    "lib/**/*.js",
+    "lib/**/*.cjs",
+    "lib/**/*.d.ts",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  scripts: {
+    prepublishOnly: "echo 'Build the package using: npm run build:ng-openapi from workspace root'",
+    build: "tsup"
+  },
+  dependencies: {
+    commander: "^14.0.0",
+    "ts-morph": "^26.0.0",
+    "ts-node": "^10.9.2",
+    typescript: "^5.8.3",
+    "@types/swagger-schema-official": "^2.0.25"
+  },
+  peerDependencies: {
+    "@angular/core": ">=15",
+    "@angular/common": ">=15"
+  },
+  peerDependenciesMeta: {
+    "@angular/core": {
+      optional: false
+    },
+    "@angular/common": {
+      optional: false
+    }
+  },
+  engines: {
+    node: ">=18.0.0",
+    npm: ">=8.0.0"
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  }
+};
+
 // src/lib/cli.ts
 var program = new import_commander.Command();
 async function loadConfigFile(configPath) {
@@ -2085,17 +2247,19 @@ __name(loadConfigFile, "loadConfigFile");
 async function generateFromOptions(options) {
   try {
     if (options.config) {
-      const config = await loadConfigFile(options.config);
-      await generateFromConfig(config);
-    } else if (options.input) {
-      const inputPath = path8.resolve(options.input);
-      if (!fs4.existsSync(inputPath)) {
-        console.error(`Error: Input file not found: ${inputPath}`);
-        process.exit(1);
+      const configPaths = Array.isArray(options.config) ? options.config : [
+        options.config
+      ];
+      for (const configPath of configPaths) {
+        const config = await loadConfigFile(configPath);
+        await generateFromConfig(config);
+        console.log(`\u2728 Generated client: ${config.clientName || "default"}`);
       }
+    } else if (options.input) {
       const config = {
-        input: inputPath,
+        input: path8.resolve(options.input),
         output: options.output || "./src/generated",
+        clientName: options.clientName,
         options: {
           dateType: options.dateType || "Date",
           enumStyle: "enum",
@@ -2109,14 +2273,14 @@ async function generateFromOptions(options) {
       program.help();
       process.exit(1);
     }
-    console.log("\u2728 Generation completed successfully!");
+    console.log("\u2728 All clients generated successfully!");
   } catch (error) {
     console.error("\u274C Generation failed:", error instanceof Error ? error.message : error);
     process.exit(1);
   }
 }
 __name(generateFromOptions, "generateFromOptions");
-program.name("ng-openapi").description("Generate Angular services and types from Swagger/OpenAPI spec").version("0.0.1").option("-c, --config <path>", "Path to configuration file").option("-i, --input <path>", "Path to Swagger/OpenAPI specification file").option("-o, --output <path>", "Output directory", "./src/generated").option("--types-only", "Generate only TypeScript interfaces").option("--date-type <type>", "Date type to use (string | Date)", "Date").action(async (options) => {
+program.name("ng-openapi").description("Generate Angular services and types from Swagger/OpenAPI spec").version(package_default.version).option("-c, --config <path>", "Path to configuration file").option("-i, --input <path>", "Path to Swagger/OpenAPI specification file").option("-o, --output <path>", "Output directory", "./src/generated").option("--types-only", "Generate only TypeScript interfaces").option("--date-type <type>", "Date type to use (string | Date)", "Date").action(async (options) => {
   await generateFromOptions(options);
 });
 program.command("generate").alias("gen").description("Generate code from Swagger specification").option("-c, --config <path>", "Path to configuration file").option("-i, --input <path>", "Path to Swagger/OpenAPI specification file").option("-o, --output <path>", "Output directory", "./src/generated").option("--types-only", "Generate only TypeScript interfaces").option("--date-type <type>", "Date type to use (string | Date)", "Date").action(async (options) => {
@@ -2131,4 +2295,8 @@ program.on("--help", () => {
   console.log("  $ ng-openapi generate -i ./api.yaml --types-only");
 });
 program.parse();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateFromOptions
+});
 //# sourceMappingURL=cli.cjs.map

package/index.d.ts

@@ -21,12 +21,14 @@ interface TypeSchema {
     $ref?: string;
     items?: any;
     nullable?: boolean;
+    enum?: Array<string | number>;
     [key: string]: any;
 }
 
 interface GeneratorConfig {
     input: string;
     output: string;
+    clientName?: string;
     options: {
         dateType: "string" | "Date";
         enumStyle: "enum" | "union";

package/index.js

@@ -441,9 +441,11 @@ var TypeGenerator = _TypeGenerator;
 var import_ts_morph2 = require("ts-morph");
 var path = __toESM(require("path"));
 var _TokenGenerator = class _TokenGenerator {
-  constructor(project) {
+  constructor(project, config) {
     __publicField(this, "project");
+    __publicField(this, "config");
     this.project = project;
+    this.config = config;
   }
   generate(outputDir) {
     const tokensDir = path.join(outputDir, "tokens");
@@ -457,23 +459,55 @@ var _TokenGenerator = class _TokenGenerator {
       ],
       moduleSpecifier: "@angular/core"
     });
+    const clientName = this.config.clientName || "DEFAULT";
+    const upperCaseClientName = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     sourceFile.addVariableStatement({
       isExported: true,
       declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
       declarations: [
         {
-          name: "BASE_PATH",
-          initializer: `new InjectionToken<string>('BASE_PATH', {
+          name: `${upperCaseClientName}_BASE_PATH`,
+          initializer: `new InjectionToken<string>('${upperCaseClientName}_BASE_PATH', {
   providedIn: 'root',
-  factory: () => '/api', // Default fallback
+  factory: () => '/api',
 })`
         }
       ],
       leadingTrivia: `/**
- * Injection token for the base API path
+ * Base path token for ${clientName} client
+ */
+`
+    });
+    sourceFile.addVariableStatement({
+      isExported: true,
+      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarations: [
+        {
+          name: `${upperCaseClientName}_HTTP_CLIENT`,
+          initializer: `new InjectionToken<HttpClient>('${upperCaseClientName}_HTTP_CLIENT')`
+        }
+      ],
+      leadingTrivia: `/**
+ * HTTP client token for ${clientName} client
  */
 `
     });
+    if (!this.config.clientName) {
+      sourceFile.addVariableStatement({
+        isExported: true,
+        declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+        declarations: [
+          {
+            name: "BASE_PATH",
+            initializer: `${upperCaseClientName}_BASE_PATH`
+          }
+        ],
+        leadingTrivia: `/**
+ * @deprecated Use ${upperCaseClientName}_BASE_PATH instead
+ */
+`
+      });
+    }
     sourceFile.saveSync();
   }
 };
@@ -838,6 +872,9 @@ function getTypeScriptType(schemaOrType, config, formatOrNullable, isNullable, c
   }
   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);
@@ -869,6 +906,10 @@ 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 _ServiceMethodBodyGenerator {
@@ -1739,6 +1780,9 @@ var _ServiceGenerator = class _ServiceGenerator {
     });
   }
   addImports(sourceFile, usedTypes) {
+    var _a;
+    const clientName = this.config.clientName || "DEFAULT";
+    const upperCaseClientName = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     sourceFile.addImportDeclarations([
       {
         namedImports: [
@@ -1766,11 +1810,15 @@ var _ServiceGenerator = class _ServiceGenerator {
       },
       {
         namedImports: [
-          "BASE_PATH"
+          `${upperCaseClientName}_BASE_PATH`,
+          `${upperCaseClientName}_HTTP_CLIENT`
         ],
         moduleSpecifier: "../tokens"
       }
     ]);
+    if (!this.config.clientName) {
+      (_a = sourceFile.getImportDeclaration("../tokens")) == null ? void 0 : _a.addNamedImport("BASE_PATH");
+    }
     if (usedTypes.size > 0) {
       sourceFile.addImportDeclaration({
         namedImports: Array.from(usedTypes).sort(),
@@ -1780,6 +1828,8 @@ var _ServiceGenerator = class _ServiceGenerator {
   }
   addServiceClass(sourceFile, controllerName, operations) {
     const className = `${controllerName}Service`;
+    const clientName = this.config.clientName || "DEFAULT";
+    const upperCaseClientName = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     sourceFile.insertText(0, SERVICE_GENERATOR_HEADER_COMMENT(controllerName));
     const serviceClass = sourceFile.addClass({
       name: className,
@@ -1798,14 +1848,14 @@ var _ServiceGenerator = class _ServiceGenerator {
       type: "HttpClient",
       scope: import_ts_morph3.Scope.Private,
       isReadonly: true,
-      initializer: "inject(HttpClient)"
+      initializer: `inject(${upperCaseClientName}_HTTP_CLIENT, { optional: true }) ?? inject(HttpClient)`
     });
     serviceClass.addProperty({
       name: "basePath",
       type: "string",
       scope: import_ts_morph3.Scope.Private,
       isReadonly: true,
-      initializer: "inject(BASE_PATH)"
+      initializer: `inject(${upperCaseClientName}_BASE_PATH)`
     });
     operations.forEach((operation) => {
       this.methodGenerator.addServiceMethod(serviceClass, operation);
@@ -1867,24 +1917,34 @@ var _ProviderGenerator = class _ProviderGenerator {
       overwrite: true
     });
     sourceFile.insertText(0, PROVIDER_GENERATOR_HEADER_COMMENT);
+    const clientName = this.config.clientName || "Default";
+    const pascalClientName = this.pascalCase(clientName);
+    const upperCaseClientName = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     sourceFile.addImportDeclarations([
       {
         namedImports: [
           "EnvironmentProviders",
           "Provider",
-          "makeEnvironmentProviders"
+          "makeEnvironmentProviders",
+          "Type",
+          "Injector",
+          "inject"
         ],
         moduleSpecifier: "@angular/core"
       },
       {
         namedImports: [
-          "HTTP_INTERCEPTORS"
+          "HttpClient",
+          "HttpInterceptor",
+          "HttpHandler",
+          "HttpRequest"
         ],
         moduleSpecifier: "@angular/common/http"
       },
       {
         namedImports: [
-          "BASE_PATH"
+          `${upperCaseClientName}_BASE_PATH`,
+          `${upperCaseClientName}_HTTP_CLIENT`
         ],
         moduleSpecifier: "./tokens"
       }
@@ -1898,10 +1958,10 @@ var _ProviderGenerator = class _ProviderGenerator {
       });
     }
     sourceFile.addInterface({
-      name: "NgOpenapiConfig",
+      name: `${pascalClientName}Config`,
       isExported: true,
       docs: [
-        "Configuration options for ng-openapi providers"
+        `Configuration options for ${clientName} API client`
       ],
       properties: [
         {
@@ -1911,6 +1971,14 @@ var _ProviderGenerator = class _ProviderGenerator {
             "Base API URL"
           ]
         },
+        {
+          name: "interceptors",
+          type: "Type<HttpInterceptor>[]",
+          hasQuestionToken: true,
+          docs: [
+            "HTTP interceptors to apply to this client's requests"
+          ]
+        },
         {
           name: "enableDateTransform",
           type: "boolean",
@@ -1921,105 +1989,102 @@ var _ProviderGenerator = class _ProviderGenerator {
         }
       ]
     });
-    this.addMainProviderFunction(sourceFile);
-    this.addAsyncProviderFunction(sourceFile);
+    this.addInterceptorChainHelper(sourceFile);
+    this.addClientProviderFunction(sourceFile, pascalClientName, upperCaseClientName);
     sourceFile.saveSync();
   }
-  addMainProviderFunction(sourceFile) {
-    const hasDateInterceptor = this.config.options.dateType === "Date";
-    const functionBody = `
-const providers: Provider[] = [
-    // Base path token
-    {
-        provide: BASE_PATH,
-        useValue: config.basePath
-    }
-];
-
-${hasDateInterceptor ? `// Add date interceptor if enabled (default: true)
-if (config.enableDateTransform !== false) {
-    providers.push({
-        provide: HTTP_INTERCEPTORS,
-        useClass: DateInterceptor,
-        multi: true
-    });
-}` : `// Date transformation not available (dateType: 'string' was used in generation)`}
-
-return makeEnvironmentProviders(providers);`;
+  addInterceptorChainHelper(sourceFile) {
     sourceFile.addFunction({
-      name: "provideNgOpenapi",
-      isExported: true,
+      name: "createHttpClientWithInterceptors",
       docs: [
-        "Provides all necessary configuration for ng-openapi generated services",
-        "",
-        "@example",
-        "```typescript",
-        "// In your app.config.ts",
-        "import { provideNgOpenapi } from './api/providers';",
-        "",
-        "export const appConfig: ApplicationConfig = {",
-        "  providers: [",
-        "    provideNgOpenapi({",
-        "      basePath: 'https://api.example.com'",
-        "    }),",
-        "    // other providers...",
-        "  ]",
-        "};",
-        "```"
+        "Creates an HttpClient with a custom interceptor chain"
       ],
       parameters: [
         {
-          name: "config",
-          type: "NgOpenapiConfig"
+          name: "baseClient",
+          type: "HttpClient"
+        },
+        {
+          name: "interceptors",
+          type: "HttpInterceptor[]"
         }
       ],
-      returnType: "EnvironmentProviders",
-      statements: functionBody
+      returnType: "HttpClient",
+      statements: `
+if (!interceptors.length) {
+    return baseClient;
+}
+
+// Create a custom handler that applies interceptors in sequence
+let handler = baseClient.handler;
+
+// Apply interceptors in reverse order (last interceptor wraps the original handler)
+for (let i = interceptors.length - 1; i >= 0; i--) {
+    const currentHandler = handler;
+    const interceptor = interceptors[i];
+    
+    handler = {
+        handle: (req: HttpRequest<any>) => interceptor.intercept(req, currentHandler)
+    };
+}
+
+// Return a new HttpClient with the custom handler
+return new (baseClient.constructor as any)(handler);`
     });
   }
-  addAsyncProviderFunction(sourceFile) {
+  addClientProviderFunction(sourceFile, pascalClientName, upperCaseClientName) {
     const hasDateInterceptor = this.config.options.dateType === "Date";
     const functionBody = `
-const providers: Provider[] = [];
-
-// Handle async base path
-if (typeof config.basePath === 'string') {
-    providers.push({
-        provide: BASE_PATH,
+const providers: Provider[] = [
+    // Base path token
+    {
+        provide: ${upperCaseClientName}_BASE_PATH,
         useValue: config.basePath
-    });
-} else {
-    providers.push({
-        provide: BASE_PATH,
-        useFactory: config.basePath
-    });
-}
-
-${hasDateInterceptor ? `// Add date interceptor if enabled (default: true)
-if (config.enableDateTransform !== false) {
-    providers.push({
-        provide: HTTP_INTERCEPTORS,
-        useClass: DateInterceptor,
-        multi: true
-    });
-}` : `// Date transformation not available (dateType: 'string' was used in generation)`}
+    },
+    
+    // HTTP client with custom interceptors
+    {
+        provide: ${upperCaseClientName}_HTTP_CLIENT,
+        useFactory: (baseClient: HttpClient, injector: Injector) => {
+            const interceptorInstances: HttpInterceptor[] = [];
+            
+            // Add custom interceptors
+            if (config.interceptors?.length) {
+                config.interceptors.forEach(interceptorClass => {
+                    interceptorInstances.push(injector.get(interceptorClass));
+                });
+            }
+            
+            ${hasDateInterceptor ? `
+            // Add date interceptor if enabled (default: true)
+            if (config.enableDateTransform !== false) {
+                interceptorInstances.push(injector.get(DateInterceptor));
+            }` : ""}
+            
+            return createHttpClientWithInterceptors(baseClient, interceptorInstances);
+        },
+        deps: [HttpClient, Injector]
+    }
+];
 
 return makeEnvironmentProviders(providers);`;
     sourceFile.addFunction({
-      name: "provideNgOpenapiAsync",
+      name: `provide${pascalClientName}`,
       isExported: true,
       docs: [
-        "Alternative function for cases where you need to handle async configuration",
+        `Provides configuration for ${pascalClientName} API client`,
         "",
         "@example",
         "```typescript",
-        "// In your app.config.ts",
-        "import { provideNgOpenapiAsync } from './api/providers';",
+        `// In your app.config.ts`,
+        `import { provide${pascalClientName} } from './api/providers';`,
+        `import { AuthInterceptor } from './interceptors/auth.interceptor';`,
         "",
         "export const appConfig: ApplicationConfig = {",
         "  providers: [",
-        "    provideNgOpenapiAsync({",
-        "      basePath: () => import('./config').then(c => c.apiConfig.baseUrl)",
+        `    provide${pascalClientName}({`,
+        "      basePath: 'https://api.example.com',",
+        "      interceptors: [AuthInterceptor]",
         "    }),",
         "    // other providers...",
         "  ]",
@@ -2029,16 +2094,16 @@ return makeEnvironmentProviders(providers);`;
       parameters: [
         {
           name: "config",
-          type: `{
-  basePath: string | (() => Promise<string>);
-  enableDateTransform?: boolean;
-}`
+          type: `${pascalClientName}Config`
         }
       ],
       returnType: "EnvironmentProviders",
       statements: functionBody
     });
   }
+  pascalCase(str) {
+    return str.replace(/(?:^|[-_])([a-z])/g, (_, char) => char.toUpperCase());
+  }
 };
 __name(_ProviderGenerator, "ProviderGenerator");
 var ProviderGenerator = _ProviderGenerator;
@@ -2071,7 +2136,7 @@ function generateFromConfig(config) {
       typeGenerator.generate();
       console.log(`\u2705 TypeScript interfaces generated`);
       if (generateServices) {
-        const tokenGenerator = new TokenGenerator(project);
+        const tokenGenerator = new TokenGenerator(project, config);
         tokenGenerator.generate(outputPath);
         if (config.options.dateType === "Date") {
           const dateTransformer = new DateTransformerGenerator(project);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-openapi",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "Generate Angular services and TypeScript types from OpenAPI/Swagger specifications",
   "keywords": [
     "angular",