ng-openapi 0.0.40 → 0.0.41-pr-8-feature-url-support-7d492ee.0

package/cli.cjs

@@ -33,14 +33,117 @@ var fs4 = __toESM(require("fs"));
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var yaml = __toESM(require("js-yaml"));
-var SwaggerParser = class {
+var SwaggerParser = class _SwaggerParser {
   static {
     __name(this, "SwaggerParser");
   }
   spec;
-  constructor(swaggerPath) {
-    const swaggerContent = fs.readFileSync(swaggerPath, "utf8");
-    this.spec = this.parseSpecFile(swaggerContent, swaggerPath);
+  constructor(spec, config) {
+    const generateClient = config.generateClientIf?.(spec) ?? true;
+    if (!generateClient) {
+      throw new Error("Client generation is disabled by configuration. Check your `generateClientIf` condition.");
+    }
+    this.spec = spec;
+  }
+  static async create(swaggerPathOrUrl, config) {
+    const swaggerContent = await _SwaggerParser.loadContent(swaggerPathOrUrl);
+    const spec = _SwaggerParser.parseSpecContent(swaggerContent, swaggerPathOrUrl);
+    return new _SwaggerParser(spec, config);
+  }
+  static async loadContent(pathOrUrl) {
+    if (_SwaggerParser.isUrl(pathOrUrl)) {
+      return await _SwaggerParser.fetchUrlContent(pathOrUrl);
+    } else {
+      return fs.readFileSync(pathOrUrl, "utf8");
+    }
+  }
+  static isUrl(input) {
+    try {
+      new URL(input);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  static async fetchUrlContent(url) {
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Accept": "application/json, application/yaml, text/yaml, text/plain, */*",
+          "User-Agent": "ng-openapi"
+        },
+        // 30 second timeout
+        signal: AbortSignal.timeout(3e4)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const content = await response.text();
+      if (!content || content.trim() === "") {
+        throw new Error(`Empty response from URL: ${url}`);
+      }
+      return content;
+    } catch (error) {
+      let errorMessage = `Failed to fetch content from URL: ${url}`;
+      if (error.name === "AbortError") {
+        errorMessage += " - Request timeout (30s)";
+      } else if (error.message) {
+        errorMessage += ` - ${error.message}`;
+      }
+      throw new Error(errorMessage);
+    }
+  }
+  static parseSpecContent(content, pathOrUrl) {
+    let format;
+    if (_SwaggerParser.isUrl(pathOrUrl)) {
+      const urlPath = new URL(pathOrUrl).pathname.toLowerCase();
+      if (urlPath.endsWith(".json")) {
+        format = "json";
+      } else if (urlPath.endsWith(".yaml") || urlPath.endsWith(".yml")) {
+        format = "yaml";
+      } else {
+        format = _SwaggerParser.detectFormat(content);
+      }
+    } else {
+      const extension = path.extname(pathOrUrl).toLowerCase();
+      switch (extension) {
+        case ".json":
+          format = "json";
+          break;
+        case ".yaml":
+          format = "yaml";
+          break;
+        case ".yml":
+          format = "yml";
+          break;
+        default:
+          format = _SwaggerParser.detectFormat(content);
+      }
+    }
+    try {
+      switch (format) {
+        case "json":
+          return JSON.parse(content);
+        case "yaml":
+        case "yml":
+          return yaml.load(content);
+        default:
+          throw new Error(`Unable to determine format for: ${pathOrUrl}`);
+      }
+    } catch (error) {
+      throw new Error(`Failed to parse ${format.toUpperCase()} content from: ${pathOrUrl}. Error: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  static detectFormat(content) {
+    const trimmed = content.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      return "json";
+    }
+    if (trimmed.includes("openapi:") || trimmed.includes("swagger:") || trimmed.includes("---") || /^[a-zA-Z][a-zA-Z0-9_]*\s*:/.test(trimmed)) {
+      return "yaml";
+    }
+    return "json";
   }
   getDefinitions() {
     return this.spec.definitions || this.spec.components?.schemas || {};
@@ -81,18 +184,6 @@ var SwaggerParser = class {
     }
     return null;
   }
-  parseSpecFile(content, filePath) {
-    const extension = path.extname(filePath).toLowerCase();
-    switch (extension) {
-      case ".json":
-        return JSON.parse(content);
-      case ".yaml":
-      case ".yml":
-        return yaml.load(content);
-      default:
-        throw new Error(`Failed to parse ${extension || "specification"} file: ${filePath}. Supported formats are .json, .yaml, and .yml.`);
-    }
-  }
 };
 
 // src/lib/core/generator.ts
@@ -137,7 +228,7 @@ var BASE_INTERCEPTOR_HEADER_COMMENT = /* @__PURE__ */ __name((clientName) => def
 `, "BASE_INTERCEPTOR_HEADER_COMMENT");
 
 // src/lib/generators/type/type.generator.ts
-var TypeGenerator = class {
+var TypeGenerator = class _TypeGenerator {
   static {
     __name(this, "TypeGenerator");
   }
@@ -146,7 +237,7 @@ var TypeGenerator = class {
   sourceFile;
   generatedTypes = /* @__PURE__ */ new Set();
   config;
-  constructor(swaggerPath, outputRoot, config) {
+  constructor(parser, outputRoot, config) {
     this.config = config;
     const outputPath = outputRoot + "/models/index.ts";
     this.project = new import_ts_morph.Project({
@@ -158,15 +249,14 @@ var TypeGenerator = class {
         ...this.config.compilerOptions
       }
     });
-    try {
-      this.parser = new SwaggerParser(swaggerPath);
-      this.sourceFile = this.project.createSourceFile(outputPath, "", {
-        overwrite: true
-      });
-    } catch (error) {
-      console.error("Error initializing TypeGenerator:", error);
-      throw error;
-    }
+    this.parser = parser;
+    this.sourceFile = this.project.createSourceFile(outputPath, "", {
+      overwrite: true
+    });
+  }
+  static async create(swaggerPathOrUrl, outputRoot, config) {
+    const parser = await SwaggerParser.create(swaggerPathOrUrl, config);
+    return new _TypeGenerator(parser, outputRoot, config);
   }
   generate() {
     try {
@@ -2008,7 +2098,7 @@ var ServiceMethodGenerator = class {
 };
 
 // src/lib/generators/service/service.generator.ts
-var ServiceGenerator = class {
+var ServiceGenerator = class _ServiceGenerator {
   static {
     __name(this, "ServiceGenerator");
   }
@@ -2017,10 +2107,10 @@ var ServiceGenerator = class {
   spec;
   config;
   methodGenerator;
-  constructor(swaggerPath, project, config) {
+  constructor(parser, project, config) {
     this.config = config;
     this.project = project;
-    this.parser = new SwaggerParser(swaggerPath);
+    this.parser = parser;
     this.spec = this.parser.getSpec();
     if (!this.parser.isValidSpec()) {
       const versionInfo = this.parser.getSpecVersion();
@@ -2028,6 +2118,10 @@ var ServiceGenerator = class {
     }
     this.methodGenerator = new ServiceMethodGenerator(config);
   }
+  static async create(swaggerPathOrUrl, project, config) {
+    const parser = await SwaggerParser.create(swaggerPathOrUrl, config);
+    return new _ServiceGenerator(parser, project, config);
+  }
   generate(outputRoot) {
     const outputDir = path8.join(outputRoot, "services");
     const paths = this.extractPaths();
@@ -2335,12 +2429,36 @@ var ServiceIndexGenerator = class {
 
 // src/lib/core/generator.ts
 var fs3 = __toESM(require("fs"));
-async function generateFromConfig(config) {
-  if (!fs3.existsSync(config.input)) {
-    throw new Error(`Input file not found: ${config.input}`);
+function isUrl(input) {
+  try {
+    new URL(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isUrl, "isUrl");
+function validateInput(input) {
+  if (isUrl(input)) {
+    const url = new URL(input);
+    if (![
+      "http:",
+      "https:"
+    ].includes(url.protocol)) {
+      throw new Error(`Unsupported URL protocol: ${url.protocol}. Only HTTP and HTTPS are supported.`);
+    }
+  } else {
+    if (!fs3.existsSync(input)) {
+      throw new Error(`Input file not found: ${input}`);
+    }
   }
+}
+__name(validateInput, "validateInput");
+async function generateFromConfig(config) {
+  validateInput(config.input);
   const outputPath = config.output;
   const generateServices = config.options.generateServices ?? true;
+  const inputType = isUrl(config.input) ? "URL" : "file";
   if (!fs3.existsSync(outputPath)) {
     fs3.mkdirSync(outputPath, {
       recursive: true
@@ -2356,7 +2474,8 @@ async function generateFromConfig(config) {
         ...config.compilerOptions
       }
     });
-    const typeGenerator = new TypeGenerator(config.input, outputPath, config);
+    console.log(`\u{1F4E1} Processing OpenAPI specification from ${inputType}: ${config.input}`);
+    const typeGenerator = await TypeGenerator.create(config.input, outputPath, config);
     typeGenerator.generate();
     console.log(`\u2705 TypeScript interfaces generated`);
     if (generateServices) {
@@ -2368,7 +2487,7 @@ async function generateFromConfig(config) {
       }
       const fileDownloadHelper = new FileDownloadGenerator(project);
       fileDownloadHelper.generate(outputPath);
-      const serviceGenerator = new ServiceGenerator(config.input, project, config);
+      const serviceGenerator = await ServiceGenerator.create(config.input, project, config);
       serviceGenerator.generate(outputPath);
       const indexGenerator = new ServiceIndexGenerator(project);
       indexGenerator.generateIndex(outputPath);
@@ -2380,14 +2499,19 @@ async function generateFromConfig(config) {
     }
     const mainIndexGenerator = new MainIndexGenerator(project, config);
     mainIndexGenerator.generateMainIndex(outputPath);
+    const sourceInfo = `from ${inputType}: ${config.input}`;
     if (config.clientName) {
-      console.log(`\u{1F389} ${config.clientName} Generation completed successfully at: ${outputPath}`);
+      console.log(`\u{1F389} ${config.clientName} Generation completed successfully ${sourceInfo} -> ${outputPath}`);
     } else {
-      console.log("\u{1F389} Generation completed successfully at:", outputPath);
+      console.log(`\u{1F389} Generation completed successfully ${sourceInfo} -> ${outputPath}`);
     }
   } catch (error) {
     if (error instanceof Error) {
       console.error("\u274C Error during generation:", error.message);
+      if (error.message.includes("fetch") || error.message.includes("Failed to fetch")) {
+        console.error("\u{1F4A1} Tip: Make sure the URL is accessible and returns a valid OpenAPI/Swagger specification");
+        console.error("\u{1F4A1} Alternative: Download the specification file locally and use the file path instead");
+      }
     } else {
       console.error("\u274C Unknown error during generation:", error);
     }
@@ -2397,7 +2521,7 @@ async function generateFromConfig(config) {
 __name(generateFromConfig, "generateFromConfig");
 
 // package.json
-var version = "0.0.39";
+var version = "0.0.40";
 
 // src/lib/cli.ts
 var program = new import_commander.Command();
@@ -2422,7 +2546,26 @@ async function loadConfigFile(configPath) {
   }
 }
 __name(loadConfigFile, "loadConfigFile");
-function validateInputFile(inputPath) {
+function isUrl2(input) {
+  try {
+    new URL(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isUrl2, "isUrl");
+function validateInput2(inputPath) {
+  if (isUrl2(inputPath)) {
+    const url = new URL(inputPath);
+    if (![
+      "http:",
+      "https:"
+    ].includes(url.protocol)) {
+      throw new Error(`Unsupported URL protocol: ${url.protocol}. Only HTTP and HTTPS are supported.`);
+    }
+    return;
+  }
   if (!fs4.existsSync(inputPath)) {
     throw new Error(`Input file not found: ${inputPath}`);
   }
@@ -2436,18 +2579,17 @@ function validateInputFile(inputPath) {
     throw new Error(`Failed to parse ${extension || "specification"}. Supported formats are .json, .yaml, and .yml.`);
   }
 }
-__name(validateInputFile, "validateInputFile");
+__name(validateInput2, "validateInput");
 async function generateFromOptions(options) {
   try {
     if (options.config) {
       const config = await loadConfigFile(options.config);
-      validateInputFile(path10.resolve(config.input));
+      validateInput2(config.input);
       await generateFromConfig(config);
     } else if (options.input) {
-      const inputPath = path10.resolve(options.input);
-      validateInputFile(inputPath);
+      validateInput2(options.input);
       const config = {
-        input: inputPath,
+        input: options.input,
         output: options.output || "./src/generated",
         options: {
           dateType: options.dateType || "Date",
@@ -2469,10 +2611,10 @@ async function generateFromOptions(options) {
   }
 }
 __name(generateFromOptions, "generateFromOptions");
-program.name("ng-openapi").description("Generate Angular services and types from OpenAPI/Swagger specifications (JSON, YAML, YML)").version(version).option("-c, --config <path>", "Path to configuration file").option("-i, --input <path>", "Path to OpenAPI/Swagger specification file (.json, .yaml, .yml)").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 OpenAPI/Swagger specifications (JSON, YAML, YML) from files or URLs").version(version).option("-c, --config <path>", "Path to configuration file").option("-i, --input <path>", "Path or URL to OpenAPI/Swagger specification (.json, .yaml, .yml)").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 OpenAPI/Swagger specification").option("-c, --config <path>", "Path to configuration file").option("-i, --input <path>", "Path to OpenAPI/Swagger specification file (.json, .yaml, .yml)").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.command("generate").alias("gen").description("Generate code from OpenAPI/Swagger specification").option("-c, --config <path>", "Path to configuration file").option("-i, --input <path>", "Path or URL to OpenAPI/Swagger specification (.json, .yaml, .yml)").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.on("--help", () => {
@@ -2482,8 +2624,10 @@ program.on("--help", () => {
   console.log("  $ ng-openapi -i ./swagger.json -o ./src/api");
   console.log("  $ ng-openapi -i ./openapi.yaml -o ./src/api");
   console.log("  $ ng-openapi -i ./api-spec.yml -o ./src/api");
+  console.log("  $ ng-openapi -i https://api.example.com/openapi.json -o ./src/api");
+  console.log("  $ ng-openapi -i https://petstore.swagger.io/v2/swagger.json -o ./src/api");
   console.log("  $ ng-openapi generate -c ./openapi.config.ts");
-  console.log("  $ ng-openapi generate -i ./api.yaml --types-only");
+  console.log("  $ ng-openapi generate -i https://api.example.com/swagger.yaml --types-only");
 });
 program.parse();
 //# sourceMappingURL=cli.cjs.map

package/index.d.ts

@@ -1,6 +1,6 @@
-import { ParameterType, XML, ExternalDocs, Info, Path, BodyParameter, QueryParameter, Security, Tag } from 'swagger-schema-official';
 import { ScriptTarget, ModuleKind } from 'ts-morph';
 import { HttpInterceptor } from '@angular/common/http';
+import { Info, ExternalDocs, Path, ParameterType, XML, BodyParameter, QueryParameter, Security, Tag } from 'swagger-schema-official';
 
 interface MethodGenerationContext {
     pathParams: Array<{
@@ -26,35 +26,6 @@ interface TypeSchema {
     [key: string]: any;
 }
 
-interface GeneratorConfig {
-    input: string;
-    output: string;
-    clientName?: string;
-    options: {
-        dateType: "string" | "Date";
-        enumStyle: "enum" | "union";
-        generateServices?: boolean;
-        generateEnumBasedOnDescription?: boolean;
-        customHeaders?: Record<string, string>;
-        responseTypeMapping?: {
-            [contentType: string]: "json" | "blob" | "arraybuffer" | "text";
-        };
-        customizeMethodName?: (operationId: string) => string;
-    };
-    compilerOptions?: {
-        declaration?: boolean;
-        target?: ScriptTarget;
-        module?: ModuleKind;
-        strict?: boolean;
-    };
-}
-interface NgOpenapiClientConfig {
-    clientName: string;
-    basePath: string;
-    enableDateTransform?: boolean;
-    interceptors?: (new (...args: HttpInterceptor[]) => HttpInterceptor)[];
-}
-
 interface Parameter {
     name: string;
     in: "query" | "path" | "header" | "cookie";
@@ -162,9 +133,45 @@ type EnumValueObject = {
     Value: number;
 };
 
+interface GeneratorConfig {
+    input: string;
+    output: string;
+    clientName?: string;
+    generateClientIf?: (swaggerSpec: SwaggerSpec) => boolean;
+    options: {
+        dateType: "string" | "Date";
+        enumStyle: "enum" | "union";
+        generateServices?: boolean;
+        generateEnumBasedOnDescription?: boolean;
+        customHeaders?: Record<string, string>;
+        responseTypeMapping?: {
+            [contentType: string]: "json" | "blob" | "arraybuffer" | "text";
+        };
+        customizeMethodName?: (operationId: string) => string;
+    };
+    compilerOptions?: {
+        declaration?: boolean;
+        target?: ScriptTarget;
+        module?: ModuleKind;
+        strict?: boolean;
+    };
+}
+interface NgOpenapiClientConfig {
+    clientName: string;
+    basePath: string;
+    enableDateTransform?: boolean;
+    interceptors?: (new (...args: HttpInterceptor[]) => HttpInterceptor)[];
+}
+
 declare class SwaggerParser {
     private readonly spec;
-    constructor(swaggerPath: string);
+    private constructor();
+    static create(swaggerPathOrUrl: string, config: GeneratorConfig): Promise<SwaggerParser>;
+    private static loadContent;
+    private static isUrl;
+    private static fetchUrlContent;
+    private static parseSpecContent;
+    private static detectFormat;
     getDefinitions(): Record<string, SwaggerDefinition>;
     getDefinition(name: string): SwaggerDefinition | undefined;
     resolveReference(ref: string): SwaggerDefinition | undefined;
@@ -176,7 +183,6 @@ declare class SwaggerParser {
         type: "swagger" | "openapi";
         version: string;
     } | null;
-    private parseSpecFile;
 }
 
 /**

package/index.js

@@ -83,10 +83,120 @@ var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var yaml = __toESM(require("js-yaml"));
 var _SwaggerParser = class _SwaggerParser {
-  constructor(swaggerPath) {
+  constructor(spec, config) {
     __publicField(this, "spec");
-    const swaggerContent = fs.readFileSync(swaggerPath, "utf8");
-    this.spec = this.parseSpecFile(swaggerContent, swaggerPath);
+    var _a, _b;
+    const generateClient = (_b = (_a = config.generateClientIf) == null ? void 0 : _a.call(config, spec)) != null ? _b : true;
+    if (!generateClient) {
+      throw new Error("Client generation is disabled by configuration. Check your `generateClientIf` condition.");
+    }
+    this.spec = spec;
+  }
+  static create(swaggerPathOrUrl, config) {
+    return __async(this, null, function* () {
+      const swaggerContent = yield _SwaggerParser.loadContent(swaggerPathOrUrl);
+      const spec = _SwaggerParser.parseSpecContent(swaggerContent, swaggerPathOrUrl);
+      return new _SwaggerParser(spec, config);
+    });
+  }
+  static loadContent(pathOrUrl) {
+    return __async(this, null, function* () {
+      if (_SwaggerParser.isUrl(pathOrUrl)) {
+        return yield _SwaggerParser.fetchUrlContent(pathOrUrl);
+      } else {
+        return fs.readFileSync(pathOrUrl, "utf8");
+      }
+    });
+  }
+  static isUrl(input) {
+    try {
+      new URL(input);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  static fetchUrlContent(url) {
+    return __async(this, null, function* () {
+      try {
+        const response = yield fetch(url, {
+          method: "GET",
+          headers: {
+            "Accept": "application/json, application/yaml, text/yaml, text/plain, */*",
+            "User-Agent": "ng-openapi"
+          },
+          // 30 second timeout
+          signal: AbortSignal.timeout(3e4)
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const content = yield response.text();
+        if (!content || content.trim() === "") {
+          throw new Error(`Empty response from URL: ${url}`);
+        }
+        return content;
+      } catch (error) {
+        let errorMessage = `Failed to fetch content from URL: ${url}`;
+        if (error.name === "AbortError") {
+          errorMessage += " - Request timeout (30s)";
+        } else if (error.message) {
+          errorMessage += ` - ${error.message}`;
+        }
+        throw new Error(errorMessage);
+      }
+    });
+  }
+  static parseSpecContent(content, pathOrUrl) {
+    let format;
+    if (_SwaggerParser.isUrl(pathOrUrl)) {
+      const urlPath = new URL(pathOrUrl).pathname.toLowerCase();
+      if (urlPath.endsWith(".json")) {
+        format = "json";
+      } else if (urlPath.endsWith(".yaml") || urlPath.endsWith(".yml")) {
+        format = "yaml";
+      } else {
+        format = _SwaggerParser.detectFormat(content);
+      }
+    } else {
+      const extension = path.extname(pathOrUrl).toLowerCase();
+      switch (extension) {
+        case ".json":
+          format = "json";
+          break;
+        case ".yaml":
+          format = "yaml";
+          break;
+        case ".yml":
+          format = "yml";
+          break;
+        default:
+          format = _SwaggerParser.detectFormat(content);
+      }
+    }
+    try {
+      switch (format) {
+        case "json":
+          return JSON.parse(content);
+        case "yaml":
+        case "yml":
+          return yaml.load(content);
+        default:
+          throw new Error(`Unable to determine format for: ${pathOrUrl}`);
+      }
+    } catch (error) {
+      throw new Error(`Failed to parse ${format.toUpperCase()} content from: ${pathOrUrl}. Error: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  static detectFormat(content) {
+    const trimmed = content.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      return "json";
+    }
+    if (trimmed.includes("openapi:") || trimmed.includes("swagger:") || trimmed.includes("---") || /^[a-zA-Z][a-zA-Z0-9_]*\s*:/.test(trimmed)) {
+      return "yaml";
+    }
+    return "json";
   }
   getDefinitions() {
     var _a;
@@ -128,18 +238,6 @@ var _SwaggerParser = class _SwaggerParser {
     }
     return null;
   }
-  parseSpecFile(content, filePath) {
-    const extension = path.extname(filePath).toLowerCase();
-    switch (extension) {
-      case ".json":
-        return JSON.parse(content);
-      case ".yaml":
-      case ".yml":
-        return yaml.load(content);
-      default:
-        throw new Error(`Failed to parse ${extension || "specification"} file: ${filePath}. Supported formats are .json, .yaml, and .yml.`);
-    }
-  }
 };
 __name(_SwaggerParser, "SwaggerParser");
 var SwaggerParser = _SwaggerParser;
@@ -187,7 +285,7 @@ var BASE_INTERCEPTOR_HEADER_COMMENT = /* @__PURE__ */ __name((clientName) => def
 
 // src/lib/generators/type/type.generator.ts
 var _TypeGenerator = class _TypeGenerator {
-  constructor(swaggerPath, outputRoot, config) {
+  constructor(parser, outputRoot, config) {
     __publicField(this, "project");
     __publicField(this, "parser");
     __publicField(this, "sourceFile");
@@ -203,15 +301,16 @@ var _TypeGenerator = class _TypeGenerator {
         strict: true
       }, this.config.compilerOptions)
     });
-    try {
-      this.parser = new SwaggerParser(swaggerPath);
-      this.sourceFile = this.project.createSourceFile(outputPath, "", {
-        overwrite: true
-      });
-    } catch (error) {
-      console.error("Error initializing TypeGenerator:", error);
-      throw error;
-    }
+    this.parser = parser;
+    this.sourceFile = this.project.createSourceFile(outputPath, "", {
+      overwrite: true
+    });
+  }
+  static create(swaggerPathOrUrl, outputRoot, config) {
+    return __async(this, null, function* () {
+      const parser = yield SwaggerParser.create(swaggerPathOrUrl, config);
+      return new _TypeGenerator(parser, outputRoot, config);
+    });
   }
   generate() {
     try {
@@ -2063,7 +2162,7 @@ var ServiceMethodGenerator = _ServiceMethodGenerator;
 
 // src/lib/generators/service/service.generator.ts
 var _ServiceGenerator = class _ServiceGenerator {
-  constructor(swaggerPath, project, config) {
+  constructor(parser, project, config) {
     __publicField(this, "project");
     __publicField(this, "parser");
     __publicField(this, "spec");
@@ -2071,7 +2170,7 @@ var _ServiceGenerator = class _ServiceGenerator {
     __publicField(this, "methodGenerator");
     this.config = config;
     this.project = project;
-    this.parser = new SwaggerParser(swaggerPath);
+    this.parser = parser;
     this.spec = this.parser.getSpec();
     if (!this.parser.isValidSpec()) {
       const versionInfo = this.parser.getSpecVersion();
@@ -2079,6 +2178,12 @@ 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 = this.extractPaths();
@@ -2388,14 +2493,38 @@ var ServiceIndexGenerator = _ServiceIndexGenerator;
 
 // src/lib/core/generator.ts
 var fs3 = __toESM(require("fs"));
+function isUrl(input) {
+  try {
+    new URL(input);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+__name(isUrl, "isUrl");
+function validateInput(input) {
+  if (isUrl(input)) {
+    const url = new URL(input);
+    if (![
+      "http:",
+      "https:"
+    ].includes(url.protocol)) {
+      throw new Error(`Unsupported URL protocol: ${url.protocol}. Only HTTP and HTTPS are supported.`);
+    }
+  } else {
+    if (!fs3.existsSync(input)) {
+      throw new Error(`Input file not found: ${input}`);
+    }
+  }
+}
+__name(validateInput, "validateInput");
 function generateFromConfig(config) {
   return __async(this, null, function* () {
     var _a;
-    if (!fs3.existsSync(config.input)) {
-      throw new Error(`Input file not found: ${config.input}`);
-    }
+    validateInput(config.input);
     const outputPath = config.output;
     const generateServices = (_a = config.options.generateServices) != null ? _a : true;
+    const inputType = isUrl(config.input) ? "URL" : "file";
     if (!fs3.existsSync(outputPath)) {
       fs3.mkdirSync(outputPath, {
         recursive: true
@@ -2410,7 +2539,8 @@ function generateFromConfig(config) {
           strict: true
         }, config.compilerOptions)
       });
-      const typeGenerator = new TypeGenerator(config.input, outputPath, config);
+      console.log(`\u{1F4E1} Processing OpenAPI specification from ${inputType}: ${config.input}`);
+      const typeGenerator = yield TypeGenerator.create(config.input, outputPath, config);
       typeGenerator.generate();
       console.log(`\u2705 TypeScript interfaces generated`);
       if (generateServices) {
@@ -2422,7 +2552,7 @@ function generateFromConfig(config) {
         }
         const fileDownloadHelper = new FileDownloadGenerator(project);
         fileDownloadHelper.generate(outputPath);
-        const serviceGenerator = new ServiceGenerator(config.input, project, config);
+        const serviceGenerator = yield ServiceGenerator.create(config.input, project, config);
         serviceGenerator.generate(outputPath);
         const indexGenerator = new ServiceIndexGenerator(project);
         indexGenerator.generateIndex(outputPath);
@@ -2434,14 +2564,19 @@ function generateFromConfig(config) {
       }
       const mainIndexGenerator = new MainIndexGenerator(project, config);
       mainIndexGenerator.generateMainIndex(outputPath);
+      const sourceInfo = `from ${inputType}: ${config.input}`;
       if (config.clientName) {
-        console.log(`\u{1F389} ${config.clientName} Generation completed successfully at: ${outputPath}`);
+        console.log(`\u{1F389} ${config.clientName} Generation completed successfully ${sourceInfo} -> ${outputPath}`);
       } else {
-        console.log("\u{1F389} Generation completed successfully at:", outputPath);
+        console.log(`\u{1F389} Generation completed successfully ${sourceInfo} -> ${outputPath}`);
       }
     } catch (error) {
       if (error instanceof Error) {
         console.error("\u274C Error during generation:", error.message);
+        if (error.message.includes("fetch") || error.message.includes("Failed to fetch")) {
+          console.error("\u{1F4A1} Tip: Make sure the URL is accessible and returns a valid OpenAPI/Swagger specification");
+          console.error("\u{1F4A1} Alternative: Download the specification file locally and use the file path instead");
+        }
       } else {
         console.error("\u274C Unknown error during generation:", error);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-openapi",
-  "version": "0.0.40",
+  "version": "0.0.41-pr-8-feature-url-support-7d492ee.0",
   "description": "Generate Angular services and TypeScript types from OpenAPI/Swagger specifications",
   "keywords": [
     "angular",