@devbro/pashmak 0.1.10 → 0.1.12

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

@@ -1202,6 +1202,9 @@ module.exports = __toCommonJS(console_exports);
 var import_neko_context = require("@devbro/neko-context");
 var import_errors = require("@devbro/neko-http/errors");
 
+// ../neko-router/dist/CompiledRoute.mjs
+var import_stream = require("stream");
+
 // ../neko-router/dist/Middleware.mjs
 var Middleware = class {
   static {
@@ -1279,6 +1282,9 @@ var CompiledRoute = class {
       if (typeof value.toJson === "function") {
         return traverse(value.toJson());
       }
+      if (typeof value.toJSON === "function") {
+        return traverse(value.toJSON());
+      }
       if (Array.isArray(value)) {
         return value.map(traverse);
       }
@@ -1303,7 +1309,7 @@ var CompiledRoute = class {
     }
     return String(obj);
   }
-  processResponseBody(res, controller_rc) {
+  async processResponseBody(res, controller_rc) {
     if (controller_rc && res.writableEnded) {
       throw new Error("cannot write to response, response has already ended");
     }
@@ -1312,18 +1318,36 @@ var CompiledRoute = class {
     }
     if (controller_rc) {
       const header_content_type = res.getHeader("Content-Type");
-      if (!header_content_type && typeof controller_rc === "object") {
+      if (controller_rc instanceof import_stream.Stream || Buffer.isBuffer(controller_rc)) {
+        await this.writeAsync(res, controller_rc);
+        res.end();
+      } else if (!header_content_type && typeof controller_rc === "object") {
         res.setHeader("Content-Type", "application/json");
+        res.end(this.convertToString(controller_rc));
       } else if (!header_content_type) {
         res.setHeader("Content-Type", "text/plain");
+        res.end(this.convertToString(controller_rc));
+      } else {
+        res.end(this.convertToString(controller_rc));
       }
-      res.end(this.convertToString(controller_rc));
       return;
     } else {
       res.statusCode = [200].includes(res.statusCode) ? 204 : res.statusCode;
       res.end();
     }
   }
+  async writeAsync(res, chunk) {
+    return new Promise((resolve, reject) => {
+      const ok = res.write(chunk, (err) => {
+        if (err) reject(err);
+      });
+      if (ok) {
+        resolve(0);
+      } else {
+        res.once("drain", resolve);
+      }
+    });
+  }
   async runMiddlewares(middlewares, req, res) {
     let index = 0;
     const me = this;
@@ -1381,7 +1405,7 @@ var Route = class {
         i = start;
       } else if (char === "*") {
         let start = i + 1;
-        while (start < path8.length && /[a-zA-Z0-9_]/.test(path8[start])) {
+        while (start < path8.length && /[a-zA-Z0-9_\.]/.test(path8[start])) {
           start++;
         }
         tokens.push({ type: "WILDCARD", value: path8.slice(i + 1, start) });
@@ -1451,6 +1475,10 @@ var Route = class {
       params: r.groups || {}
     };
   }
+  prependMiddleware(middlewares) {
+    this.middlewares = [].concat(middlewares, this.middlewares);
+    return this;
+  }
   addMiddleware(middlewares) {
     this.middlewares = this.middlewares.concat(middlewares);
     return this;
@@ -1465,6 +1493,62 @@ var Route = class {
 
 // ../neko-router/dist/Router.mjs
 var import_path = __toESM(require("path"), 1);
+
+// ../node_modules/url-join/lib/url-join.js
+function normalize(strArray) {
+  var resultArray = [];
+  if (strArray.length === 0) {
+    return "";
+  }
+  if (typeof strArray[0] !== "string") {
+    throw new TypeError("Url must be a string. Received " + strArray[0]);
+  }
+  if (strArray[0].match(/^[^/:]+:\/*$/) && strArray.length > 1) {
+    var first = strArray.shift();
+    strArray[0] = first + strArray[0];
+  }
+  if (strArray[0].match(/^file:\/\/\//)) {
+    strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, "$1:///");
+  } else {
+    strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, "$1://");
+  }
+  for (var i = 0; i < strArray.length; i++) {
+    var component = strArray[i];
+    if (typeof component !== "string") {
+      throw new TypeError("Url must be a string. Received " + component);
+    }
+    if (component === "") {
+      continue;
+    }
+    if (i > 0) {
+      component = component.replace(/^[\/]+/, "");
+    }
+    if (i < strArray.length - 1) {
+      component = component.replace(/[\/]+$/, "");
+    } else {
+      component = component.replace(/[\/]+$/, "/");
+    }
+    resultArray.push(component);
+  }
+  var str = resultArray.join("/");
+  str = str.replace(/\/(\?|&|#[^!])/g, "$1");
+  var parts = str.split("?");
+  str = parts.shift() + (parts.length > 0 ? "?" : "") + parts.join("&");
+  return str;
+}
+__name(normalize, "normalize");
+function urlJoin() {
+  var input;
+  if (typeof arguments[0] === "object") {
+    input = arguments[0];
+  } else {
+    input = [].slice.call(arguments);
+  }
+  return normalize(input);
+}
+__name(urlJoin, "urlJoin");
+
+// ../neko-router/dist/Router.mjs
 var Router = class {
   static {
     __name(this, "Router");
@@ -1489,6 +1573,12 @@ var Router = class {
       }).addMiddleware([...controller.baseMiddlewares, ...route.middlewares]);
     }
   }
+  addRouter(path22, router2) {
+    for (const route of router2.routes) {
+      let path222 = urlJoin("/", path22, route.path);
+      this.addRoute(route.methods, path222, route.handler).addMiddleware(router2.getMiddlewares()).addMiddleware(route.getMiddlewares());
+    }
+  }
   addGlobalMiddleware(middlewares) {
     this.middlewares = this.middlewares.concat(middlewares);
   }
@@ -1529,7 +1619,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");
 
@@ -1540,6 +1630,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();
@@ -1610,27 +1847,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}`
-    );
+  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 = new import_neko_mailer.Mailer(provider);
+  const rc = await QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
 
@@ -1645,29 +1874,46 @@ var MigrateCommand = class extends import_clipanion2.Command {
     __name(this, "MigrateCommand");
   }
   static paths = [[`migrate`]];
-  fresh = import_clipanion2.Option.Boolean("--fresh", false);
+  fresh = import_clipanion2.Option.Boolean(`--fresh`, false, {
+    description: `whether to delete and recreate database`
+  });
+  refresh = import_clipanion2.Option.Boolean(`--refresh`, false, {
+    description: `whether to drop all tables before running migrations by using rollback function`
+  });
   async execute() {
     await import_neko_context3.context_provider.run(async () => {
       const db2 = db();
       const schema = db2.getSchema();
       if (this.fresh) {
-        logger().info("dropping all tables!!");
-        let retry = true;
-        let retry_count = 0;
-        while (retry && retry_count < 10) {
-          retry = false;
-          retry_count++;
-          const tables = await schema.tables();
-          for (const table of tables) {
-            logger().info(`dropping table ${table.name}`);
-            try {
-              await schema.dropTable(table.name);
-            } catch {
-              logger().info(`failed to drop ${table.name}`);
-              retry = true;
-            }
+        throw new Error("not implemented");
+      }
+      if (this.refresh) {
+        logger().info("reverting all migrations!!");
+        const existing_migrations = await db2.runQuery({
+          sql: "select * from migrations order by created_at DESC",
+          bindings: []
+        });
+        const migrationsDir2 = import_neko_config2.config.get("migration.path");
+        for (const migration_record of existing_migrations) {
+          logger().info(`rolling back ${migration_record.filename}`);
+          try {
+            const MigrationClass = (await import(import_path2.default.join(migrationsDir2, migration_record.filename))).default;
+            const migrationInstance = new MigrationClass();
+            await migrationInstance.down(db2.getSchema());
+            await db2.runQuery({
+              sql: "delete from migrations where filename = $1",
+              bindings: [migration_record.filename]
+            });
+          } catch (error) {
+            logger().error(
+              `Failed to rollback migration ${migration_record.filename}: ${error}`
+            );
+            throw error;
           }
         }
+        logger().info(
+          `rolled back ${existing_migrations.length} migrations successfully!`
+        );
       }
       if (!await schema.tableExists("migrations")) {
         await schema.createTable("migrations", (blueprint) => {
@@ -1779,7 +2025,7 @@ var MigrateRollbackCommand = class extends import_clipanion4.Command {
     __name(this, "MigrateRollbackCommand");
   }
   static paths = [[`migrate`, "rollback"]];
-  steps = import_clipanion4.Option.String(`--steps`, {
+  steps = import_clipanion4.Option.String(`--steps`, "1", {
     description: `how many migrations to rollback`,
     validator: t.isNumber()
   });
@@ -1792,13 +2038,12 @@ var MigrateRollbackCommand = class extends import_clipanion4.Command {
       const dirEntries = await import_promises2.default.readdir(migrationsDir);
       files = dirEntries.filter((entry) => entry.endsWith(".ts")).sort();
       const migrations = await db2.runQuery({
-        sql: "select * from migrations order by created_at DESC",
-        bindings: []
+        sql: "select * from migrations order by created_at DESC limit $1",
+        bindings: [this.steps]
       });
-      const count = 0;
       for (const migration of migrations) {
         const class_to_migrate = migration.filename;
-        this.context.stdout.write(`rolling back ${class_to_migrate}`);
+        logger().info(`rolling back ${class_to_migrate}`);
         const ClassToMigrate = (await import(import_path4.default.join(migrationsDir, class_to_migrate))).default;
         const c = new ClassToMigrate();
         await c.down(db2.getSchema());
@@ -1815,7 +2060,7 @@ cli().register(MigrateRollbackCommand);
 // src/app/console/StartCommand.mts
 var import_clipanion5 = require("clipanion");
 var import_neko_config5 = require("@devbro/neko-config");
-var import_neko_sql = require("@devbro/neko-sql");
+var import_neko_sql2 = require("@devbro/neko-sql");
 var StartCommand = class extends import_clipanion5.Command {
   static {
     __name(this, "StartCommand");
@@ -1834,7 +2079,7 @@ var StartCommand = class extends import_clipanion5.Command {
     }
     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
 `);