@devbro/pashmak 0.1.19 → 0.1.21

package/dist/bin/index.cjs

@@ -561,6 +561,15 @@ var init_http = __esm({
   }
 });
 
+// src/helper.mts
+var helper_exports = {};
+var init_helper = __esm({
+  "src/helper.mts"() {
+    "use strict";
+    __reExport(helper_exports, require("@devbro/neko-helper"));
+  }
+});
+
 // src/queue.mts
 var queue_exports = {};
 __export(queue_exports, {
@@ -572,11 +581,11 @@ var init_queue = __esm({
     "use strict";
     __reExport(queue_exports, require("@devbro/neko-queue"));
     init_facades();
+    init_helper();
     DatabaseTransport = class {
       static {
         __name(this, "DatabaseTransport");
       }
-      activeIntervals = /* @__PURE__ */ new Set();
       config = {
         queue_table: "queue_messages",
         db_connection: "default",
@@ -585,14 +594,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, helper_exports.createRepeater)(
+          this.processMessage,
+          this.config.listen_interval * 1e3
+        );
       }
       async dispatch(channel, message) {
         const conn = db(this.config.db_connection);
@@ -610,57 +653,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 +702,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 +710,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);
     });
@@ -804,7 +795,10 @@ var init_facades = __esm({
     db = /* @__PURE__ */ __name((label = "default") => (0, import_neko_context2.ctx)().getOrThrow(["database", label]), "db");
     storage = (0, import_neko_helper.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)(() => {
@@ -861,7 +855,7 @@ var init_facades = __esm({
     });
     mailer = (0, import_neko_helper.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
       );
@@ -873,7 +867,10 @@ var init_facades = __esm({
       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;
     });

package/dist/bin/middlewares.cjs

@@ -481,11 +481,16 @@ __export(queue_exports, {
   DatabaseTransport: () => DatabaseTransport
 });
 __reExport(queue_exports, require("@devbro/neko-queue"));
+
+// src/helper.mts
+var helper_exports = {};
+__reExport(helper_exports, require("@devbro/neko-helper"));
+
+// src/queue.mts
 var DatabaseTransport = class {
   static {
     __name(this, "DatabaseTransport");
   }
-  activeIntervals = /* @__PURE__ */ new Set();
   config = {
     queue_table: "queue_messages",
     db_connection: "default",
@@ -494,14 +499,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, helper_exports.createRepeater)(
+      this.processMessage,
+      this.config.listen_interval * 1e3
+    );
   }
   async dispatch(channel, message) {
     const conn = db(this.config.db_connection);
@@ -519,50 +558,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 +596,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 +604,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);
 });
@@ -683,7 +670,10 @@ var scheduler = (0, import_neko_helper.createSingleton)(() => {
 var db = /* @__PURE__ */ __name((label = "default") => (0, import_neko_context2.ctx)().getOrThrow(["database", label]), "db");
 var storage = (0, import_neko_helper.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)(() => {
@@ -740,7 +730,7 @@ var logger = (0, import_neko_helper.createSingleton)((label) => {
 });
 var mailer = (0, import_neko_helper.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
   );
@@ -752,7 +742,10 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   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;
 });