@devbro/pashmak 0.1.26 → 0.1.28

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

@@ -0,0 +1,868 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/app/console/generate/GenerateApiDocsCommand.mts
+var GenerateApiDocsCommand_exports = {};
+__export(GenerateApiDocsCommand_exports, {
+  GenerateApiDocsCommand: () => GenerateApiDocsCommand
+});
+module.exports = __toCommonJS(GenerateApiDocsCommand_exports);
+
+// src/router.mts
+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 {
+    __name(this, "Middleware");
+  }
+  constructor(params = {}) {
+  }
+  static getInstance(params) {
+    throw new Error("Method not implemented. Please implement a static getInstance method.");
+  }
+};
+
+// ../neko-router/dist/MiddlewareFactory.mjs
+var MiddlewareFactory = class {
+  static {
+    __name(this, "MiddlewareFactory");
+  }
+  static create(func) {
+    const cls = class extends Middleware {
+      static {
+        __name(this, "cls");
+      }
+      call(req, res, next) {
+        return func(req, res, next);
+      }
+      constructor(params = {}) {
+        super(params);
+      }
+    };
+    return new cls();
+  }
+};
+
+// ../neko-router/dist/CompiledRoute.mjs
+var CompiledRoute = class {
+  static {
+    __name(this, "CompiledRoute");
+  }
+  constructor(route, request, response, globalMiddlewares = []) {
+    this.route = route;
+    this.request = request;
+    this.response = response;
+    this.globalMiddlewares = globalMiddlewares;
+    this.prepareMiddlewares();
+  }
+  middlewares = [];
+  getMiddlewares() {
+    return this.middlewares;
+  }
+  prepareMiddlewares() {
+    this.middlewares = [];
+    for (const middleware of [...this.globalMiddlewares, ...this.route.getMiddlewares()]) {
+      if (middleware instanceof Middleware) {
+        this.middlewares.push(middleware);
+      } else if (this.isClass(middleware)) {
+        this.middlewares.push(middleware.getInstance({}));
+      } else if (typeof middleware === "function") {
+        this.middlewares.push(MiddlewareFactory.create(middleware));
+      } else {
+        throw new Error("Invalid middleware type");
+      }
+    }
+  }
+  isClass(func) {
+    return typeof func === "function" && /^class\s/.test(Function.prototype.toString.call(func));
+  }
+  async run() {
+    return await this.runMiddlewares(this.middlewares, this.request, this.response);
+  }
+  prepareOutputJsonFormat(obj) {
+    function traverse(value) {
+      if (value === void 0 || value === null) {
+        return null;
+      }
+      if (!value || typeof value !== "object") {
+        return value;
+      }
+      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);
+      }
+      const result = {};
+      for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          result[key] = traverse(value[key]);
+        }
+      }
+      return result;
+    }
+    __name(traverse, "traverse");
+    return traverse(obj);
+  }
+  convertToString(obj) {
+    if (typeof obj === "string") {
+      return obj;
+    } else if (obj instanceof Buffer) {
+      return obj.toString();
+    } else if (typeof obj === "object") {
+      return JSON.stringify(this.prepareOutputJsonFormat(obj));
+    }
+    return String(obj);
+  }
+  async processResponseBody(res, controller_rc) {
+    if (controller_rc && res.writableEnded) {
+      throw new Error("cannot write to response, response has already ended");
+    }
+    if (res.writableEnded) {
+      return;
+    }
+    if (controller_rc) {
+      const header_content_type = res.getHeader("Content-Type");
+      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));
+      }
+      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;
+    async function next() {
+      if (index >= middlewares.length) {
+        const controller_rc = await me.route.callHanlder(req, res);
+        await me.processResponseBody(res, controller_rc);
+        return;
+      }
+      const middleware = middlewares[index++];
+      if (middleware instanceof Middleware) {
+        await middleware.call(req, res, next);
+      } else if (typeof middleware === "function") {
+        await middleware(req, res, next);
+      } else {
+        throw new Error("does not know how to run middleware");
+      }
+    }
+    __name(next, "next");
+    await next();
+  }
+};
+
+// ../neko-router/dist/Route.mjs
+var Route = class {
+  static {
+    __name(this, "Route");
+  }
+  constructor(methods, path3, handler) {
+    this.methods = methods;
+    this.path = path3;
+    this.handler = handler;
+    this.urlRegex = this.pathToRegex(path3);
+  }
+  middlewares = [];
+  urlRegex;
+  pathToRegex(path3) {
+    const lex = this.lexUrlPath(path3);
+    return this.tokensToRegex(lex);
+  }
+  lexUrlPath(path3) {
+    const tokens = [];
+    let i = 0;
+    while (i < path3.length) {
+      const char = path3[i];
+      if (char === "/") {
+        tokens.push({ type: "SLASH", value: "/" });
+        i++;
+      } else if (char === ":") {
+        let start = i + 1;
+        while (start < path3.length && /[a-zA-Z0-9_]/.test(path3[start])) {
+          start++;
+        }
+        tokens.push({ type: "PARAM", value: path3.slice(i + 1, start) });
+        i = start;
+      } else if (char === "*") {
+        let start = i + 1;
+        while (start < path3.length && /[a-zA-Z0-9_\.]/.test(path3[start])) {
+          start++;
+        }
+        tokens.push({ type: "WILDCARD", value: path3.slice(i + 1, start) });
+        i = start;
+      } else {
+        let start = i;
+        while (start < path3.length && !["/", ":", "*"].includes(path3[start])) {
+          start++;
+        }
+        tokens.push({ type: "TEXT", value: path3.slice(i, start) });
+        i = start;
+      }
+    }
+    return tokens;
+  }
+  tokensToRegex(tokens) {
+    const regexParts = [];
+    for (const token of tokens) {
+      if (token.type === "SLASH") {
+        regexParts.push("\\/");
+      } else if (token.type === "PARAM") {
+        regexParts.push(`(?<${token.value}>[^\\/]+)`);
+      } else if (token.type === "WILDCARD") {
+        regexParts.push("(.+)");
+      } else if (token.type === "TEXT") {
+        regexParts.push(token.value.replace(/[-\/\\^$.*+?()[\]{}|]/g, "\\$&"));
+      }
+    }
+    if (regexParts.length > 0 && regexParts[regexParts.length - 1] === "\\/") {
+      regexParts[regexParts.length - 1] = "\\/?";
+    } else {
+      regexParts.push("\\/?");
+    }
+    return new RegExp(`^${regexParts.join("")}$`);
+  }
+  /**
+   * to evaludate if request is a match for this route
+   * @param request http request
+   * @returns return true if route is a match for this request
+   */
+  test(request) {
+    if (this.methods.indexOf(request.method) === -1) {
+      return false;
+    }
+    const url = new URL(request.url || "/", "http://localhost");
+    return this.testPath(url.pathname);
+  }
+  testPath(pathname) {
+    return this.urlRegex.test(pathname);
+  }
+  /**
+   * returns details of the match, otherwise it returns false
+   * @param request the request to match
+   * @returns object cotaining details of match including matched params
+   */
+  match(request) {
+    if (this.methods.indexOf(request.method) === -1) {
+      return false;
+    }
+    const url = new URL(request.url || "/", "http://localhost");
+    const r = this.urlRegex.exec(url.pathname);
+    if (!r) {
+      return false;
+    }
+    return {
+      url,
+      params: r.groups || {}
+    };
+  }
+  prependMiddleware(middlewares) {
+    this.middlewares = [].concat(middlewares, this.middlewares);
+    return this;
+  }
+  addMiddleware(middlewares) {
+    this.middlewares = this.middlewares.concat(middlewares);
+    return this;
+  }
+  getMiddlewares() {
+    return this.middlewares;
+  }
+  callHanlder(request, response) {
+    return this.handler(request, response);
+  }
+};
+
+// ../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");
+  }
+  middlewares = [];
+  routes = [];
+  addRoute(methods, path22, handler) {
+    const route = new Route(methods, path22, handler);
+    this.routes.push(route);
+    return route;
+  }
+  getMiddlewares() {
+    return [...this.middlewares];
+  }
+  addController(controller) {
+    const basePath = controller.basePath || "";
+    for (const route of controller.routes) {
+      const urlPath = import_path.default.join(basePath, route.path);
+      this.addRoute(route.methods, urlPath, async (req, res) => {
+        const controllerInstance = controller.getInstance();
+        return await controllerInstance[route.handler]();
+      }).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);
+  }
+  resolve(request) {
+    for (const route of this.routes) {
+      if (route.test(request)) {
+        return route;
+      }
+    }
+    return void 0;
+  }
+  resolveMultiple(request) {
+    const rc = [];
+    const url = new URL(request.url || "/", "http://localhost");
+    for (const route of this.routes) {
+      if (route.testPath(url.pathname)) {
+        rc.push(route);
+      }
+    }
+    return rc;
+  }
+  getCompiledRoute(request, response) {
+    const route = this.resolve(request);
+    if (!route) {
+      return void 0;
+    }
+    const match = route.match(request);
+    if (!match) {
+      return void 0;
+    }
+    request.params = match.params;
+    return new CompiledRoute(route, request, response, this.middlewares);
+  }
+};
+
+// src/facades.mts
+var import_neko_scheduler = require("@devbro/neko-scheduler");
+var import_neko_helper2 = require("@devbro/neko-helper");
+var import_neko_context3 = require("@devbro/neko-context");
+var import_neko_storage2 = require("@devbro/neko-storage");
+var import_neko_mailer2 = require("@devbro/neko-mailer");
+var import_neko_config = require("@devbro/neko-config");
+var import_clipanion = require("clipanion");
+
+// src/http.mts
+var http_exports = {};
+__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");
+
+// src/queue.mts
+var queue_exports = {};
+__export(queue_exports, {
+  DatabaseTransport: () => DatabaseTransport
+});
+__reExport(queue_exports, require("@devbro/neko-queue"));
+var import_neko_helper = require("@devbro/neko-helper");
+var import_neko_context2 = require("@devbro/neko-context");
+var DatabaseTransport = class {
+  static {
+    __name(this, "DatabaseTransport");
+  }
+  config = {
+    queue_table: "queue_messages",
+    db_connection: "default",
+    listen_interval: 60,
+    // seconds
+    message_limit: 10,
+    // messages per each fetch
+    max_retry_count: 5
+    // maximum retry count for failed messages
+  };
+  channels = /* @__PURE__ */ new Map();
+  messageQueues = [];
+  repeater;
+  processMessage = /* @__PURE__ */ __name(async () => {
+    await import_neko_context2.context_provider.run(async () => {
+      const conn = db(this.config.db_connection);
+      try {
+        let q = conn.getQuery();
+        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 {
+            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",
+              updated_at: /* @__PURE__ */ new Date(),
+              process_message: error.message || "Error processing message"
+            });
+          }
+        }
+      } catch (error) {
+        logger().error("Error in DatabaseTransport listen interval:", {
+          error
+        });
+      }
+    });
+  }, "processMessage");
+  constructor(config2 = {}) {
+    this.config = { ...this.config, ...config2 };
+    this.repeater = (0, import_neko_helper.createRepeater)(
+      this.processMessage,
+      this.config.listen_interval * 1e3
+    );
+  }
+  async dispatch(channel, message) {
+    const conn = db(this.config.db_connection);
+    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);
+  }
+  async startListening() {
+    this.repeater.start();
+  }
+  async stopListening() {
+    this.repeater.stop();
+  }
+};
+
+// src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
+var import_neko_storage = require("@devbro/neko-storage");
+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 ctor(...args);
+  }
+};
+import_neko_mailer.MailerProviderFactory.register("ses", (opt) => {
+  return new import_neko_mailer.SESProvider(opt);
+});
+import_neko_mailer.MailerProviderFactory.register("smtp", (opt) => {
+  return new import_neko_mailer.SMTPProvider(opt);
+});
+import_neko_mailer.MailerProviderFactory.register("memory", (opt) => {
+  return new import_neko_mailer.MemoryProvider();
+});
+import_neko_queue.QueueTransportFactory.register("database", (opt) => {
+  return new DatabaseTransport(opt);
+});
+import_neko_queue.QueueTransportFactory.register("memory", (opt) => {
+  return new import_neko_queue.MemoryTransport(opt);
+});
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
+import_neko_storage.StorageProviderFactory.register("local", (opt) => {
+  return new import_neko_storage.LocalStorageProvider(opt);
+});
+import_neko_storage.StorageProviderFactory.register("s3", (opt) => {
+  return new import_neko_storage.AWSS3StorageProvider(opt);
+});
+
+// src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
+var import_neko_queue2 = require("@devbro/neko-queue");
+var router = (0, import_neko_helper2.createSingleton)(() => new Router());
+var scheduler = (0, import_neko_helper2.createSingleton)(() => {
+  const rc = new import_neko_scheduler.Scheduler();
+  rc.setErrorHandler((err, job) => {
+    logger().error({
+      msg: "Scheduled job error",
+      err,
+      job_name: job.getName()
+    });
+  });
+  return rc;
+});
+var db = /* @__PURE__ */ __name((label = "default") => (0, import_neko_context3.ctx)().getOrThrow(["database", label]), "db");
+var storage = (0, import_neko_helper2.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
+  );
+  return new import_neko_storage2.Storage(provider);
+});
+var cli = (0, import_neko_helper2.createSingleton)(() => {
+  const [node, app, ...args] = process.argv;
+  return new import_clipanion.Cli({
+    binaryLabel: `My Application`,
+    binaryName: `${node} ${app}`,
+    binaryVersion: `1.0.0`
+  });
+});
+var httpServer = (0, import_neko_helper2.createSingleton)(() => {
+  const server = new http_exports.HttpServer();
+  server.setErrorHandler(async (err, req, res) => {
+    if (err instanceof http_exports.HttpError) {
+      res.writeHead(err.statusCode, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ message: err.message, error: err.code }));
+      logger().warn({ msg: "HttpError: " + err.message, err });
+      return;
+    } else if (err instanceof yup.ValidationError) {
+      res.writeHead(422, { "Content-Type": "application/json" });
+      const errs = {};
+      err.inner.forEach((e) => {
+        const sanitizedParams = { ...e.params };
+        if (/passw/i.test(e.path)) {
+          sanitizedParams.value = "******";
+          sanitizedParams.originalValue = "******";
+        }
+        errs[e.path] = {
+          type: e.type,
+          message: e.message,
+          params: sanitizedParams
+        };
+      });
+      res.end(JSON.stringify({ message: "validation error", errors: errs }));
+      logger().warn({ msg: "ValidationError: " + err.message, err });
+      return;
+    } else {
+      logger().error({ msg: "Error: " + err.message, err });
+    }
+    res.writeHead(500, { "Content-Type": "" });
+    res.end(JSON.stringify({ error: "Internal Server Error" }));
+  });
+  server.setRouter(router());
+  return server;
+});
+var logger = (0, import_neko_helper2.createSingleton)((label) => {
+  const logger_config = import_neko_config.config.get(["loggers", label].join("."));
+  const rc = new import_neko_logger.Logger(logger_config);
+  rc.setExtrasFunction((message) => {
+    message.requestId = (0, import_neko_context3.ctxSafe)()?.get("requestId") || "N/A";
+    return message;
+  });
+  return rc;
+});
+var mailer = (0, import_neko_helper2.createSingleton)((label) => {
+  const mailer_config = import_neko_config.config.get(["mailer", label].join("."));
+  const provider = import_neko_mailer2.MailerProviderFactory.create(
+    mailer_config.provider,
+    mailer_config.config
+  );
+  const rc = new import_neko_mailer2.Mailer(provider);
+  return rc;
+});
+var queue = (0, import_neko_helper2.createSingleton)((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 provider = import_neko_queue2.QueueTransportFactory.create(
+    queue_config.provider,
+    queue_config.config
+  );
+  const rc = new import_neko_queue2.QueueConnection(provider);
+  return rc;
+});
+var cache = (0, import_neko_helper2.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.provider,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
+
+// src/app/console/generate/GenerateApiDocsCommand.mts
+var import_clipanion2 = require("clipanion");
+var import_path2 = __toESM(require("path"), 1);
+var fs = __toESM(require("fs/promises"), 1);
+var GenerateApiDocsCommand = class extends import_clipanion2.Command {
+  static {
+    __name(this, "GenerateApiDocsCommand");
+  }
+  static paths = [
+    [`make`, `apidocs`],
+    [`generate`, `apidocs`]
+  ];
+  async execute() {
+    const rootDir = process.cwd();
+    this.context.stdout.write(`Generating OpenAPI documentation...
+`);
+    const routes = router().routes;
+    const openApiSpec = {
+      openapi: "3.0.0",
+      info: {
+        title: "API Documentation",
+        version: "1.0.0",
+        description: "Auto-generated API documentation"
+      },
+      servers: [
+        {
+          url: "/",
+          description: "Local server"
+        }
+      ],
+      paths: {}
+    };
+    for (const route of routes) {
+      const routePath = route.path;
+      const openApiPath = routePath.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
+      if (!openApiSpec.paths[openApiPath]) {
+        openApiSpec.paths[openApiPath] = {};
+      }
+      for (const method of route.methods) {
+        const lowerMethod = method.toLowerCase();
+        if (lowerMethod === "head") {
+          continue;
+        }
+        openApiSpec.paths[openApiPath][lowerMethod] = {
+          summary: `${method} ${routePath}`,
+          description: `Endpoint for ${method} ${routePath}`,
+          parameters: this.extractParameters(routePath),
+          responses: {
+            "200": {
+              description: "Successful response",
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object"
+                  }
+                }
+              }
+            },
+            "500": {
+              description: "Internal server error"
+            }
+          }
+        };
+        if (["post", "put", "patch"].includes(lowerMethod)) {
+          openApiSpec.paths[openApiPath][lowerMethod].requestBody = {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object"
+                }
+              }
+            }
+          };
+        }
+      }
+    }
+    const publicDir = import_path2.default.join(rootDir, "public");
+    await fs.mkdir(publicDir, { recursive: true });
+    const outputPath = import_path2.default.join(publicDir, "openapi.json");
+    await fs.writeFile(
+      outputPath,
+      JSON.stringify(openApiSpec, null, 2),
+      "utf-8"
+    );
+    this.context.stdout.write(
+      `OpenAPI documentation generated at: ${outputPath}
+`
+    );
+    this.context.stdout.write(`Total routes documented: ${routes.length}
+`);
+  }
+  extractParameters(routePath) {
+    const paramRegex = /:([a-zA-Z0-9_]+)/g;
+    const parameters = [];
+    let match;
+    while ((match = paramRegex.exec(routePath)) !== null) {
+      parameters.push({
+        name: match[1],
+        in: "path",
+        required: true,
+        schema: {
+          type: "string"
+        },
+        description: `Path parameter ${match[1]}`
+      });
+    }
+    return parameters;
+  }
+};
+cli().register(GenerateApiDocsCommand);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenerateApiDocsCommand
+});