@devbro/pashmak 0.1.20 → 0.1.22

package/dist/bin/index.cjs

@@ -566,17 +566,17 @@ var queue_exports = {};
 __export(queue_exports, {
   DatabaseTransport: () => DatabaseTransport
 });
-var DatabaseTransport;
+var import_neko_helper, 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");
     DatabaseTransport = class {
       static {
         __name(this, "DatabaseTransport");
       }
-      activeIntervals = /* @__PURE__ */ new Set();
       config = {
         queue_table: "queue_messages",
         db_connection: "default",
@@ -585,14 +585,48 @@ var init_queue = __esm({
         message_limit: 10
         // messages per each fetch
       };
-      constructor(config10) {
+      channels = /* @__PURE__ */ new Map();
+      messageQueues = [];
+      repeater;
+      processMessage = /* @__PURE__ */ __name(async () => {
+        const conn = db(this.config.db_connection);
+        try {
+          await conn.connect();
+          let q = conn.getQuery();
+          let messages = await q.table(this.config.queue_table).whereOp("channel", "in", Array.from(this.channels.keys())).whereOp("status", "in", ["pending", "failed"]).limit(this.config.message_limit).orderBy("last_tried_at", "asc").get();
+          for (let msg of messages) {
+            try {
+              let callback = this.channels.get(msg.channel);
+              await callback(msg.message);
+              await q.table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+                status: "processed",
+                updated_at: /* @__PURE__ */ new Date(),
+                last_tried_at: /* @__PURE__ */ new Date(),
+                retried_count: (msg.retried_count || 0) + 1
+              });
+            } catch (error) {
+              await q.table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+                status: "failed",
+                last_tried_at: /* @__PURE__ */ new Date(),
+                retried_count: (msg.retried_count || 0) + 1,
+                process_message: error.message || "Error processing message"
+              });
+            }
+          }
+        } catch (error) {
+          logger().error("Error in DatabaseTransport listen interval:", {
+            error
+          });
+        } finally {
+          await conn.disconnect();
+        }
+      }, "processMessage");
+      constructor(config10 = {}) {
         this.config = { ...this.config, ...config10 };
-      }
-      setListenInterval(interval) {
-        this.config.listen_interval = interval;
-      }
-      setMessageLimit(limit) {
-        this.config.message_limit = limit;
+        this.repeater = (0, import_neko_helper.createRepeater)(
+          this.processMessage,
+          this.config.listen_interval * 1e3
+        );
       }
       async dispatch(channel, message) {
         const conn = db(this.config.db_connection);
@@ -610,57 +644,29 @@ var init_queue = __esm({
             created_at: /* @__PURE__ */ new Date(),
             updated_at: /* @__PURE__ */ new Date(),
             last_tried_at: null,
-            process_message: ""
+            process_message: "",
+            retried_count: 0,
+            status: "pending"
           });
         } finally {
           await conn.disconnect();
         }
       }
-      async listen(channel, callback) {
-        return new Promise(async (resolve, reject) => {
-          const intervalId = setInterval(async () => {
-            const conn = db(this.config.db_connection);
-            try {
-              await conn.connect();
-              let q = conn.getQuery();
-              let messages = await q.table(this.config.queue_table).whereOp("channel", "=", channel).whereOp("processed", "=", false).limit(this.config.message_limit).orderBy("last_tried_at", "asc").get();
-              for (let msg of messages) {
-                try {
-                  await callback(msg.message);
-                  await q.table(this.config.queue_table).whereOp("id", "=", msg.id).update({
-                    processed: true,
-                    updated_at: /* @__PURE__ */ new Date()
-                  });
-                } catch (error) {
-                  await q.table(this.config.queue_table).whereOp("id", "=", msg.id).update({
-                    processed: false,
-                    last_tried_at: /* @__PURE__ */ new Date(),
-                    process_message: error.message || "Error processing message"
-                  });
-                }
-              }
-            } catch (error) {
-              this.activeIntervals.delete(intervalId);
-              logger().error("Error in DatabaseTransport listen interval:", { error });
-            } finally {
-              await conn.disconnect();
-            }
-          }, this.config.listen_interval * 1e3);
-          this.activeIntervals.add(intervalId);
-        });
+      async registerListener(channel, callback) {
+        this.channels.set(channel, callback);
+      }
+      async startListening() {
+        this.repeater.start();
       }
       async stopListening() {
-        for (const intervalId of this.activeIntervals) {
-          clearInterval(intervalId);
-        }
-        this.activeIntervals.clear();
+        this.repeater.stop();
       }
     };
   }
 });
 
 // src/factories.mts
-var import_neko_mailer, import_neko_queue, import_neko_queue2, import_neko_cache, import_neko_storage, FlexibleFactory, MailerFactory, QueueTransportFactory, CacheProviderFactory;
+var import_neko_mailer, import_neko_queue, import_neko_queue2, import_neko_cache, import_neko_storage, FlexibleFactory, CacheProviderFactory;
 var init_factories = __esm({
   "src/factories.mts"() {
     "use strict";
@@ -687,19 +693,7 @@ var init_factories = __esm({
         return ctor(...args);
       }
     };
-    MailerFactory = class _MailerFactory {
-      static {
-        __name(this, "MailerFactory");
-      }
-      static instance = new FlexibleFactory();
-      static register(key, factory) {
-        _MailerFactory.instance.register(key, factory);
-      }
-      static create(key, ...args) {
-        return _MailerFactory.instance.create(key, ...args);
-      }
-    };
-    MailerFactory.register("logger", (opt) => {
+    import_neko_mailer.MailerProviderFactory.register("logger", (opt) => {
       return new import_neko_mailer.FunctionProvider((mail) => {
         logger().info({
           msg: "Sending email",
@@ -707,32 +701,20 @@ var init_factories = __esm({
         });
       });
     });
-    MailerFactory.register("ses", (opt) => {
+    import_neko_mailer.MailerProviderFactory.register("ses", (opt) => {
       return new import_neko_mailer.SESProvider(opt);
     });
-    MailerFactory.register("smtp", (opt) => {
+    import_neko_mailer.MailerProviderFactory.register("smtp", (opt) => {
       return new import_neko_mailer.SMTPProvider(opt);
     });
-    MailerFactory.register("memory", (opt) => {
+    import_neko_mailer.MailerProviderFactory.register("memory", (opt) => {
       return new import_neko_mailer.MemoryProvider();
     });
-    QueueTransportFactory = class _QueueTransportFactory {
-      static {
-        __name(this, "QueueTransportFactory");
-      }
-      static instance = new FlexibleFactory();
-      static register(key, factory) {
-        _QueueTransportFactory.instance.register(key, factory);
-      }
-      static create(key, ...args) {
-        return _QueueTransportFactory.instance.create(key, ...args);
-      }
-    };
-    QueueTransportFactory.register("database", (opt) => {
+    import_neko_queue2.QueueTransportFactory.register("database", (opt) => {
       let transport = new DatabaseTransport(opt);
       return new import_neko_queue.QueueConnection(transport);
     });
-    QueueTransportFactory.register("memory", (opt) => {
+    import_neko_queue2.QueueTransportFactory.register("memory", (opt) => {
       let transport = new import_neko_queue2.MemoryTransport(opt);
       return new import_neko_queue.QueueConnection(transport);
     });
@@ -770,13 +752,13 @@ var init_factories = __esm({
 });
 
 // src/facades.mts
-var import_neko_scheduler, import_neko_helper, import_neko_context2, import_neko_storage2, import_neko_mailer2, import_neko_config, import_clipanion, yup, import_neko_logger, import_neko_cache2, import_neko_queue3, router, scheduler, db, storage, cli, httpServer, logger, mailer, queue, cache;
+var import_neko_scheduler, import_neko_helper2, import_neko_context2, import_neko_storage2, import_neko_mailer2, import_neko_config, import_clipanion, yup, import_neko_logger, import_neko_cache2, import_neko_queue3, 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_helper = require("@devbro/neko-helper");
+    import_neko_helper2 = require("@devbro/neko-helper");
     import_neko_context2 = require("@devbro/neko-context");
     import_neko_storage2 = require("@devbro/neko-storage");
     import_neko_mailer2 = require("@devbro/neko-mailer");
@@ -789,8 +771,8 @@ var init_facades = __esm({
     init_factories();
     import_neko_cache2 = require("@devbro/neko-cache");
     import_neko_queue3 = require("@devbro/neko-queue");
-    router = (0, import_neko_helper.createSingleton)(() => new Router());
-    scheduler = (0, import_neko_helper.createSingleton)(() => {
+    router = (0, import_neko_helper2.createSingleton)(() => new Router());
+    scheduler = (0, import_neko_helper2.createSingleton)(() => {
       const rc = new import_neko_scheduler.Scheduler();
       rc.setErrorHandler((err, job) => {
         logger().error({
@@ -802,12 +784,15 @@ var init_facades = __esm({
       return rc;
     });
     db = /* @__PURE__ */ __name((label = "default") => (0, import_neko_context2.ctx)().getOrThrow(["database", label]), "db");
-    storage = (0, import_neko_helper.createSingleton)((label = "default") => {
+    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);
+      const provider = import_neko_storage2.StorageProviderFactory.create(
+        storage_config.provider,
+        storage_config.config
+      );
       return new import_neko_storage2.Storage(provider);
     });
-    cli = (0, import_neko_helper.createSingleton)(() => {
+    cli = (0, import_neko_helper2.createSingleton)(() => {
       const [node, app, ...args] = process.argv;
       return new import_clipanion.Cli({
         binaryLabel: `My Application`,
@@ -815,7 +800,7 @@ var init_facades = __esm({
         binaryVersion: `1.0.0`
       });
     });
-    httpServer = (0, import_neko_helper.createSingleton)(() => {
+    httpServer = (0, import_neko_helper2.createSingleton)(() => {
       const server = new http_exports.HttpServer();
       server.setErrorHandler(async (err, req, res) => {
         if (err instanceof http_exports.HttpError) {
@@ -850,7 +835,7 @@ var init_facades = __esm({
       server.setRouter(router());
       return server;
     });
-    logger = (0, import_neko_helper.createSingleton)((label) => {
+    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) => {
@@ -859,25 +844,28 @@ var init_facades = __esm({
       });
       return rc;
     });
-    mailer = (0, import_neko_helper.createSingleton)((label) => {
+    mailer = (0, import_neko_helper2.createSingleton)((label) => {
       const mailer_config = import_neko_config.config.get(["mailer", label].join("."));
-      const provider = MailerFactory.create(
+      const provider = import_neko_mailer2.MailerProviderFactory.create(
         mailer_config.provider,
         mailer_config.config
       );
       const rc = new import_neko_mailer2.Mailer(provider);
       return rc;
     });
-    queue = (0, import_neko_helper.createSingleton)((label) => {
+    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 = QueueTransportFactory.create(queue_config.provider, queue_config.config);
+      const provider = import_neko_queue3.QueueTransportFactory.create(
+        queue_config.provider,
+        queue_config.config
+      );
       const rc = new import_neko_queue3.QueueConnection(provider);
       return rc;
     });
-    cache = (0, import_neko_helper.createSingleton)((label) => {
+    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`);

package/dist/bin/middlewares.cjs

@@ -455,7 +455,7 @@ var Router = class {
 
 // src/facades.mts
 var import_neko_scheduler = require("@devbro/neko-scheduler");
-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 import_neko_storage2 = require("@devbro/neko-storage");
 var import_neko_mailer2 = require("@devbro/neko-mailer");
@@ -481,11 +481,11 @@ __export(queue_exports, {
   DatabaseTransport: () => DatabaseTransport
 });
 __reExport(queue_exports, require("@devbro/neko-queue"));
+var import_neko_helper = require("@devbro/neko-helper");
 var DatabaseTransport = class {
   static {
     __name(this, "DatabaseTransport");
   }
-  activeIntervals = /* @__PURE__ */ new Set();
   config = {
     queue_table: "queue_messages",
     db_connection: "default",
@@ -494,14 +494,48 @@ var DatabaseTransport = class {
     message_limit: 10
     // messages per each fetch
   };
-  constructor(config2) {
+  channels = /* @__PURE__ */ new Map();
+  messageQueues = [];
+  repeater;
+  processMessage = /* @__PURE__ */ __name(async () => {
+    const conn = db(this.config.db_connection);
+    try {
+      await conn.connect();
+      let q = conn.getQuery();
+      let messages = await q.table(this.config.queue_table).whereOp("channel", "in", Array.from(this.channels.keys())).whereOp("status", "in", ["pending", "failed"]).limit(this.config.message_limit).orderBy("last_tried_at", "asc").get();
+      for (let msg of messages) {
+        try {
+          let callback = this.channels.get(msg.channel);
+          await callback(msg.message);
+          await q.table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+            status: "processed",
+            updated_at: /* @__PURE__ */ new Date(),
+            last_tried_at: /* @__PURE__ */ new Date(),
+            retried_count: (msg.retried_count || 0) + 1
+          });
+        } catch (error) {
+          await q.table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+            status: "failed",
+            last_tried_at: /* @__PURE__ */ new Date(),
+            retried_count: (msg.retried_count || 0) + 1,
+            process_message: error.message || "Error processing message"
+          });
+        }
+      }
+    } catch (error) {
+      logger().error("Error in DatabaseTransport listen interval:", {
+        error
+      });
+    } finally {
+      await conn.disconnect();
+    }
+  }, "processMessage");
+  constructor(config2 = {}) {
     this.config = { ...this.config, ...config2 };
-  }
-  setListenInterval(interval) {
-    this.config.listen_interval = interval;
-  }
-  setMessageLimit(limit) {
-    this.config.message_limit = limit;
+    this.repeater = (0, import_neko_helper.createRepeater)(
+      this.processMessage,
+      this.config.listen_interval * 1e3
+    );
   }
   async dispatch(channel, message) {
     const conn = db(this.config.db_connection);
@@ -519,50 +553,22 @@ var DatabaseTransport = class {
         created_at: /* @__PURE__ */ new Date(),
         updated_at: /* @__PURE__ */ new Date(),
         last_tried_at: null,
-        process_message: ""
+        process_message: "",
+        retried_count: 0,
+        status: "pending"
       });
     } finally {
       await conn.disconnect();
     }
   }
-  async listen(channel, callback) {
-    return new Promise(async (resolve, reject) => {
-      const intervalId = setInterval(async () => {
-        const conn = db(this.config.db_connection);
-        try {
-          await conn.connect();
-          let q = conn.getQuery();
-          let messages = await q.table(this.config.queue_table).whereOp("channel", "=", channel).whereOp("processed", "=", false).limit(this.config.message_limit).orderBy("last_tried_at", "asc").get();
-          for (let msg of messages) {
-            try {
-              await callback(msg.message);
-              await q.table(this.config.queue_table).whereOp("id", "=", msg.id).update({
-                processed: true,
-                updated_at: /* @__PURE__ */ new Date()
-              });
-            } catch (error) {
-              await q.table(this.config.queue_table).whereOp("id", "=", msg.id).update({
-                processed: false,
-                last_tried_at: /* @__PURE__ */ new Date(),
-                process_message: error.message || "Error processing message"
-              });
-            }
-          }
-        } catch (error) {
-          this.activeIntervals.delete(intervalId);
-          logger().error("Error in DatabaseTransport listen interval:", { error });
-        } finally {
-          await conn.disconnect();
-        }
-      }, this.config.listen_interval * 1e3);
-      this.activeIntervals.add(intervalId);
-    });
+  async registerListener(channel, callback) {
+    this.channels.set(channel, callback);
+  }
+  async startListening() {
+    this.repeater.start();
   }
   async stopListening() {
-    for (const intervalId of this.activeIntervals) {
-      clearInterval(intervalId);
-    }
-    this.activeIntervals.clear();
+    this.repeater.stop();
   }
 };
 
@@ -585,19 +591,7 @@ var FlexibleFactory = class {
     return ctor(...args);
   }
 };
-var MailerFactory = class _MailerFactory {
-  static {
-    __name(this, "MailerFactory");
-  }
-  static instance = new FlexibleFactory();
-  static register(key, factory) {
-    _MailerFactory.instance.register(key, factory);
-  }
-  static create(key, ...args) {
-    return _MailerFactory.instance.create(key, ...args);
-  }
-};
-MailerFactory.register("logger", (opt) => {
+import_neko_mailer.MailerProviderFactory.register("logger", (opt) => {
   return new import_neko_mailer.FunctionProvider((mail) => {
     logger().info({
       msg: "Sending email",
@@ -605,32 +599,20 @@ MailerFactory.register("logger", (opt) => {
     });
   });
 });
-MailerFactory.register("ses", (opt) => {
+import_neko_mailer.MailerProviderFactory.register("ses", (opt) => {
   return new import_neko_mailer.SESProvider(opt);
 });
-MailerFactory.register("smtp", (opt) => {
+import_neko_mailer.MailerProviderFactory.register("smtp", (opt) => {
   return new import_neko_mailer.SMTPProvider(opt);
 });
-MailerFactory.register("memory", (opt) => {
+import_neko_mailer.MailerProviderFactory.register("memory", (opt) => {
   return new import_neko_mailer.MemoryProvider();
 });
-var QueueTransportFactory = class _QueueTransportFactory {
-  static {
-    __name(this, "QueueTransportFactory");
-  }
-  static instance = new FlexibleFactory();
-  static register(key, factory) {
-    _QueueTransportFactory.instance.register(key, factory);
-  }
-  static create(key, ...args) {
-    return _QueueTransportFactory.instance.create(key, ...args);
-  }
-};
-QueueTransportFactory.register("database", (opt) => {
+import_neko_queue2.QueueTransportFactory.register("database", (opt) => {
   let transport = new DatabaseTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
-QueueTransportFactory.register("memory", (opt) => {
+import_neko_queue2.QueueTransportFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
@@ -668,8 +650,8 @@ import_neko_storage.StorageProviderFactory.register("s3", (opt) => {
 // src/facades.mts
 var import_neko_cache2 = require("@devbro/neko-cache");
 var import_neko_queue3 = require("@devbro/neko-queue");
-var router = (0, import_neko_helper.createSingleton)(() => new Router());
-var scheduler = (0, import_neko_helper.createSingleton)(() => {
+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({
@@ -681,12 +663,15 @@ var scheduler = (0, import_neko_helper.createSingleton)(() => {
   return rc;
 });
 var db = /* @__PURE__ */ __name((label = "default") => (0, import_neko_context2.ctx)().getOrThrow(["database", label]), "db");
-var storage = (0, import_neko_helper.createSingleton)((label = "default") => {
+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);
+  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_helper.createSingleton)(() => {
+var cli = (0, import_neko_helper2.createSingleton)(() => {
   const [node, app, ...args] = process.argv;
   return new import_clipanion.Cli({
     binaryLabel: `My Application`,
@@ -694,7 +679,7 @@ var cli = (0, import_neko_helper.createSingleton)(() => {
     binaryVersion: `1.0.0`
   });
 });
-var httpServer = (0, import_neko_helper.createSingleton)(() => {
+var httpServer = (0, import_neko_helper2.createSingleton)(() => {
   const server = new http_exports.HttpServer();
   server.setErrorHandler(async (err, req, res) => {
     if (err instanceof http_exports.HttpError) {
@@ -729,7 +714,7 @@ var httpServer = (0, import_neko_helper.createSingleton)(() => {
   server.setRouter(router());
   return server;
 });
-var logger = (0, import_neko_helper.createSingleton)((label) => {
+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) => {
@@ -738,25 +723,28 @@ var logger = (0, import_neko_helper.createSingleton)((label) => {
   });
   return rc;
 });
-var mailer = (0, import_neko_helper.createSingleton)((label) => {
+var mailer = (0, import_neko_helper2.createSingleton)((label) => {
   const mailer_config = import_neko_config.config.get(["mailer", label].join("."));
-  const provider = MailerFactory.create(
+  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_helper.createSingleton)((label) => {
+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 = QueueTransportFactory.create(queue_config.provider, queue_config.config);
+  const provider = import_neko_queue3.QueueTransportFactory.create(
+    queue_config.provider,
+    queue_config.config
+  );
   const rc = new import_neko_queue3.QueueConnection(provider);
   return rc;
 });
-var cache = (0, import_neko_helper.createSingleton)((label) => {
+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`);