@devbro/pashmak 0.1.47 → 0.1.49

package/dist/bin/index.cjs

@@ -89,13 +89,14 @@ var init_MiddlewareFactory = __esm({
 });
 
 // ../neko-router/dist/CompiledRoute.mjs
-var import_stream, CompiledRoute;
+var import_stream, import_neko_helper, CompiledRoute;
 var init_CompiledRoute = __esm({
   "../neko-router/dist/CompiledRoute.mjs"() {
     "use strict";
     import_stream = require("stream");
     init_Middleware();
     init_MiddlewareFactory();
+    import_neko_helper = require("@devbro/neko-helper");
     CompiledRoute = class {
       static {
         __name(this, "CompiledRoute");
@@ -116,7 +117,7 @@ var init_CompiledRoute = __esm({
         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));
@@ -125,13 +126,8 @@ var init_CompiledRoute = __esm({
           }
         }
       }
-      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) {
@@ -278,7 +274,7 @@ var init_Route = __esm({
             i = start;
           } else if (char === "*") {
             let start = i + 1;
-            while (start < path10.length && /[a-zA-Z0-9_\.]/.test(path10[start])) {
+            while (start < path10.length && /[a-zA-Z0-9_]/.test(path10[start])) {
               start++;
             }
             tokens.push({ type: "WILDCARD", value: path10.slice(i + 1, start) });
@@ -557,10 +553,29 @@ var init_router = __esm({
 
 // src/http.mts
 var http_exports = {};
+__export(http_exports, {
+  handleHttpErrors: () => handleHttpErrors
+});
+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" }));
+}
+var import_neko_http;
 var init_http = __esm({
   "src/http.mts"() {
     "use strict";
+    import_neko_http = require("@devbro/neko-http");
+    init_facades();
     __reExport(http_exports, require("@devbro/neko-http"));
+    __name(handleHttpErrors, "handleHttpErrors");
   }
 });
 
@@ -569,13 +584,13 @@ var queue_exports = {};
 __export(queue_exports, {
   DatabaseTransport: () => DatabaseTransport
 });
-var import_neko_helper, import_neko_context2, DatabaseTransport;
+var import_neko_helper2, import_neko_context2, DatabaseTransport;
 var init_queue = __esm({
   "src/queue.mts"() {
     "use strict";
     __reExport(queue_exports, require("@devbro/neko-queue"));
     init_facades();
-    import_neko_helper = require("@devbro/neko-helper");
+    import_neko_helper2 = require("@devbro/neko-helper");
     import_neko_context2 = require("@devbro/neko-context");
     DatabaseTransport = class {
       static {
@@ -636,7 +651,7 @@ var init_queue = __esm({
       }, "processMessage");
       constructor(config11 = {}) {
         this.config = { ...this.config, ...config11 };
-        this.repeater = (0, import_neko_helper.createRepeater)(
+        this.repeater = (0, import_neko_helper2.createRepeater)(
           this.processMessage,
           this.config.listen_interval * 1e3
         );
@@ -713,6 +728,24 @@ var init_factories = __esm({
     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);
+    });
     CacheProviderFactory = class _CacheProviderFactory {
       static {
         __name(this, "CacheProviderFactory");
@@ -743,17 +776,29 @@ var init_factories = __esm({
     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_scheduler, import_neko_helper2, import_neko_context3, import_neko_storage2, import_neko_mailer2, import_neko_config, import_clipanion, import_neko_logger, import_neko_cache2, import_neko_queue2, router, scheduler, db, storage, cli, httpServer, logger, mailer, queue, cache;
+var import_neko_scheduler, import_neko_helper3, import_neko_context3, import_neko_storage2, import_neko_mailer2, import_neko_config, import_clipanion, import_neko_logger, import_neko_cache2, import_neko_queue2, router, scheduler, db, storage, cli, httpServer, logger, mailer, queue, cache;
 var init_facades = __esm({
   "src/facades.mts"() {
     "use strict";
     init_router();
     import_neko_scheduler = require("@devbro/neko-scheduler");
-    import_neko_helper2 = require("@devbro/neko-helper");
+    import_neko_helper3 = require("@devbro/neko-helper");
     import_neko_context3 = require("@devbro/neko-context");
     import_neko_storage2 = require("@devbro/neko-storage");
     import_neko_mailer2 = require("@devbro/neko-mailer");
@@ -764,8 +809,8 @@ var init_facades = __esm({
     init_factories();
     import_neko_cache2 = require("@devbro/neko-cache");
     import_neko_queue2 = require("@devbro/neko-queue");
-    router = (0, import_neko_helper2.createSingleton)(() => new Router());
-    scheduler = (0, import_neko_helper2.createSingleton)(() => {
+    router = (0, import_neko_helper3.createSingleton)(() => new Router());
+    scheduler = (0, import_neko_helper3.createSingleton)(() => {
       const rc = new import_neko_scheduler.Scheduler();
       rc.setErrorHandler((err, job) => {
         logger().error({
@@ -777,7 +822,7 @@ var init_facades = __esm({
       return rc;
     });
     db = /* @__PURE__ */ __name((label = "default") => (0, import_neko_context3.ctx)().getOrThrow(["database", label]), "db");
-    storage = (0, import_neko_helper2.createSingleton)((label = "default") => {
+    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,
@@ -785,7 +830,7 @@ var init_facades = __esm({
       );
       return new import_neko_storage2.Storage(provider);
     });
-    cli = (0, import_neko_helper2.createSingleton)(() => {
+    cli = (0, import_neko_helper3.createSingleton)(() => {
       const [node, app, ...args] = process.argv;
       return new import_clipanion.Cli({
         binaryLabel: `My Application`,
@@ -793,24 +838,13 @@ var init_facades = __esm({
         binaryVersion: `1.0.0`
       });
     });
-    httpServer = (0, import_neko_helper2.createSingleton)(() => {
+    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;
     });
-    logger = (0, import_neko_helper2.createSingleton)((label) => {
+    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) => {
@@ -819,7 +853,7 @@ var init_facades = __esm({
       });
       return rc;
     });
-    mailer = (0, import_neko_helper2.createSingleton)((label) => {
+    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,
@@ -828,7 +862,7 @@ var init_facades = __esm({
       const rc = new import_neko_mailer2.Mailer(provider);
       return rc;
     });
-    queue = (0, import_neko_helper2.createSingleton)((label) => {
+    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`);
@@ -839,7 +873,7 @@ var init_facades = __esm({
       );
       return new import_neko_queue2.QueueConnection(provider);
     });
-    cache = (0, import_neko_helper2.createSingleton)((label) => {
+    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`);
@@ -2254,12 +2288,15 @@ var init_StartCommand = __esm({
         __name(this, "StartCommand");
       }
       scheduler = import_clipanion5.Option.Boolean(`--scheduler`, false);
+      cron = import_clipanion5.Option.Boolean(`--cron`, false);
       http = import_clipanion5.Option.Boolean(`--http`, false);
       queue = import_clipanion5.Option.Boolean(`--queue`, false);
       all = import_clipanion5.Option.Boolean("--all", false);
       static paths = [[`start`]];
       async execute() {
-        if ([this.all, this.http, this.scheduler, this.queue].filter((x) => x).length == 0) {
+        if ([this.all, this.http, this.scheduler || this.cron, this.queue].filter(
+          (x) => x
+        ).length == 0) {
           this.context.stdout.write(
             `No service was selected. please check -h for details
 `
@@ -2269,7 +2306,7 @@ var init_StartCommand = __esm({
         logger().info(`Starting Server
 `);
         import_neko_sql.PostgresqlConnection.defaults.idleTimeoutMillis = 1e4;
-        if (this.scheduler || this.all) {
+        if (this.scheduler || this.cron || this.all) {
           logger().info(`starting scheduler
 `);
           scheduler().start();
@@ -2490,7 +2527,7 @@ var init_config = __esm({
 });
 
 // src/app/console/generate/GenerateApiDocsCommand.mts
-var import_clipanion9, import_path7, fs6, import_neko_helper3, GenerateApiDocsCommand;
+var import_clipanion9, import_path7, fs6, import_neko_helper4, GenerateApiDocsCommand;
 var init_GenerateApiDocsCommand = __esm({
   "src/app/console/generate/GenerateApiDocsCommand.mts"() {
     "use strict";
@@ -2499,144 +2536,155 @@ var init_GenerateApiDocsCommand = __esm({
     import_path7 = __toESM(require("path"), 1);
     fs6 = __toESM(require("fs/promises"), 1);
     init_config();
-    import_neko_helper3 = require("@devbro/neko-helper");
+    import_neko_helper4 = require("@devbro/neko-helper");
     GenerateApiDocsCommand = class extends import_clipanion9.Command {
       static {
         __name(this, "GenerateApiDocsCommand");
       }
-      static paths = [
-        [`make`, `apidocs`],
-        [`generate`, `apidocs`]
-      ];
+      static paths = [[`generate`, `apidocsv2`]];
       static usage = import_clipanion9.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_clipanion9.Option.String({ required: false });
+      output = import_clipanion9.Option.String(`--output,-o`, {
+        description: `Output file path for generated documentation`
       });
-      help = import_clipanion9.Option.Boolean(`--help,-h`, false, {
-        description: `Show help message for this command`
+      config = import_clipanion9.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 fs6.mkdir(config_exports.config.get("private_path"), { recursive: true });
-        const outputPath = import_path7.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_path7.default.join(config_exports.config.get("private_path"), "openapi_from_routes.json");
+        await fs6.mkdir(import_path7.default.dirname(outputPath), { recursive: true });
         await fs6.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: ${routes.length}
+        this.context.stdout.write(
+          `Total routes documented: ${Object.keys(openApiSpec.paths).length}
+`
+        );
+        return 0;
+      }
+      async executeGenerateBase() {
+        this.context.stdout.write(`Generating base OpenAPI specification...
 `);
-        let files_to_merge = config_exports.config.get("api_docs.merge_files");
+        const baseSpec = this.getBaseOpenApiSpec();
+        const outputPath = this.output || import_path7.default.join(config_exports.config.get("private_path"), "openapi_base.json");
+        await fs6.mkdir(import_path7.default.dirname(outputPath), { recursive: true });
+        await fs6.writeFile(outputPath, JSON.stringify(baseSpec, null, 2), "utf-8");
+        this.context.stdout.write(
+          `Base OpenAPI specification generated at: ${outputPath}
+`
+        );
+        return 0;
+      }
+      async executeMergeFiles() {
+        this.context.stdout.write(`Merging OpenAPI 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 fs6.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 fs6.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 fs6.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 fs6.mkdir(import_path7.default.dirname(outputPath), { recursive: true });
+        await fs6.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;
@@ -2655,6 +2703,78 @@ var init_GenerateApiDocsCommand = __esm({
         }
         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);
   }
@@ -3000,8 +3120,11 @@ var init_DatabaseServiceProvider = __esm({
         return _DatabaseServiceProvider.instance;
       }
       getConnection(db_config) {
-        const conn = new import_neko_sql2.PostgresqlConnection(db_config);
-        return conn;
+        if (db_config.provider === "postgresql") {
+          const conn = new import_neko_sql2.PostgresqlConnection(db_config.config);
+          return conn;
+        }
+        throw new Error(`Unsupported database provider: ${db_config.provider}`);
       }
     };
   }