@devbro/pashmak 0.1.19 → 0.1.21

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

@@ -1637,11 +1637,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",
@@ -1650,14 +1655,48 @@ var DatabaseTransport = class {
     message_limit: 10
     // messages per each fetch
   };
-  constructor(config5) {
+  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(config5 = {}) {
     this.config = { ...this.config, ...config5 };
-  }
-  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);
@@ -1675,50 +1714,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();
   }
 };
 
@@ -1741,19 +1752,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",
@@ -1761,32 +1760,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);
 });
@@ -1839,7 +1826,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)(() => {
@@ -1896,7 +1886,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
   );
@@ -1908,7 +1898,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;
 });

package/dist/bin/app/console/queue/GenerateQueueMigrateCommand.cjs

@@ -480,11 +480,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",
@@ -493,14 +498,48 @@ var DatabaseTransport = class {
     message_limit: 10
     // messages per each fetch
   };
-  constructor(config3) {
+  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(config3 = {}) {
     this.config = { ...this.config, ...config3 };
-  }
-  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);
@@ -518,50 +557,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();
   }
 };
 
@@ -584,19 +595,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",
@@ -604,32 +603,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);
 });
@@ -682,7 +669,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)(() => {
@@ -739,7 +729,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
   );
@@ -751,7 +741,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;
 });

package/dist/bin/cache.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;
 });