@devbro/pashmak 0.1.24 → 0.1.26

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

@@ -491,8 +491,10 @@ var DatabaseTransport = class {
     db_connection: "default",
     listen_interval: 60,
     // seconds
-    message_limit: 10
+    message_limit: 10,
     // messages per each fetch
+    max_retry_count: 5
+    // maximum retry count for failed messages
   };
   channels = /* @__PURE__ */ new Map();
   messageQueues = [];
@@ -501,24 +503,31 @@ var DatabaseTransport = class {
     await import_neko_context2.context_provider.run(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();
+        let messages = await conn.getQuery().table(this.config.queue_table).whereOp("channel", "in", Array.from(this.channels.keys())).whereOp("status", "in", ["pending", "failed"]).whereOp("retried_count", "<", this.config.max_retry_count).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",
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processing",
               updated_at: /* @__PURE__ */ new Date(),
               last_tried_at: /* @__PURE__ */ new Date(),
               retried_count: (msg.retried_count || 0) + 1
             });
+            let callback = this.channels.get(msg.channel);
+            await callback(msg.message);
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processed",
+              updated_at: /* @__PURE__ */ new Date()
+            });
           } catch (error) {
+            logger().error("Error processing message:", {
+              error,
+              message_id: msg.id,
+              channel: msg.channel
+            });
             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,
+              updated_at: /* @__PURE__ */ new Date(),
               process_message: error.message || "Error processing message"
             });
           }
@@ -527,8 +536,6 @@ var DatabaseTransport = class {
         logger().error("Error in DatabaseTransport listen interval:", {
           error
         });
-      } finally {
-        await conn.disconnect();
       }
     });
   }, "processMessage");
@@ -541,27 +548,21 @@ var DatabaseTransport = class {
   }
   async dispatch(channel, message) {
     const conn = db(this.config.db_connection);
-    try {
-      await conn.connect();
-      let schema = conn.getSchema();
-      if (await schema.tableExists(this.config.queue_table) === false) {
-        return;
-      }
-      let q = conn.getQuery();
-      await q.table(this.config.queue_table).insert({
-        channel,
-        message,
-        processed: false,
-        created_at: /* @__PURE__ */ new Date(),
-        updated_at: /* @__PURE__ */ new Date(),
-        last_tried_at: null,
-        process_message: "",
-        retried_count: 0,
-        status: "pending"
-      });
-    } finally {
-      await conn.disconnect();
+    let schema = conn.getSchema();
+    if (await schema.tableExists(this.config.queue_table) === false) {
+      return;
     }
+    let q = conn.getQuery();
+    await q.table(this.config.queue_table).insert({
+      channel,
+      message,
+      created_at: /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date(),
+      last_tried_at: null,
+      process_message: "",
+      retried_count: 0,
+      status: "pending"
+    });
   }
   async registerListener(channel, callback) {
     this.channels.set(channel, callback);

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

@@ -494,8 +494,10 @@ var DatabaseTransport = class {
     db_connection: "default",
     listen_interval: 60,
     // seconds
-    message_limit: 10
+    message_limit: 10,
     // messages per each fetch
+    max_retry_count: 5
+    // maximum retry count for failed messages
   };
   channels = /* @__PURE__ */ new Map();
   messageQueues = [];
@@ -504,24 +506,31 @@ var DatabaseTransport = class {
     await import_neko_context2.context_provider.run(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();
+        let messages = await conn.getQuery().table(this.config.queue_table).whereOp("channel", "in", Array.from(this.channels.keys())).whereOp("status", "in", ["pending", "failed"]).whereOp("retried_count", "<", this.config.max_retry_count).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",
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processing",
               updated_at: /* @__PURE__ */ new Date(),
               last_tried_at: /* @__PURE__ */ new Date(),
               retried_count: (msg.retried_count || 0) + 1
             });
+            let callback = this.channels.get(msg.channel);
+            await callback(msg.message);
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processed",
+              updated_at: /* @__PURE__ */ new Date()
+            });
           } catch (error) {
+            logger().error("Error processing message:", {
+              error,
+              message_id: msg.id,
+              channel: msg.channel
+            });
             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,
+              updated_at: /* @__PURE__ */ new Date(),
               process_message: error.message || "Error processing message"
             });
           }
@@ -530,8 +539,6 @@ var DatabaseTransport = class {
         logger().error("Error in DatabaseTransport listen interval:", {
           error
         });
-      } finally {
-        await conn.disconnect();
       }
     });
   }, "processMessage");
@@ -544,27 +551,21 @@ var DatabaseTransport = class {
   }
   async dispatch(channel, message) {
     const conn = db(this.config.db_connection);
-    try {
-      await conn.connect();
-      let schema = conn.getSchema();
-      if (await schema.tableExists(this.config.queue_table) === false) {
-        return;
-      }
-      let q = conn.getQuery();
-      await q.table(this.config.queue_table).insert({
-        channel,
-        message,
-        processed: false,
-        created_at: /* @__PURE__ */ new Date(),
-        updated_at: /* @__PURE__ */ new Date(),
-        last_tried_at: null,
-        process_message: "",
-        retried_count: 0,
-        status: "pending"
-      });
-    } finally {
-      await conn.disconnect();
+    let schema = conn.getSchema();
+    if (await schema.tableExists(this.config.queue_table) === false) {
+      return;
     }
+    let q = conn.getQuery();
+    await q.table(this.config.queue_table).insert({
+      channel,
+      message,
+      created_at: /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date(),
+      last_tried_at: null,
+      process_message: "",
+      retried_count: 0,
+      status: "pending"
+    });
   }
   async registerListener(channel, callback) {
     this.channels.set(channel, callback);

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

@@ -492,8 +492,10 @@ var DatabaseTransport = class {
     db_connection: "default",
     listen_interval: 60,
     // seconds
-    message_limit: 10
+    message_limit: 10,
     // messages per each fetch
+    max_retry_count: 5
+    // maximum retry count for failed messages
   };
   channels = /* @__PURE__ */ new Map();
   messageQueues = [];
@@ -502,24 +504,31 @@ var DatabaseTransport = class {
     await import_neko_context2.context_provider.run(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();
+        let messages = await conn.getQuery().table(this.config.queue_table).whereOp("channel", "in", Array.from(this.channels.keys())).whereOp("status", "in", ["pending", "failed"]).whereOp("retried_count", "<", this.config.max_retry_count).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",
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processing",
               updated_at: /* @__PURE__ */ new Date(),
               last_tried_at: /* @__PURE__ */ new Date(),
               retried_count: (msg.retried_count || 0) + 1
             });
+            let callback = this.channels.get(msg.channel);
+            await callback(msg.message);
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processed",
+              updated_at: /* @__PURE__ */ new Date()
+            });
           } catch (error) {
+            logger().error("Error processing message:", {
+              error,
+              message_id: msg.id,
+              channel: msg.channel
+            });
             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,
+              updated_at: /* @__PURE__ */ new Date(),
               process_message: error.message || "Error processing message"
             });
           }
@@ -528,8 +537,6 @@ var DatabaseTransport = class {
         logger().error("Error in DatabaseTransport listen interval:", {
           error
         });
-      } finally {
-        await conn.disconnect();
       }
     });
   }, "processMessage");
@@ -542,27 +549,21 @@ var DatabaseTransport = class {
   }
   async dispatch(channel, message) {
     const conn = db(this.config.db_connection);
-    try {
-      await conn.connect();
-      let schema = conn.getSchema();
-      if (await schema.tableExists(this.config.queue_table) === false) {
-        return;
-      }
-      let q = conn.getQuery();
-      await q.table(this.config.queue_table).insert({
-        channel,
-        message,
-        processed: false,
-        created_at: /* @__PURE__ */ new Date(),
-        updated_at: /* @__PURE__ */ new Date(),
-        last_tried_at: null,
-        process_message: "",
-        retried_count: 0,
-        status: "pending"
-      });
-    } finally {
-      await conn.disconnect();
+    let schema = conn.getSchema();
+    if (await schema.tableExists(this.config.queue_table) === false) {
+      return;
     }
+    let q = conn.getQuery();
+    await q.table(this.config.queue_table).insert({
+      channel,
+      message,
+      created_at: /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date(),
+      last_tried_at: null,
+      process_message: "",
+      retried_count: 0,
+      status: "pending"
+    });
   }
   async registerListener(channel, callback) {
     this.channels.set(channel, callback);

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

@@ -490,8 +490,10 @@ var DatabaseTransport = class {
     db_connection: "default",
     listen_interval: 60,
     // seconds
-    message_limit: 10
+    message_limit: 10,
     // messages per each fetch
+    max_retry_count: 5
+    // maximum retry count for failed messages
   };
   channels = /* @__PURE__ */ new Map();
   messageQueues = [];
@@ -500,24 +502,31 @@ var DatabaseTransport = class {
     await import_neko_context2.context_provider.run(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();
+        let messages = await conn.getQuery().table(this.config.queue_table).whereOp("channel", "in", Array.from(this.channels.keys())).whereOp("status", "in", ["pending", "failed"]).whereOp("retried_count", "<", this.config.max_retry_count).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",
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processing",
               updated_at: /* @__PURE__ */ new Date(),
               last_tried_at: /* @__PURE__ */ new Date(),
               retried_count: (msg.retried_count || 0) + 1
             });
+            let callback = this.channels.get(msg.channel);
+            await callback(msg.message);
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processed",
+              updated_at: /* @__PURE__ */ new Date()
+            });
           } catch (error) {
+            logger().error("Error processing message:", {
+              error,
+              message_id: msg.id,
+              channel: msg.channel
+            });
             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,
+              updated_at: /* @__PURE__ */ new Date(),
               process_message: error.message || "Error processing message"
             });
           }
@@ -526,8 +535,6 @@ var DatabaseTransport = class {
         logger().error("Error in DatabaseTransport listen interval:", {
           error
         });
-      } finally {
-        await conn.disconnect();
       }
     });
   }, "processMessage");
@@ -540,27 +547,21 @@ var DatabaseTransport = class {
   }
   async dispatch(channel, message) {
     const conn = db(this.config.db_connection);
-    try {
-      await conn.connect();
-      let schema = conn.getSchema();
-      if (await schema.tableExists(this.config.queue_table) === false) {
-        return;
-      }
-      let q = conn.getQuery();
-      await q.table(this.config.queue_table).insert({
-        channel,
-        message,
-        processed: false,
-        created_at: /* @__PURE__ */ new Date(),
-        updated_at: /* @__PURE__ */ new Date(),
-        last_tried_at: null,
-        process_message: "",
-        retried_count: 0,
-        status: "pending"
-      });
-    } finally {
-      await conn.disconnect();
+    let schema = conn.getSchema();
+    if (await schema.tableExists(this.config.queue_table) === false) {
+      return;
     }
+    let q = conn.getQuery();
+    await q.table(this.config.queue_table).insert({
+      channel,
+      message,
+      created_at: /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date(),
+      last_tried_at: null,
+      process_message: "",
+      retried_count: 0,
+      status: "pending"
+    });
   }
   async registerListener(channel, callback) {
     this.channels.set(channel, callback);

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

@@ -490,8 +490,10 @@ var DatabaseTransport = class {
     db_connection: "default",
     listen_interval: 60,
     // seconds
-    message_limit: 10
+    message_limit: 10,
     // messages per each fetch
+    max_retry_count: 5
+    // maximum retry count for failed messages
   };
   channels = /* @__PURE__ */ new Map();
   messageQueues = [];
@@ -500,24 +502,31 @@ var DatabaseTransport = class {
     await import_neko_context2.context_provider.run(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();
+        let messages = await conn.getQuery().table(this.config.queue_table).whereOp("channel", "in", Array.from(this.channels.keys())).whereOp("status", "in", ["pending", "failed"]).whereOp("retried_count", "<", this.config.max_retry_count).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",
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processing",
               updated_at: /* @__PURE__ */ new Date(),
               last_tried_at: /* @__PURE__ */ new Date(),
               retried_count: (msg.retried_count || 0) + 1
             });
+            let callback = this.channels.get(msg.channel);
+            await callback(msg.message);
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processed",
+              updated_at: /* @__PURE__ */ new Date()
+            });
           } catch (error) {
+            logger().error("Error processing message:", {
+              error,
+              message_id: msg.id,
+              channel: msg.channel
+            });
             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,
+              updated_at: /* @__PURE__ */ new Date(),
               process_message: error.message || "Error processing message"
             });
           }
@@ -526,8 +535,6 @@ var DatabaseTransport = class {
         logger().error("Error in DatabaseTransport listen interval:", {
           error
         });
-      } finally {
-        await conn.disconnect();
       }
     });
   }, "processMessage");
@@ -540,27 +547,21 @@ var DatabaseTransport = class {
   }
   async dispatch(channel, message) {
     const conn = db(this.config.db_connection);
-    try {
-      await conn.connect();
-      let schema = conn.getSchema();
-      if (await schema.tableExists(this.config.queue_table) === false) {
-        return;
-      }
-      let q = conn.getQuery();
-      await q.table(this.config.queue_table).insert({
-        channel,
-        message,
-        processed: false,
-        created_at: /* @__PURE__ */ new Date(),
-        updated_at: /* @__PURE__ */ new Date(),
-        last_tried_at: null,
-        process_message: "",
-        retried_count: 0,
-        status: "pending"
-      });
-    } finally {
-      await conn.disconnect();
+    let schema = conn.getSchema();
+    if (await schema.tableExists(this.config.queue_table) === false) {
+      return;
     }
+    let q = conn.getQuery();
+    await q.table(this.config.queue_table).insert({
+      channel,
+      message,
+      created_at: /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date(),
+      last_tried_at: null,
+      process_message: "",
+      retried_count: 0,
+      status: "pending"
+    });
   }
   async registerListener(channel, callback) {
     this.channels.set(channel, callback);

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

@@ -1653,8 +1653,10 @@ var DatabaseTransport = class {
     db_connection: "default",
     listen_interval: 60,
     // seconds
-    message_limit: 10
+    message_limit: 10,
     // messages per each fetch
+    max_retry_count: 5
+    // maximum retry count for failed messages
   };
   channels = /* @__PURE__ */ new Map();
   messageQueues = [];
@@ -1663,24 +1665,31 @@ var DatabaseTransport = class {
     await import_neko_context2.context_provider.run(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();
+        let messages = await conn.getQuery().table(this.config.queue_table).whereOp("channel", "in", Array.from(this.channels.keys())).whereOp("status", "in", ["pending", "failed"]).whereOp("retried_count", "<", this.config.max_retry_count).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",
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processing",
               updated_at: /* @__PURE__ */ new Date(),
               last_tried_at: /* @__PURE__ */ new Date(),
               retried_count: (msg.retried_count || 0) + 1
             });
+            let callback = this.channels.get(msg.channel);
+            await callback(msg.message);
+            await conn.getQuery().table(this.config.queue_table).whereOp("id", "=", msg.id).update({
+              status: "processed",
+              updated_at: /* @__PURE__ */ new Date()
+            });
           } catch (error) {
+            logger().error("Error processing message:", {
+              error,
+              message_id: msg.id,
+              channel: msg.channel
+            });
             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,
+              updated_at: /* @__PURE__ */ new Date(),
               process_message: error.message || "Error processing message"
             });
           }
@@ -1689,8 +1698,6 @@ var DatabaseTransport = class {
         logger().error("Error in DatabaseTransport listen interval:", {
           error
         });
-      } finally {
-        await conn.disconnect();
       }
     });
   }, "processMessage");
@@ -1703,27 +1710,21 @@ var DatabaseTransport = class {
   }
   async dispatch(channel, message) {
     const conn = db(this.config.db_connection);
-    try {
-      await conn.connect();
-      let schema = conn.getSchema();
-      if (await schema.tableExists(this.config.queue_table) === false) {
-        return;
-      }
-      let q = conn.getQuery();
-      await q.table(this.config.queue_table).insert({
-        channel,
-        message,
-        processed: false,
-        created_at: /* @__PURE__ */ new Date(),
-        updated_at: /* @__PURE__ */ new Date(),
-        last_tried_at: null,
-        process_message: "",
-        retried_count: 0,
-        status: "pending"
-      });
-    } finally {
-      await conn.disconnect();
+    let schema = conn.getSchema();
+    if (await schema.tableExists(this.config.queue_table) === false) {
+      return;
     }
+    let q = conn.getQuery();
+    await q.table(this.config.queue_table).insert({
+      channel,
+      message,
+      created_at: /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date(),
+      last_tried_at: null,
+      process_message: "",
+      retried_count: 0,
+      status: "pending"
+    });
   }
   async registerListener(channel, callback) {
     this.channels.set(channel, callback);