@devbro/pashmak 0.1.47 → 0.1.49

package/dist/bin/app/console/generate/GenerateApiDocsCommand.cjs

@@ -77,6 +77,7 @@ var MiddlewareFactory = class {
 };
 
 // ../neko-router/dist/CompiledRoute.mjs
+var import_neko_helper = require("@devbro/neko-helper");
 var CompiledRoute = class {
   static {
     __name(this, "CompiledRoute");
@@ -97,7 +98,7 @@ var CompiledRoute = class {
     for (const middleware of [...this.globalMiddlewares, ...this.route.getMiddlewares()]) {
       if (middleware instanceof Middleware) {
         this.middlewares.push(middleware);
-      } else if (this.isClass(middleware)) {
+      } else if ((0, import_neko_helper.isClass)(middleware)) {
         this.middlewares.push(middleware.getInstance({}));
       } else if (typeof middleware === "function") {
         this.middlewares.push(MiddlewareFactory.create(middleware));
@@ -106,13 +107,8 @@ var CompiledRoute = class {
       }
     }
   }
-  isClass(func) {
-    return typeof func === "function" && /^class\s/.test(Function.prototype.toString.call(func));
-  }
   async run() {
-    let rc = await this.runMiddlewares(this.middlewares, this.request, this.response);
-    this.response.end();
-    return rc;
+    return await this.runMiddlewares(this.middlewares, this.request, this.response);
   }
   prepareOutputJsonFormat(obj) {
     function traverse(value) {
@@ -246,7 +242,7 @@ var Route = class {
         i = start;
       } else if (char === "*") {
         let start = i + 1;
-        while (start < path3.length && /[a-zA-Z0-9_\.]/.test(path3[start])) {
+        while (start < path3.length && /[a-zA-Z0-9_]/.test(path3[start])) {
           start++;
         }
         tokens.push({ type: "WILDCARD", value: path3.slice(i + 1, start) });
@@ -457,7 +453,7 @@ var Router = class {
 
 // src/facades.mts
 var import_neko_scheduler = require("@devbro/neko-scheduler");
-var import_neko_helper2 = require("@devbro/neko-helper");
+var import_neko_helper3 = require("@devbro/neko-helper");
 var import_neko_context3 = require("@devbro/neko-context");
 var import_neko_storage2 = require("@devbro/neko-storage");
 var import_neko_mailer2 = require("@devbro/neko-mailer");
@@ -466,7 +462,24 @@ var import_clipanion = require("clipanion");
 
 // src/http.mts
 var http_exports = {};
+__export(http_exports, {
+  handleHttpErrors: () => handleHttpErrors
+});
+var import_neko_http = require("@devbro/neko-http");
 __reExport(http_exports, require("@devbro/neko-http"));
+async function handleHttpErrors(err, req, res) {
+  if (err instanceof import_neko_http.HttpError) {
+    res.writeHead(err.statusCode, { "Content-Type": "application/json" });
+    res.write(JSON.stringify({ message: err.message, error: err.code }));
+    logger().warn({ msg: "HttpError: " + err.message, err });
+    return;
+  } else {
+    logger().error({ msg: "Error: " + err.message, err });
+  }
+  res.writeHead(500, { "Content-Type": "application/json" });
+  res.write(JSON.stringify({ error: "Internal Server Error" }));
+}
+__name(handleHttpErrors, "handleHttpErrors");
 
 // src/facades.mts
 var import_neko_logger = require("@devbro/neko-logger");
@@ -481,7 +494,7 @@ __export(queue_exports, {
   DatabaseTransport: () => DatabaseTransport
 });
 __reExport(queue_exports, require("@devbro/neko-queue"));
-var import_neko_helper = require("@devbro/neko-helper");
+var import_neko_helper2 = require("@devbro/neko-helper");
 var import_neko_context2 = require("@devbro/neko-context");
 var DatabaseTransport = class {
   static {
@@ -542,7 +555,7 @@ var DatabaseTransport = class {
   }, "processMessage");
   constructor(config3 = {}) {
     this.config = { ...this.config, ...config3 };
-    this.repeater = (0, import_neko_helper.createRepeater)(
+    this.repeater = (0, import_neko_helper2.createRepeater)(
       this.processMessage,
       this.config.listen_interval * 1e3
     );
@@ -610,6 +623,24 @@ import_neko_queue.QueueTransportFactory.register("database", (opt) => {
 import_neko_queue.QueueTransportFactory.register("memory", (opt) => {
   return new import_neko_queue.MemoryTransport(opt);
 });
+import_neko_queue.QueueTransportFactory.register("sqs", (opt) => {
+  return new import_neko_queue.AwsSqsTransport(opt);
+});
+import_neko_queue.QueueTransportFactory.register("amqp", (opt) => {
+  return new import_neko_queue.AmqpTransport(opt);
+});
+import_neko_queue.QueueTransportFactory.register("redis", (opt) => {
+  return new import_neko_queue.RedisTransport(opt);
+});
+import_neko_queue.QueueTransportFactory.register("async", (opt) => {
+  return new import_neko_queue.AsyncTransport();
+});
+import_neko_queue.QueueTransportFactory.register("azure_service_bus", (opt) => {
+  return new import_neko_queue.AzureServiceBusTransport(opt);
+});
+import_neko_queue.QueueTransportFactory.register("google_pubsub", (opt) => {
+  return new import_neko_queue.GooglePubSubTransport(opt);
+});
 var CacheProviderFactory = class _CacheProviderFactory {
   static {
     __name(this, "CacheProviderFactory");
@@ -640,12 +671,24 @@ import_neko_storage.StorageProviderFactory.register("local", (opt) => {
 import_neko_storage.StorageProviderFactory.register("s3", (opt) => {
   return new import_neko_storage.AWSS3StorageProvider(opt);
 });
+import_neko_storage.StorageProviderFactory.register("gcp", (opt) => {
+  return new import_neko_storage.GCPStorageProvider(opt);
+});
+import_neko_storage.StorageProviderFactory.register("azure", (opt) => {
+  return new import_neko_storage.AzureBlobStorageProvider(opt);
+});
+import_neko_storage.StorageProviderFactory.register("ftp", (opt) => {
+  return new import_neko_storage.FTPStorageProvider(opt);
+});
+import_neko_storage.StorageProviderFactory.register("sftp", (opt) => {
+  return new import_neko_storage.SFTPStorageProvider(opt);
+});
 
 // src/facades.mts
 var import_neko_cache2 = require("@devbro/neko-cache");
 var import_neko_queue2 = require("@devbro/neko-queue");
-var router = (0, import_neko_helper2.createSingleton)(() => new Router());
-var scheduler = (0, import_neko_helper2.createSingleton)(() => {
+var router = (0, import_neko_helper3.createSingleton)(() => new Router());
+var scheduler = (0, import_neko_helper3.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
   rc.setErrorHandler((err, job) => {
     logger().error({
@@ -657,7 +700,7 @@ var scheduler = (0, import_neko_helper2.createSingleton)(() => {
   return rc;
 });
 var db = /* @__PURE__ */ __name((label = "default") => (0, import_neko_context3.ctx)().getOrThrow(["database", label]), "db");
-var storage = (0, import_neko_helper2.createSingleton)((label = "default") => {
+var storage = (0, import_neko_helper3.createSingleton)((label = "default") => {
   let storage_config = import_neko_config.config.get(["storages", label].join("."));
   const provider = import_neko_storage2.StorageProviderFactory.create(
     storage_config.provider,
@@ -665,7 +708,7 @@ var storage = (0, import_neko_helper2.createSingleton)((label = "default") => {
   );
   return new import_neko_storage2.Storage(provider);
 });
-var cli = (0, import_neko_helper2.createSingleton)(() => {
+var cli = (0, import_neko_helper3.createSingleton)(() => {
   const [node, app, ...args] = process.argv;
   return new import_clipanion.Cli({
     binaryLabel: `My Application`,
@@ -673,24 +716,13 @@ var cli = (0, import_neko_helper2.createSingleton)(() => {
     binaryVersion: `1.0.0`
   });
 });
-var httpServer = (0, import_neko_helper2.createSingleton)(() => {
+var httpServer = (0, import_neko_helper3.createSingleton)(() => {
   const server = new http_exports.HttpServer();
-  server.setErrorHandler(async (err, req, res) => {
-    if (err instanceof http_exports.HttpError) {
-      res.writeHead(err.statusCode, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ message: err.message, error: err.code }));
-      logger().warn({ msg: "HttpError: " + err.message, err });
-      return;
-    } else {
-      logger().error({ msg: "Error: " + err.message, err });
-    }
-    res.writeHead(500, { "Content-Type": "" });
-    res.end(JSON.stringify({ error: "Internal Server Error" }));
-  });
+  server.setErrorHandler(handleHttpErrors);
   server.setRouter(router());
   return server;
 });
-var logger = (0, import_neko_helper2.createSingleton)((label) => {
+var logger = (0, import_neko_helper3.createSingleton)((label) => {
   const logger_config = import_neko_config.config.get(["loggers", label].join("."));
   const rc = new import_neko_logger.Logger(logger_config);
   rc.setExtrasFunction((message) => {
@@ -699,7 +731,7 @@ var logger = (0, import_neko_helper2.createSingleton)((label) => {
   });
   return rc;
 });
-var mailer = (0, import_neko_helper2.createSingleton)((label) => {
+var mailer = (0, import_neko_helper3.createSingleton)((label) => {
   const mailer_config = import_neko_config.config.get(["mailer", label].join("."));
   const provider = import_neko_mailer2.MailerProviderFactory.create(
     mailer_config.provider,
@@ -708,7 +740,7 @@ var mailer = (0, import_neko_helper2.createSingleton)((label) => {
   const rc = new import_neko_mailer2.Mailer(provider);
   return rc;
 });
-var queue = (0, import_neko_helper2.createSingleton)((label) => {
+var queue = (0, import_neko_helper3.createSingleton)((label) => {
   const queue_config = import_neko_config.config.get(["queues", label].join("."));
   if (!queue_config) {
     throw new Error(`Queue configuration for '${label}' not found`);
@@ -719,7 +751,7 @@ var queue = (0, import_neko_helper2.createSingleton)((label) => {
   );
   return new import_neko_queue2.QueueConnection(provider);
 });
-var cache = (0, import_neko_helper2.createSingleton)((label) => {
+var cache = (0, import_neko_helper3.createSingleton)((label) => {
   const cache_config = import_neko_config.config.get(["caches", label].join("."));
   if (!cache_config) {
     throw new Error(`Cache configuration for '${label}' not found`);
@@ -741,144 +773,155 @@ var config_exports = {};
 __reExport(config_exports, require("@devbro/neko-config"));
 
 // src/app/console/generate/GenerateApiDocsCommand.mts
-var import_neko_helper3 = require("@devbro/neko-helper");
+var import_neko_helper4 = require("@devbro/neko-helper");
 var GenerateApiDocsCommand = class extends import_clipanion2.Command {
   static {
     __name(this, "GenerateApiDocsCommand");
   }
-  static paths = [
-    [`make`, `apidocs`],
-    [`generate`, `apidocs`]
-  ];
+  static paths = [[`generate`, `apidocsv2`]];
   static usage = import_clipanion2.Command.Usage({
     category: `Generate`,
     description: `Generate OpenAPI documentation from routes`,
     details: `
-      This command generates OpenAPI 3.0 specification documentation by analyzing
+      This command utility generates OpenAPI 3.0 specification documentation by analyzing
       your application's routes and merging with example files.
       
-      The generated documentation includes:
-      - All registered routes with their HTTP methods
-      - Path parameters extracted from route definitions
-      - Request body schemas for POST, PUT, and PATCH methods
-      - Response schemas
-      
-      The command will merge files specified in config.api_docs.merge_files
-      and output the final documentation to config.api_docs.output.
+      Subcommands:
+      - generate-from-routes: Generate OpenAPI spec from registered routes
+      - generate-base: Generate base OpenAPI specification structure
+      - merge-files: Merge multiple OpenAPI files into final documentation
 
+      
       This command depends on config data. make sure your default config contains the following:
-      api_docs: {
-        merge_files: [
-          path.join(__dirname, '../..', 'private', 'openapi_examples.json'),
-          path.join(__dirname, '../..', 'private', 'openapi_base.json'),
-          path.join(__dirname, '../..', 'private', 'openapi_user_changes.json'),
-        ],
-        output: path.join(__dirname, '../..', 'private', 'openapi.json'),
-      }
+
+\`\`\`
+api_docs: {
+
+  merge_files: [
+
+    path.join(__dirname, '../..', 'private', 'openapi_base.json'),
+
+    path.join(__dirname, '../..', 'private', 'openapi_from_routes.json'),
+
+    path.join(__dirname, '../..', 'private', 'openapi_from_tests.json'),
+
+    path.join(__dirname, '../..', 'private', 'openapi_other_user_changes.json'),
+
+  ],
+
+  output: path.join(__dirname, '../..', 'public', 'openapi.json'),
+
+}
+
+\`\`\`
     `,
-    examples: [[`Generate API documentation`, `$0 generate apidocs`]]
+    examples: [
+      [
+        `Generate from routes`,
+        `$0 generate apidocsv2 generate-from-routes --output path/to/output.json`
+      ],
+      [
+        `Generate base spec`,
+        `$0 generate apidocsv2 generate-base --output path/to/output.json`
+      ],
+      [`Merge files`, `$0 generate apidocsv2 merge-files`],
+      [`Show help`, `$0 generate apidocsv2 --help`]
+    ]
+  });
+  subcommand = import_clipanion2.Option.String({ required: false });
+  output = import_clipanion2.Option.String(`--output,-o`, {
+    description: `Output file path for generated documentation`
   });
-  help = import_clipanion2.Option.Boolean(`--help,-h`, false, {
-    description: `Show help message for this command`
+  config = import_clipanion2.Option.String(`--config,-c`, {
+    description: `Path in config to get details from (default: api_docs)`,
+    required: false
   });
   async execute() {
-    if (this.help) {
+    if (!this.subcommand) {
       this.context.stdout.write(
         this.constructor.usage?.toString() || "No help available\n"
       );
       return 0;
     }
-    const rootDir = process.cwd();
-    this.context.stdout.write(`Generating OpenAPI documentation...
+    switch (this.subcommand) {
+      case "generate-from-routes":
+        return await this.executeGenerateFromRoutes();
+      case "generate-base":
+        return await this.executeGenerateBase();
+      case "merge-files":
+        return await this.executeMergeFiles();
+      default:
+        this.context.stderr.write(`Unknown subcommand: ${this.subcommand}
 `);
-    const routes = router().routes;
-    const openApiSpec = {
-      openapi: "3.0.0",
-      info: {
-        title: "API Documentation",
-        version: "1.0.0",
-        description: "Auto-generated API documentation"
-      },
-      servers: [
-        {
-          url: "/",
-          description: "Local server"
-        }
-      ],
-      paths: {}
-    };
-    for (const route of routes) {
-      const routePath = route.path;
-      const openApiPath = routePath.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
-      if (!openApiSpec.paths[openApiPath]) {
-        openApiSpec.paths[openApiPath] = {};
-      }
-      for (const method of route.methods) {
-        const lowerMethod = method.toLowerCase();
-        if (lowerMethod === "head") {
-          continue;
-        }
-        openApiSpec.paths[openApiPath][lowerMethod] = {
-          summary: `${method} ${routePath}`,
-          description: `Endpoint for ${method} ${routePath}`,
-          parameters: this.extractParameters(routePath),
-          responses: {
-            "200": {
-              description: "Successful response",
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object"
-                  }
-                }
-              }
-            },
-            "500": {
-              description: "Internal server error"
-            }
-          }
-        };
-        if (["post", "put", "patch"].includes(lowerMethod)) {
-          openApiSpec.paths[openApiPath][lowerMethod].requestBody = {
-            required: true,
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object"
-                }
-              }
-            }
-          };
-        }
-      }
+        this.context.stdout.write(
+          this.constructor.usage?.toString() || "No help available\n"
+        );
+        return 1;
     }
-    await fs.mkdir(config_exports.config.get("private_path"), { recursive: true });
-    const outputPath = import_path2.default.join(config_exports.config.get("private_path"), "openapi.json");
+  }
+  async executeGenerateFromRoutes() {
+    this.context.stdout.write(
+      `Generating OpenAPI documentation from routes...
+`
+    );
+    const openApiSpec = this.generateFromRoutes();
+    const outputPath = this.output || import_path2.default.join(config_exports.config.get("private_path"), "openapi_from_routes.json");
+    await fs.mkdir(import_path2.default.dirname(outputPath), { recursive: true });
     await fs.writeFile(
       outputPath,
       JSON.stringify(openApiSpec, null, 2),
       "utf-8"
     );
     this.context.stdout.write(
-      `OpenAPI documentation generated at: ${outputPath}
+      `OpenAPI routes documentation generated at: ${outputPath}
+`
+    );
+    this.context.stdout.write(
+      `Total routes documented: ${Object.keys(openApiSpec.paths).length}
+`
+    );
+    return 0;
+  }
+  async executeGenerateBase() {
+    this.context.stdout.write(`Generating base OpenAPI specification...
+`);
+    const baseSpec = this.getBaseOpenApiSpec();
+    const outputPath = this.output || import_path2.default.join(config_exports.config.get("private_path"), "openapi_base.json");
+    await fs.mkdir(import_path2.default.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, JSON.stringify(baseSpec, null, 2), "utf-8");
+    this.context.stdout.write(
+      `Base OpenAPI specification generated at: ${outputPath}
 `
     );
-    this.context.stdout.write(`Total routes documented: ${routes.length}
+    return 0;
+  }
+  async executeMergeFiles() {
+    this.context.stdout.write(`Merging OpenAPI files...
 `);
-    let files_to_merge = config_exports.config.get("api_docs.merge_files");
+    let configPath = this.config || "api_docs";
+    const files_to_merge = config_exports.config.get(`${configPath}.merge_files`);
     let final_api_docs = {};
-    for (let file_path of files_to_merge) {
-      let file_json = JSON.parse(await fs.readFile(file_path, "utf8"));
-      final_api_docs = import_neko_helper3.Arr.deepMerge(final_api_docs, file_json);
+    for (const file_path of files_to_merge) {
+      try {
+        const file_json = JSON.parse(await fs.readFile(file_path, "utf8"));
+        final_api_docs = import_neko_helper4.Arr.deepMerge(final_api_docs, file_json);
+        this.context.stdout.write(`  Merged: ${file_path}
+`);
+      } catch (error) {
+        this.context.stderr.write(
+          `  Warning: Could not read ${file_path}: ${error.message}
+`
+        );
+      }
     }
-    await fs.writeFile(
-      config_exports.config.get("api_docs.output"),
-      JSON.stringify(final_api_docs, null, 2)
-    );
+    const outputPath = this.output || config_exports.config.get(`${configPath}.output`);
+    await fs.mkdir(import_path2.default.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, JSON.stringify(final_api_docs, null, 2));
     this.context.stdout.write(
-      `wrote final open api document to : ${config_exports.config.get("api_docs.output")}
+      `Final OpenAPI document written to: ${outputPath}
 `
     );
+    return 0;
   }
   extractParameters(routePath) {
     const paramRegex = /:([a-zA-Z0-9_]+)/g;
@@ -897,6 +940,78 @@ var GenerateApiDocsCommand = class extends import_clipanion2.Command {
     }
     return parameters;
   }
+  generateFromRoutes() {
+    const openApiSpec = {
+      paths: {}
+    };
+    const routes = router().routes;
+    for (const route of routes) {
+      const routePath = route.path;
+      const openApiPath = routePath.replace(/\/$/g, "");
+      if (!openApiSpec.paths[openApiPath]) {
+        openApiSpec.paths[openApiPath] = {};
+      }
+      for (const method of route.methods) {
+        const lowerMethod = method.toLowerCase();
+        if (lowerMethod === "head") {
+          continue;
+        }
+        openApiSpec.paths[openApiPath][lowerMethod] = {
+          summary: `${routePath}`,
+          description: `Endpoint for ${method} ${routePath}`,
+          security: [],
+          parameters: this.extractParameters(routePath),
+          responses: {}
+        };
+        if (["post", "put", "patch"].includes(lowerMethod)) {
+          openApiSpec.paths[openApiPath][lowerMethod].requestBody = {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object"
+                }
+              }
+            }
+          };
+        }
+      }
+    }
+    return openApiSpec;
+  }
+  getBaseOpenApiSpec() {
+    const openApiSpec = {
+      openapi: "3.0.0",
+      info: {
+        title: "API Documentation",
+        version: "1.0.0",
+        description: "Auto-generated API documentation"
+      },
+      servers: [
+        {
+          url: "/",
+          description: "Local server"
+        }
+      ],
+      components: {
+        securitySchemes: {
+          bearerAuth: {
+            type: "http",
+            scheme: "bearer",
+            bearerFormat: "JWT",
+            description: "JWT token authentication"
+          }
+        }
+      },
+      security: [
+        {
+          bearerAuth: []
+        }
+      ],
+      paths: {}
+    };
+    return openApiSpec;
+  }
 };
 cli().register(GenerateApiDocsCommand);
 // Annotate the CommonJS export names for ESM import in node: