@devbro/pashmak 0.1.48 → 0.1.51

package/dist/bin/app/console/StartCommand.cjs

@@ -79,6 +79,7 @@ var MiddlewareFactory = class {
 };
 
 // ../neko-router/dist/CompiledRoute.mjs
+var import_neko_helper = require("@devbro/neko-helper");
 var CompiledRoute = class {
   static {
     __name(this, "CompiledRoute");
@@ -99,7 +100,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));
@@ -108,9 +109,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);
   }
@@ -246,7 +244,7 @@ var Route = class {
         i = start;
       } else if (char === "*") {
         let start = i + 1;
-        while (start < path2.length && /[a-zA-Z0-9_\.]/.test(path2[start])) {
+        while (start < path2.length && /[a-zA-Z0-9_]/.test(path2[start])) {
           start++;
         }
         tokens.push({ type: "WILDCARD", value: path2.slice(i + 1, start) });
@@ -457,7 +455,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");
@@ -498,7 +496,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 {
@@ -559,7 +557,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
     );
@@ -627,6 +625,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");
@@ -657,32 +673,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`,
@@ -690,52 +749,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/StartCommand.mts
 var import_neko_sql = require("@devbro/neko-sql");
@@ -744,12 +811,15 @@ var StartCommand = class extends import_clipanion2.Command {
     __name(this, "StartCommand");
   }
   scheduler = import_clipanion2.Option.Boolean(`--scheduler`, false);
+  cron = import_clipanion2.Option.Boolean(`--cron`, false);
   http = import_clipanion2.Option.Boolean(`--http`, false);
   queue = import_clipanion2.Option.Boolean(`--queue`, false);
   all = import_clipanion2.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
 `
@@ -759,7 +829,7 @@ var StartCommand = class extends import_clipanion2.Command {
     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();