@devbro/pashmak 0.1.11 → 0.1.12

package/dist/bin/index.cjs

@@ -561,8 +561,165 @@ var init_http = __esm({
   }
 });
 
+// src/queue.mts
+var queue_exports = {};
+__export(queue_exports, {
+  DatabaseTransport: () => DatabaseTransport
+});
+var import_neko_sql, DatabaseTransport;
+var init_queue = __esm({
+  "src/queue.mts"() {
+    "use strict";
+    __reExport(queue_exports, require("@devbro/neko-queue"));
+    import_neko_sql = require("@devbro/neko-sql");
+    DatabaseTransport = class {
+      // default to 100 messages per fetch
+      constructor(db_config) {
+        this.db_config = db_config;
+      }
+      static {
+        __name(this, "DatabaseTransport");
+      }
+      listenInterval = 6e4;
+      // default to 1 minute
+      messageLimit = 100;
+      setListenInterval(interval) {
+        this.listenInterval = interval;
+      }
+      setMessageLimit(limit) {
+        this.messageLimit = limit;
+      }
+      async dispatch(channel, message) {
+        const conn = new import_neko_sql.PostgresqlConnection(this.db_config);
+        try {
+          await conn.connect();
+          let q = conn.getQuery();
+          await q.table("queue_messages").insert({
+            channel,
+            message,
+            processed: false,
+            created_at: /* @__PURE__ */ new Date(),
+            updated_at: /* @__PURE__ */ new Date(),
+            last_tried_at: null,
+            process_message: ""
+          });
+        } finally {
+          await conn.disconnect();
+        }
+      }
+      async listen(channel, callback) {
+        return new Promise(async (resolve, reject) => {
+          setInterval(async () => {
+            const conn = new import_neko_sql.PostgresqlConnection(this.db_config);
+            try {
+              await conn.connect();
+              let q = conn.getQuery();
+              let messages = await q.table("queue_messages").whereOp("channel", "=", channel).whereOp("processed", "=", false).limit(this.messageLimit).orderBy("last_tried_at", "asc").get();
+              for (let msg of messages) {
+                try {
+                  await callback(msg.message);
+                  await q.table("queue_messages").whereOp("id", "=", msg.id).update({
+                    processed: true,
+                    updated_at: /* @__PURE__ */ new Date()
+                  });
+                } catch (error) {
+                  await q.table("queue_messages").whereOp("id", "=", msg.id).update({
+                    processed: false,
+                    last_tried_at: /* @__PURE__ */ new Date(),
+                    process_message: error.message || "Error processing message"
+                  });
+                }
+              }
+            } finally {
+              await conn.disconnect();
+            }
+          }, this.listenInterval);
+        });
+      }
+    };
+  }
+});
+
+// src/factories.mts
+var import_neko_mailer, import_neko_queue, import_neko_queue2, FlexibleFactory, MailerFactory, QueueFactory;
+var init_factories = __esm({
+  "src/factories.mts"() {
+    "use strict";
+    import_neko_mailer = require("@devbro/neko-mailer");
+    init_facades();
+    import_neko_queue = require("@devbro/neko-queue");
+    import_neko_queue2 = require("@devbro/neko-queue");
+    init_queue();
+    FlexibleFactory = class {
+      static {
+        __name(this, "FlexibleFactory");
+      }
+      registry = /* @__PURE__ */ new Map();
+      register(key, ctor) {
+        this.registry.set(key, ctor);
+      }
+      create(key, ...args) {
+        const ctor = this.registry.get(key);
+        if (!ctor) {
+          throw new Error(`No factory registered for key: ${key}`);
+        }
+        return new 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) => {
+      return new import_neko_mailer.FunctionProvider((mail) => {
+        logger().info({
+          msg: "Sending email",
+          mail
+        });
+      });
+    });
+    MailerFactory.register("SES", (opt) => {
+      return new import_neko_mailer.SESProvider(opt);
+    });
+    MailerFactory.register("SMTP", (opt) => {
+      return new import_neko_mailer.SMTPProvider(opt);
+    });
+    MailerFactory.register("MEMORY", (opt) => {
+      return new import_neko_mailer.MemoryProvider();
+    });
+    QueueFactory = class _QueueFactory {
+      static {
+        __name(this, "QueueFactory");
+      }
+      static instance = new FlexibleFactory();
+      static register(key, factory) {
+        _QueueFactory.instance.register(key, factory);
+      }
+      static create(key, ...args) {
+        return _QueueFactory.instance.create(key, ...args);
+      }
+    };
+    QueueFactory.register("database", (opt) => {
+      let transport = new DatabaseTransport(opt);
+      return new import_neko_queue.QueueConnection(transport);
+    });
+    QueueFactory.register("memory", (opt) => {
+      let transport = new import_neko_queue2.MemoryTransport(opt);
+      return new import_neko_queue.QueueConnection(transport);
+    });
+  }
+});
+
 // src/facades.mts
-var import_neko_scheduler, import_neko_helper, import_neko_context2, import_neko_storage, import_neko_mailer, import_neko_config, import_clipanion, yup, import_neko_logger, router, scheduler, db, storage, cli, httpServer, logger, mailer;
+var import_neko_scheduler, import_neko_helper, import_neko_context2, import_neko_storage, import_neko_mailer2, import_neko_config, import_clipanion, yup, import_neko_logger, router, scheduler, db, storage, cli, httpServer, logger, mailer, queue;
 var init_facades = __esm({
   "src/facades.mts"() {
     "use strict";
@@ -571,13 +728,14 @@ var init_facades = __esm({
     import_neko_helper = require("@devbro/neko-helper");
     import_neko_context2 = require("@devbro/neko-context");
     import_neko_storage = require("@devbro/neko-storage");
-    import_neko_mailer = require("@devbro/neko-mailer");
+    import_neko_mailer2 = require("@devbro/neko-mailer");
     import_neko_config = require("@devbro/neko-config");
     import_clipanion = require("clipanion");
     init_http();
     init_http();
     yup = __toESM(require("yup"), 1);
     import_neko_logger = require("@devbro/neko-logger");
+    init_factories();
     router = (0, import_neko_helper.createSingleton)(() => new Router());
     scheduler = (0, import_neko_helper.createSingleton)(() => {
       const rc = new import_neko_scheduler.Scheduler();
@@ -648,27 +806,19 @@ var init_facades = __esm({
     });
     mailer = (0, import_neko_helper.createSingleton)((label) => {
       const mailer_config = import_neko_config.config.get(["mailer", label].join("."));
-      let provider;
-      if (mailer_config.provider === "logger") {
-        provider = new import_neko_mailer.FunctionProvider((mail) => {
-          logger().info({
-            msg: "Sending email",
-            mail
-          });
-        });
-      } else if (mailer_config.provider === "SES") {
-        provider = new import_neko_mailer.SESProvider(mailer_config.config);
-      } else if (mailer_config.provider === "SMTP") {
-        provider = new import_neko_mailer.SMTPProvider(mailer_config.config);
-      } else if (mailer_config.provider === "MEMORY") {
-        provider = new import_neko_mailer.MemoryProvider();
-      }
-      if (!provider) {
-        throw new Error(
-          `cannot initiate mailer provider: ${mailer_config?.provider}`
-        );
+      let provider = MailerFactory.create(
+        mailer_config.provider,
+        mailer_config.config
+      );
+      const rc = new import_neko_mailer2.Mailer(provider);
+      return rc;
+    });
+    queue = (0, import_neko_helper.createSingleton)(async (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 rc = new import_neko_mailer.Mailer(provider);
+      const rc = await QueueFactory.create(queue_config.type, queue_config);
       return rc;
     });
   }
@@ -2052,14 +2202,14 @@ var init_migrate = __esm({
 });
 
 // src/app/console/StartCommand.mts
-var import_clipanion5, import_neko_config5, import_neko_sql, StartCommand;
+var import_clipanion5, import_neko_config5, import_neko_sql2, StartCommand;
 var init_StartCommand = __esm({
   "src/app/console/StartCommand.mts"() {
     "use strict";
     import_clipanion5 = require("clipanion");
     import_neko_config5 = require("@devbro/neko-config");
     init_facades();
-    import_neko_sql = require("@devbro/neko-sql");
+    import_neko_sql2 = require("@devbro/neko-sql");
     StartCommand = class extends import_clipanion5.Command {
       static {
         __name(this, "StartCommand");
@@ -2078,7 +2228,7 @@ var init_StartCommand = __esm({
         }
         logger().info(`Starting Server
 `);
-        import_neko_sql.PostgresqlConnection.defaults.idleTimeoutMillis = 1e4;
+        import_neko_sql2.PostgresqlConnection.defaults.idleTimeoutMillis = 1e4;
         if (this.scheduler || this.all) {
           logger().info(`starting scheduler
 `);
@@ -2441,12 +2591,12 @@ var DatabaseServiceProvider_exports = {};
 __export(DatabaseServiceProvider_exports, {
   DatabaseServiceProvider: () => DatabaseServiceProvider
 });
-var import_neko_sql2, import_neko_orm, import_neko_context5, import_neko_config7, DatabaseServiceProvider;
+var import_neko_sql3, import_neko_orm, import_neko_context5, import_neko_config7, DatabaseServiceProvider;
 var init_DatabaseServiceProvider = __esm({
   "src/DatabaseServiceProvider.mts"() {
     "use strict";
     init_dist();
-    import_neko_sql2 = require("@devbro/neko-sql");
+    import_neko_sql3 = require("@devbro/neko-sql");
     import_neko_orm = require("@devbro/neko-orm");
     import_neko_context5 = require("@devbro/neko-context");
     import_neko_config7 = require("@devbro/neko-config");
@@ -2483,7 +2633,7 @@ var init_DatabaseServiceProvider = __esm({
         return _DatabaseServiceProvider.instance;
       }
       async getConnection(db_config) {
-        const conn = new import_neko_sql2.PostgresqlConnection(db_config);
+        const conn = new import_neko_sql3.PostgresqlConnection(db_config);
         if (!await conn.connect()) {
           throw new Error("Failed to connect to the database");
         }

package/dist/bin/middlewares.cjs

@@ -458,7 +458,7 @@ var import_neko_scheduler = require("@devbro/neko-scheduler");
 var import_neko_helper = require("@devbro/neko-helper");
 var import_neko_context2 = require("@devbro/neko-context");
 var import_neko_storage = require("@devbro/neko-storage");
-var import_neko_mailer = require("@devbro/neko-mailer");
+var import_neko_mailer2 = require("@devbro/neko-mailer");
 var import_neko_config = require("@devbro/neko-config");
 var import_clipanion = require("clipanion");
 
@@ -469,6 +469,153 @@ __reExport(http_exports, require("@devbro/neko-http"));
 // src/facades.mts
 var yup = __toESM(require("yup"), 1);
 var import_neko_logger = require("@devbro/neko-logger");
+
+// src/factories.mts
+var import_neko_mailer = require("@devbro/neko-mailer");
+var import_neko_queue = require("@devbro/neko-queue");
+var import_neko_queue2 = require("@devbro/neko-queue");
+
+// src/queue.mts
+var queue_exports = {};
+__export(queue_exports, {
+  DatabaseTransport: () => DatabaseTransport
+});
+__reExport(queue_exports, require("@devbro/neko-queue"));
+var import_neko_sql = require("@devbro/neko-sql");
+var DatabaseTransport = class {
+  // default to 100 messages per fetch
+  constructor(db_config) {
+    this.db_config = db_config;
+  }
+  static {
+    __name(this, "DatabaseTransport");
+  }
+  listenInterval = 6e4;
+  // default to 1 minute
+  messageLimit = 100;
+  setListenInterval(interval) {
+    this.listenInterval = interval;
+  }
+  setMessageLimit(limit) {
+    this.messageLimit = limit;
+  }
+  async dispatch(channel, message) {
+    const conn = new import_neko_sql.PostgresqlConnection(this.db_config);
+    try {
+      await conn.connect();
+      let q = conn.getQuery();
+      await q.table("queue_messages").insert({
+        channel,
+        message,
+        processed: false,
+        created_at: /* @__PURE__ */ new Date(),
+        updated_at: /* @__PURE__ */ new Date(),
+        last_tried_at: null,
+        process_message: ""
+      });
+    } finally {
+      await conn.disconnect();
+    }
+  }
+  async listen(channel, callback) {
+    return new Promise(async (resolve, reject) => {
+      setInterval(async () => {
+        const conn = new import_neko_sql.PostgresqlConnection(this.db_config);
+        try {
+          await conn.connect();
+          let q = conn.getQuery();
+          let messages = await q.table("queue_messages").whereOp("channel", "=", channel).whereOp("processed", "=", false).limit(this.messageLimit).orderBy("last_tried_at", "asc").get();
+          for (let msg of messages) {
+            try {
+              await callback(msg.message);
+              await q.table("queue_messages").whereOp("id", "=", msg.id).update({
+                processed: true,
+                updated_at: /* @__PURE__ */ new Date()
+              });
+            } catch (error) {
+              await q.table("queue_messages").whereOp("id", "=", msg.id).update({
+                processed: false,
+                last_tried_at: /* @__PURE__ */ new Date(),
+                process_message: error.message || "Error processing message"
+              });
+            }
+          }
+        } finally {
+          await conn.disconnect();
+        }
+      }, this.listenInterval);
+    });
+  }
+};
+
+// src/factories.mts
+var FlexibleFactory = class {
+  static {
+    __name(this, "FlexibleFactory");
+  }
+  registry = /* @__PURE__ */ new Map();
+  register(key, ctor) {
+    this.registry.set(key, ctor);
+  }
+  create(key, ...args) {
+    const ctor = this.registry.get(key);
+    if (!ctor) {
+      throw new Error(`No factory registered for key: ${key}`);
+    }
+    return new 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) => {
+  return new import_neko_mailer.FunctionProvider((mail) => {
+    logger().info({
+      msg: "Sending email",
+      mail
+    });
+  });
+});
+MailerFactory.register("SES", (opt) => {
+  return new import_neko_mailer.SESProvider(opt);
+});
+MailerFactory.register("SMTP", (opt) => {
+  return new import_neko_mailer.SMTPProvider(opt);
+});
+MailerFactory.register("MEMORY", (opt) => {
+  return new import_neko_mailer.MemoryProvider();
+});
+var QueueFactory = class _QueueFactory {
+  static {
+    __name(this, "QueueFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _QueueFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _QueueFactory.instance.create(key, ...args);
+  }
+};
+QueueFactory.register("database", (opt) => {
+  let transport = new DatabaseTransport(opt);
+  return new import_neko_queue.QueueConnection(transport);
+});
+QueueFactory.register("memory", (opt) => {
+  let transport = new import_neko_queue2.MemoryTransport(opt);
+  return new import_neko_queue.QueueConnection(transport);
+});
+
+// src/facades.mts
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -539,27 +686,19 @@ 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("."));
-  let provider;
-  if (mailer_config.provider === "logger") {
-    provider = new import_neko_mailer.FunctionProvider((mail) => {
-      logger().info({
-        msg: "Sending email",
-        mail
-      });
-    });
-  } else if (mailer_config.provider === "SES") {
-    provider = new import_neko_mailer.SESProvider(mailer_config.config);
-  } else if (mailer_config.provider === "SMTP") {
-    provider = new import_neko_mailer.SMTPProvider(mailer_config.config);
-  } else if (mailer_config.provider === "MEMORY") {
-    provider = new import_neko_mailer.MemoryProvider();
-  }
-  if (!provider) {
-    throw new Error(
-      `cannot initiate mailer provider: ${mailer_config?.provider}`
-    );
-  }
-  const rc = new import_neko_mailer.Mailer(provider);
+  let provider = MailerFactory.create(
+    mailer_config.provider,
+    mailer_config.config
+  );
+  const rc = new import_neko_mailer2.Mailer(provider);
+  return rc;
+});
+var queue = (0, import_neko_helper.createSingleton)(async (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 rc = await QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
 

package/dist/bin/queue.cjs

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/queue.mts
+var queue_exports = {};
+__export(queue_exports, {
+  DatabaseTransport: () => DatabaseTransport
+});
+module.exports = __toCommonJS(queue_exports);
+__reExport(queue_exports, require("@devbro/neko-queue"), module.exports);
+var import_neko_sql = require("@devbro/neko-sql");
+var DatabaseTransport = class {
+  // default to 100 messages per fetch
+  constructor(db_config) {
+    this.db_config = db_config;
+  }
+  static {
+    __name(this, "DatabaseTransport");
+  }
+  listenInterval = 6e4;
+  // default to 1 minute
+  messageLimit = 100;
+  setListenInterval(interval) {
+    this.listenInterval = interval;
+  }
+  setMessageLimit(limit) {
+    this.messageLimit = limit;
+  }
+  async dispatch(channel, message) {
+    const conn = new import_neko_sql.PostgresqlConnection(this.db_config);
+    try {
+      await conn.connect();
+      let q = conn.getQuery();
+      await q.table("queue_messages").insert({
+        channel,
+        message,
+        processed: false,
+        created_at: /* @__PURE__ */ new Date(),
+        updated_at: /* @__PURE__ */ new Date(),
+        last_tried_at: null,
+        process_message: ""
+      });
+    } finally {
+      await conn.disconnect();
+    }
+  }
+  async listen(channel, callback) {
+    return new Promise(async (resolve, reject) => {
+      setInterval(async () => {
+        const conn = new import_neko_sql.PostgresqlConnection(this.db_config);
+        try {
+          await conn.connect();
+          let q = conn.getQuery();
+          let messages = await q.table("queue_messages").whereOp("channel", "=", channel).whereOp("processed", "=", false).limit(this.messageLimit).orderBy("last_tried_at", "asc").get();
+          for (let msg of messages) {
+            try {
+              await callback(msg.message);
+              await q.table("queue_messages").whereOp("id", "=", msg.id).update({
+                processed: true,
+                updated_at: /* @__PURE__ */ new Date()
+              });
+            } catch (error) {
+              await q.table("queue_messages").whereOp("id", "=", msg.id).update({
+                processed: false,
+                last_tried_at: /* @__PURE__ */ new Date(),
+                process_message: error.message || "Error processing message"
+              });
+            }
+          }
+        } finally {
+          await conn.disconnect();
+        }
+      }, this.listenInterval);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseTransport,
+  ...require("@devbro/neko-queue")
+});

package/dist/facades.d.mts

@@ -7,6 +7,7 @@ import { Storage } from '@devbro/neko-storage';
 import { Mailer } from '@devbro/neko-mailer';
 import { HttpServer } from '@devbro/neko-http';
 import { Logger } from '@devbro/neko-logger';
+import { QueueConnection } from '@devbro/neko-queue';
 
 declare const router: (label?: string, ...args: any[]) => Router;
 declare const scheduler: (label?: string, ...args: any[]) => Scheduler;
@@ -16,5 +17,6 @@ declare const cli: (label?: string, ...args: any[]) => Cli<clipanion.BaseContext
 declare const httpServer: (label?: string, ...args: any[]) => HttpServer;
 declare const logger: (label?: string, ...args: any[]) => Logger;
 declare const mailer: (label?: string, ...args: any[]) => Mailer;
+declare const queue: (label?: string, ...args: any[]) => Promise<QueueConnection<any>>;
 
-export { cli, db, httpServer, logger, mailer, router, scheduler, storage };
+export { cli, db, httpServer, logger, mailer, queue, router, scheduler, storage };

package/dist/facades.mjs

@@ -5,19 +5,14 @@ import { Scheduler } from "@devbro/neko-scheduler";
 import { createSingleton } from "@devbro/neko-helper";
 import { ctx, ctxSafe } from "@devbro/neko-context";
 import { StorageFactory } from "@devbro/neko-storage";
-import {
-  Mailer,
-  FunctionProvider,
-  SESProvider,
-  SMTPProvider,
-  MemoryProvider
-} from "@devbro/neko-mailer";
+import { Mailer } from "@devbro/neko-mailer";
 import { config } from "@devbro/neko-config";
 import { Cli } from "clipanion";
 import { HttpServer } from "./http.mjs";
 import { HttpError } from "./http.mjs";
 import * as yup from "yup";
 import { Logger } from "@devbro/neko-logger";
+import { MailerFactory, QueueFactory } from "./factories.mts";
 const router = createSingleton(() => new Router());
 const scheduler = createSingleton(() => {
   const rc = new Scheduler();
@@ -88,35 +83,28 @@ const logger = createSingleton((label) => {
 });
 const mailer = createSingleton((label) => {
   const mailer_config = config.get(["mailer", label].join("."));
-  let provider;
-  if (mailer_config.provider === "logger") {
-    provider = new FunctionProvider((mail) => {
-      logger().info({
-        msg: "Sending email",
-        mail
-      });
-    });
-  } else if (mailer_config.provider === "SES") {
-    provider = new SESProvider(mailer_config.config);
-  } else if (mailer_config.provider === "SMTP") {
-    provider = new SMTPProvider(mailer_config.config);
-  } else if (mailer_config.provider === "MEMORY") {
-    provider = new MemoryProvider();
-  }
-  if (!provider) {
-    throw new Error(
-      `cannot initiate mailer provider: ${mailer_config?.provider}`
-    );
-  }
+  let provider = MailerFactory.create(
+    mailer_config.provider,
+    mailer_config.config
+  );
   const rc = new Mailer(provider);
   return rc;
 });
+const queue = createSingleton(async (label) => {
+  const queue_config = config.get(["queues", label].join("."));
+  if (!queue_config) {
+    throw new Error(`Queue configuration for '${label}' not found`);
+  }
+  const rc = await QueueFactory.create(queue_config.type, queue_config);
+  return rc;
+});
 export {
   cli,
   db,
   httpServer,
   logger,
   mailer,
+  queue,
   router,
   scheduler,
   storage