@devbro/pashmak 0.1.48 → 0.1.51

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

@@ -78,6 +78,7 @@ var MiddlewareFactory = class {
 };
 
 // ../neko-router/dist/CompiledRoute.mjs
+var import_neko_helper = require("@devbro/neko-helper");
 var CompiledRoute = class {
   static {
     __name(this, "CompiledRoute");
@@ -98,7 +99,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));
@@ -107,9 +108,6 @@ var CompiledRoute = class {
       }
     }
   }
-  isClass(func) {
-    return typeof func === "function" && /^class\s/.test(Function.prototype.toString.call(func));
-  }
   async run() {
     return await this.runMiddlewares(this.middlewares, this.request, this.response);
   }
@@ -245,7 +243,7 @@ var Route = class {
         i = start;
       } else if (char === "*") {
         let start = i + 1;
-        while (start < path4.length && /[a-zA-Z0-9_\.]/.test(path4[start])) {
+        while (start < path4.length && /[a-zA-Z0-9_]/.test(path4[start])) {
           start++;
         }
         tokens.push({ type: "WILDCARD", value: path4.slice(i + 1, start) });
@@ -456,7 +454,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");
@@ -497,7 +495,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 {
@@ -558,7 +556,7 @@ var DatabaseTransport = class {
   }, "processMessage");
   constructor(config4 = {}) {
     this.config = { ...this.config, ...config4 };
-    this.repeater = (0, import_neko_helper.createRepeater)(
+    this.repeater = (0, import_neko_helper2.createRepeater)(
       this.processMessage,
       this.config.listen_interval * 1e3
     );
@@ -626,6 +624,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");
@@ -656,32 +672,75 @@ 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)(() => {
-  const rc = new import_neko_scheduler.Scheduler();
-  rc.setErrorHandler((err, job) => {
-    logger().error({
-      msg: "Scheduled job error",
-      err,
-      job_name: job.getName()
-    });
+function wrapSingletonWithAccessors(singletonFn) {
+  let methodsInitialized = false;
+  const initializeMethods = /* @__PURE__ */ __name(() => {
+    if (methodsInitialized) return;
+    const defaultInstance = singletonFn();
+    const prototype = Object.getPrototypeOf(defaultInstance);
+    const methodNames = Object.getOwnPropertyNames(prototype).filter(
+      (name) => name !== "constructor" && typeof prototype[name] === "function"
+    );
+    for (const methodName of methodNames) {
+      singletonFn[methodName] = (...args) => {
+        const instance = singletonFn();
+        return instance[methodName](...args);
+      };
+    }
+    methodsInitialized = true;
+  }, "initializeMethods");
+  return new Proxy(singletonFn, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string" && !Reflect.has(target, prop)) {
+        initializeMethods();
+      }
+      return Reflect.get(target, prop, receiver);
+    }
   });
-  return rc;
-});
+}
+__name(wrapSingletonWithAccessors, "wrapSingletonWithAccessors");
+var router = (0, import_neko_helper3.createSingleton)(() => new Router());
+var scheduler = wrapSingletonWithAccessors(
+  (0, import_neko_helper3.createSingleton)(() => {
+    const rc = new import_neko_scheduler.Scheduler();
+    rc.setErrorHandler((err, job) => {
+      logger().error({
+        msg: "Scheduled job error",
+        err,
+        job_name: job.getName()
+      });
+    });
+    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") => {
-  let storage_config = import_neko_config.config.get(["storages", label].join("."));
-  const provider = import_neko_storage2.StorageProviderFactory.create(
-    storage_config.provider,
-    storage_config.config
-  );
-  return new import_neko_storage2.Storage(provider);
-});
-var cli = (0, import_neko_helper2.createSingleton)(() => {
+var storage = wrapSingletonWithAccessors(
+  (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,
+      storage_config.config
+    );
+    return new import_neko_storage2.Storage(provider);
+  })
+);
+var cli = (0, import_neko_helper3.createSingleton)(() => {
   const [node, app, ...args] = process.argv;
   return new import_clipanion.Cli({
     binaryLabel: `My Application`,
@@ -689,52 +748,60 @@ 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(handleHttpErrors);
   server.setRouter(router());
   return server;
 });
-var logger = (0, import_neko_helper2.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) => {
-    message.requestId = (0, import_neko_context3.ctxSafe)()?.get("requestId") || "N/A";
-    return message;
-  });
-  return rc;
-});
-var mailer = (0, import_neko_helper2.createSingleton)((label) => {
-  const mailer_config = import_neko_config.config.get(["mailer", label].join("."));
-  const provider = import_neko_mailer2.MailerProviderFactory.create(
-    mailer_config.provider,
-    mailer_config.config
-  );
-  const rc = new import_neko_mailer2.Mailer(provider);
-  return rc;
-});
-var queue = (0, import_neko_helper2.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`);
-  }
-  const provider = import_neko_queue2.QueueTransportFactory.create(
-    queue_config.provider,
-    queue_config.config
-  );
-  return new import_neko_queue2.QueueConnection(provider);
-});
-var cache = (0, import_neko_helper2.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`);
-  }
-  const provider = CacheProviderFactory.create(
-    cache_config.provider,
-    cache_config.config
-  );
-  return new import_neko_cache2.Cache(provider);
-});
+var logger = wrapSingletonWithAccessors(
+  (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) => {
+      message.requestId = (0, import_neko_context3.ctxSafe)()?.get("requestId") || "N/A";
+      return message;
+    });
+    return rc;
+  })
+);
+var mailer = wrapSingletonWithAccessors(
+  (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,
+      mailer_config.config
+    );
+    const rc = new import_neko_mailer2.Mailer(provider);
+    return rc;
+  })
+);
+var queue = wrapSingletonWithAccessors(
+  (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`);
+    }
+    const provider = import_neko_queue2.QueueTransportFactory.create(
+      queue_config.provider,
+      queue_config.config
+    );
+    return new import_neko_queue2.QueueConnection(provider);
+  })
+);
+var cache = wrapSingletonWithAccessors(
+  (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`);
+    }
+    const provider = CacheProviderFactory.create(
+      cache_config.provider,
+      cache_config.config
+    );
+    return new import_neko_cache2.Cache(provider);
+  })
+);
 
 // src/app/console/generate/GenerateControllerCommand.mts
 var import_clipanion2 = require("clipanion");
@@ -799,144 +866,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_clipanion3.Command {
   static {
     __name(this, "GenerateApiDocsCommand");
   }
-  static paths = [
-    [`make`, `apidocs`],
-    [`generate`, `apidocs`]
-  ];
+  static paths = [[`generate`, `apidocs`]];
   static usage = import_clipanion3.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 apidocs generate-from-routes --output path/to/output.json`
+      ],
+      [
+        `Generate base spec`,
+        `$0 generate apidocs generate-base --output path/to/output.json`
+      ],
+      [`Merge files`, `$0 generate apidocs merge-files`],
+      [`Show help`, `$0 generate apidocs --help`]
+    ]
+  });
+  subcommand = import_clipanion3.Option.String({ required: false });
+  output = import_clipanion3.Option.String(`--output,-o`, {
+    description: `Output file path for generated documentation`
   });
-  help = import_clipanion3.Option.Boolean(`--help,-h`, false, {
-    description: `Show help message for this command`
+  config = import_clipanion3.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 fs2.mkdir(config_exports.config.get("private_path"), { recursive: true });
-    const outputPath = import_path3.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_path3.default.join(config_exports.config.get("private_path"), "openapi_from_routes.json");
+    await fs2.mkdir(import_path3.default.dirname(outputPath), { recursive: true });
     await fs2.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_path3.default.join(config_exports.config.get("private_path"), "openapi_base.json");
+    await fs2.mkdir(import_path3.default.dirname(outputPath), { recursive: true });
+    await fs2.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 fs2.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 fs2.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 fs2.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 fs2.mkdir(import_path3.default.dirname(outputPath), { recursive: true });
+    await fs2.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;
@@ -955,6 +1033,78 @@ var GenerateApiDocsCommand = class extends import_clipanion3.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: