@devbro/pashmak 0.1.7 → 0.1.9

package/dist/bin/index.cjs

@@ -0,0 +1,2452 @@
+"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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);
+
+// ../neko-router/dist/types.mjs
+var init_types = __esm({
+  "../neko-router/dist/types.mjs"() {
+    "use strict";
+  }
+});
+
+// ../neko-router/dist/Middleware.mjs
+var Middleware;
+var init_Middleware = __esm({
+  "../neko-router/dist/Middleware.mjs"() {
+    "use strict";
+    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;
+var init_MiddlewareFactory = __esm({
+  "../neko-router/dist/MiddlewareFactory.mjs"() {
+    "use strict";
+    init_Middleware();
+    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;
+var init_CompiledRoute = __esm({
+  "../neko-router/dist/CompiledRoute.mjs"() {
+    "use strict";
+    init_Middleware();
+    init_MiddlewareFactory();
+    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 || typeof value !== "object") {
+            return value;
+          }
+          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);
+      }
+      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 (!header_content_type && typeof controller_rc === "object") {
+            res.setHeader("Content-Type", "application/json");
+          } else if (!header_content_type) {
+            res.setHeader("Content-Type", "text/plain");
+          }
+          res.end(this.convertToString(controller_rc));
+          return;
+        } else {
+          res.statusCode = [200].includes(res.statusCode) ? 204 : res.statusCode;
+          res.end();
+        }
+      }
+      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/Controller.mjs
+var init_Controller = __esm({
+  "../neko-router/dist/Controller.mjs"() {
+    "use strict";
+  }
+});
+
+// ../neko-router/dist/Route.mjs
+var Route;
+var init_Route = __esm({
+  "../neko-router/dist/Route.mjs"() {
+    "use strict";
+    Route = class {
+      static {
+        __name(this, "Route");
+      }
+      constructor(methods, path8, handler) {
+        this.methods = methods;
+        this.path = path8;
+        this.handler = handler;
+        this.urlRegex = this.pathToRegex(path8);
+      }
+      middlewares = [];
+      urlRegex;
+      pathToRegex(path8) {
+        const lex = this.lexUrlPath(path8);
+        return this.tokensToRegex(lex);
+      }
+      lexUrlPath(path8) {
+        const tokens = [];
+        let i = 0;
+        while (i < path8.length) {
+          const char = path8[i];
+          if (char === "/") {
+            tokens.push({ type: "SLASH", value: "/" });
+            i++;
+          } else if (char === ":") {
+            let start = i + 1;
+            while (start < path8.length && /[a-zA-Z0-9_]/.test(path8[start])) {
+              start++;
+            }
+            tokens.push({ type: "PARAM", value: path8.slice(i + 1, start) });
+            i = start;
+          } else if (char === "*") {
+            let start = i + 1;
+            while (start < path8.length && /[a-zA-Z0-9_]/.test(path8[start])) {
+              start++;
+            }
+            tokens.push({ type: "WILDCARD", value: path8.slice(i + 1, start) });
+            i = start;
+          } else {
+            let start = i;
+            while (start < path8.length && !["/", ":", "*"].includes(path8[start])) {
+              start++;
+            }
+            tokens.push({ type: "TEXT", value: path8.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 || {}
+        };
+      }
+      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, Router;
+var init_Router = __esm({
+  "../neko-router/dist/Router.mjs"() {
+    "use strict";
+    init_CompiledRoute();
+    init_Route();
+    import_path = __toESM(require("path"), 1);
+    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]);
+        }
+      }
+      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);
+      }
+    };
+  }
+});
+
+// ../neko-router/dist/helpers.mjs
+async function runNext(middlewares, req, res, final) {
+  let index = 0;
+  async function next() {
+    if (index >= middlewares.length) {
+      return await final(req, res);
+    }
+    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();
+}
+var init_helpers = __esm({
+  "../neko-router/dist/helpers.mjs"() {
+    "use strict";
+    init_Middleware();
+    __name(runNext, "runNext");
+  }
+});
+
+// ../neko-router/dist/index.mjs
+var init_dist = __esm({
+  "../neko-router/dist/index.mjs"() {
+    "use strict";
+    init_types();
+    init_CompiledRoute();
+    init_Controller();
+    init_Route();
+    init_Router();
+    init_Middleware();
+    init_MiddlewareFactory();
+    init_helpers();
+  }
+});
+
+// src/router.mts
+var import_neko_context, import_errors;
+var init_router = __esm({
+  "src/router.mts"() {
+    "use strict";
+    import_neko_context = require("@devbro/neko-context");
+    import_errors = require("@devbro/neko-http/errors");
+    init_dist();
+    init_dist();
+  }
+});
+
+// src/http.mts
+var http_exports = {};
+var init_http = __esm({
+  "src/http.mts"() {
+    "use strict";
+    __reExport(http_exports, require("@devbro/neko-http"));
+  }
+});
+
+// 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 init_facades = __esm({
+  "src/facades.mts"() {
+    "use strict";
+    init_router();
+    import_neko_scheduler = require("@devbro/neko-scheduler");
+    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_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");
+    router = (0, import_neko_helper.createSingleton)(() => new Router());
+    scheduler = (0, import_neko_helper.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;
+    });
+    db = /* @__PURE__ */ __name((label = "default") => (0, import_neko_context2.ctx)().getOrThrow(["database", label]), "db");
+    storage = (0, import_neko_helper.createSingleton)(
+      (label = "default") => import_neko_storage.StorageFactory.create(import_neko_config.config.get(["storages", label].join(".")))
+    );
+    cli = (0, import_neko_helper.createSingleton)(() => {
+      const [node, app, ...args] = process.argv;
+      return new import_clipanion.Cli({
+        binaryLabel: `My Application`,
+        binaryName: `${node} ${app}`,
+        binaryVersion: `1.0.0`
+      });
+    });
+    httpServer = (0, import_neko_helper.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;
+    });
+    logger = (0, import_neko_helper.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_context2.ctxSafe)()?.get("requestId") || "N/A";
+        return message;
+      });
+      return rc;
+    });
+    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);
+      return rc;
+    });
+  }
+});
+
+// src/app/console/migrate/MigrateCommand.ts
+var import_clipanion2, import_neko_context3, import_path2, import_promises, import_neko_config2, MigrateCommand;
+var init_MigrateCommand = __esm({
+  "src/app/console/migrate/MigrateCommand.ts"() {
+    "use strict";
+    init_facades();
+    import_clipanion2 = require("clipanion");
+    import_neko_context3 = require("@devbro/neko-context");
+    import_path2 = __toESM(require("path"));
+    import_promises = __toESM(require("fs/promises"));
+    import_neko_config2 = require("@devbro/neko-config");
+    MigrateCommand = class extends import_clipanion2.Command {
+      static {
+        __name(this, "MigrateCommand");
+      }
+      static paths = [
+        [
+          `migrate`
+        ]
+      ];
+      fresh = import_clipanion2.Option.Boolean("--fresh", false);
+      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;
+                }
+              }
+            }
+          }
+          if (!await schema.tableExists("migrations")) {
+            await schema.createTable("migrations", (blueprint) => {
+              blueprint.id();
+              blueprint.timestamps();
+              blueprint.string("filename");
+              blueprint.integer("batch");
+            });
+          }
+          const migrationsDir = import_neko_config2.config.get("migration.path");
+          let files = [];
+          const dirEntries = await import_promises.default.readdir(migrationsDir);
+          files = dirEntries.filter((entry) => entry.endsWith(".ts") || entry.endsWith(".js")).sort();
+          let batch_number = await db2.runQuery({
+            sql: "select max(batch) as next_batch from migrations",
+            bindings: []
+          });
+          batch_number = batch_number[0].next_batch || 0;
+          batch_number++;
+          const migrations = await db2.runQuery({
+            sql: "select * from migrations order by created_at ASC",
+            bindings: []
+          });
+          const completed_migrations = migrations.map((r) => r.filename);
+          const pending_migrations = files.filter((file) => !completed_migrations.includes(file));
+          let migrated_count = 0;
+          for (const class_to_migrate of pending_migrations) {
+            logger().info(`migrating up ${class_to_migrate}`);
+            const ClassToMigrate = (await import(import_path2.default.join(migrationsDir, class_to_migrate))).default;
+            const c = new ClassToMigrate();
+            await c.up(db2.getSchema());
+            await db2.runQuery({
+              sql: "insert into migrations (filename, batch) values ($1,$2)",
+              bindings: [
+                class_to_migrate,
+                batch_number
+              ]
+            });
+            migrated_count++;
+          }
+          if (migrated_count === 0) {
+            logger().warn("no migrations to run!");
+            return;
+          }
+          logger().info(`migrated ${migrated_count} migrations successfully!`);
+        });
+      }
+    };
+    cli().register(MigrateCommand);
+  }
+});
+
+// src/app/console/migrate/GenerateMigrateCommand.ts
+var import_clipanion3, import_change_case_all, import_path3, fs2, import_neko_config3, import_handlebars, import_url, import_meta, GenerateMigrateCommand;
+var init_GenerateMigrateCommand = __esm({
+  "src/app/console/migrate/GenerateMigrateCommand.ts"() {
+    "use strict";
+    init_facades();
+    import_clipanion3 = require("clipanion");
+    import_change_case_all = require("change-case-all");
+    import_path3 = __toESM(require("path"));
+    fs2 = __toESM(require("fs/promises"));
+    import_neko_config3 = require("@devbro/neko-config");
+    import_handlebars = __toESM(require("handlebars"));
+    import_url = require("url");
+    import_meta = {};
+    GenerateMigrateCommand = class extends import_clipanion3.Command {
+      static {
+        __name(this, "GenerateMigrateCommand");
+      }
+      static paths = [
+        [
+          `generate`,
+          `migrate`
+        ],
+        [
+          "generate",
+          "migration"
+        ]
+      ];
+      name = import_clipanion3.Option.String({
+        required: true
+      });
+      async execute() {
+        const date = /* @__PURE__ */ new Date();
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        const secondsOfDay = String(date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds()).padStart(5, "0");
+        const fixed_name = import_change_case_all.Case.snake(this.name);
+        const filename = `${year}_${month}_${day}_${secondsOfDay}_${fixed_name}.ts`;
+        this.context.stdout.write(`creating migration file ${filename}
+`);
+        await fs2.mkdir(import_neko_config3.config.get("migration.path"), {
+          recursive: true
+        });
+        let dirname = typeof __dirname === "string" ? __dirname : void 0;
+        if (!dirname) {
+          dirname = import_path3.default.dirname((0, import_url.fileURLToPath)(import_meta.url));
+        }
+        const compiledTemplate = import_handlebars.default.compile((await fs2.readFile(import_path3.default.join(dirname, "./make_migration.tpl"))).toString());
+        const template = await compiledTemplate({
+          className: import_change_case_all.Case.pascal(this.name) + "Migration",
+          tableName: import_change_case_all.Case.snake(this.name)
+        });
+        await fs2.writeFile(import_path3.default.join(import_neko_config3.config.get("migration.path"), filename), template);
+      }
+    };
+    cli().register(GenerateMigrateCommand);
+  }
+});
+
+// ../node_modules/typanion/lib/index.js
+var require_lib = __commonJS({
+  "../node_modules/typanion/lib/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    var simpleKeyRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    function getPrintable(value) {
+      if (value === null) return `null`;
+      if (value === void 0) return `undefined`;
+      if (value === ``) return `an empty string`;
+      if (typeof value === "symbol") return `<${value.toString()}>`;
+      if (Array.isArray(value)) return `an array`;
+      return JSON.stringify(value);
+    }
+    __name(getPrintable, "getPrintable");
+    function getPrintableArray(value, conjunction) {
+      if (value.length === 0) return `nothing`;
+      if (value.length === 1) return getPrintable(value[0]);
+      const rest = value.slice(0, -1);
+      const trailing = value[value.length - 1];
+      const separator = value.length > 2 ? `, ${conjunction} ` : ` ${conjunction} `;
+      return `${rest.map((value2) => getPrintable(value2)).join(`, `)}${separator}${getPrintable(trailing)}`;
+    }
+    __name(getPrintableArray, "getPrintableArray");
+    function computeKey(state, key) {
+      var _a, _b, _c;
+      if (typeof key === `number`) {
+        return `${(_a = state === null || state === void 0 ? void 0 : state.p) !== null && _a !== void 0 ? _a : `.`}[${key}]`;
+      } else if (simpleKeyRegExp.test(key)) {
+        return `${(_b = state === null || state === void 0 ? void 0 : state.p) !== null && _b !== void 0 ? _b : ``}.${key}`;
+      } else {
+        return `${(_c = state === null || state === void 0 ? void 0 : state.p) !== null && _c !== void 0 ? _c : `.`}[${JSON.stringify(key)}]`;
+      }
+    }
+    __name(computeKey, "computeKey");
+    function plural(n, singular, plural2) {
+      return n === 1 ? singular : plural2;
+    }
+    __name(plural, "plural");
+    var colorStringRegExp = /^#[0-9a-f]{6}$/i;
+    var colorStringAlphaRegExp = /^#[0-9a-f]{6}([0-9a-f]{2})?$/i;
+    var base64RegExp = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+    var uuid4RegExp = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}$/i;
+    var iso8601RegExp = /^(?:[1-9]\d{3}(-?)(?:(?:0[1-9]|1[0-2])\1(?:0[1-9]|1\d|2[0-8])|(?:0[13-9]|1[0-2])\1(?:29|30)|(?:0[13578]|1[02])(?:\1)31|00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[0-5]))|(?:[1-9]\d(?:0[48]|[2468][048]|[13579][26])|(?:[2468][048]|[13579][26])00)(?:(-?)02(?:\2)29|-?366))T(?:[01]\d|2[0-3])(:?)[0-5]\d(?:\3[0-5]\d)?(?:Z|[+-][01]\d(?:\3[0-5]\d)?)$/;
+    function pushError({ errors, p } = {}, message) {
+      errors === null || errors === void 0 ? void 0 : errors.push(`${p !== null && p !== void 0 ? p : `.`}: ${message}`);
+      return false;
+    }
+    __name(pushError, "pushError");
+    function makeSetter(target, key) {
+      return (v) => {
+        target[key] = v;
+      };
+    }
+    __name(makeSetter, "makeSetter");
+    function makeCoercionFn(target, key) {
+      return (v) => {
+        const previous = target[key];
+        target[key] = v;
+        return makeCoercionFn(target, key).bind(null, previous);
+      };
+    }
+    __name(makeCoercionFn, "makeCoercionFn");
+    function makeLazyCoercionFn(fn2, orig, generator) {
+      const commit = /* @__PURE__ */ __name(() => {
+        fn2(generator());
+        return revert;
+      }, "commit");
+      const revert = /* @__PURE__ */ __name(() => {
+        fn2(orig);
+        return commit;
+      }, "revert");
+      return commit;
+    }
+    __name(makeLazyCoercionFn, "makeLazyCoercionFn");
+    function isUnknown() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          return true;
+        }, "test")
+      });
+    }
+    __name(isUnknown, "isUnknown");
+    function isLiteral(expected) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (value !== expected) return pushError(state, `Expected ${getPrintable(expected)} (got ${getPrintable(value)})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isLiteral, "isLiteral");
+    function isString() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (typeof value !== `string`) return pushError(state, `Expected a string (got ${getPrintable(value)})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isString, "isString");
+    function isEnum(enumSpec) {
+      const valuesArray = Array.isArray(enumSpec) ? enumSpec : Object.values(enumSpec);
+      const isAlphaNum = valuesArray.every((item) => typeof item === "string" || typeof item === "number");
+      const values = new Set(valuesArray);
+      if (values.size === 1) return isLiteral([
+        ...values
+      ][0]);
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!values.has(value)) {
+            if (isAlphaNum) {
+              return pushError(state, `Expected one of ${getPrintableArray(valuesArray, `or`)} (got ${getPrintable(value)})`);
+            } else {
+              return pushError(state, `Expected a valid enumeration value (got ${getPrintable(value)})`);
+            }
+          }
+          return true;
+        }, "test")
+      });
+    }
+    __name(isEnum, "isEnum");
+    var BOOLEAN_COERCIONS = /* @__PURE__ */ new Map([
+      [
+        `true`,
+        true
+      ],
+      [
+        `True`,
+        true
+      ],
+      [
+        `1`,
+        true
+      ],
+      [
+        1,
+        true
+      ],
+      [
+        `false`,
+        false
+      ],
+      [
+        `False`,
+        false
+      ],
+      [
+        `0`,
+        false
+      ],
+      [
+        0,
+        false
+      ]
+    ]);
+    function isBoolean() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          var _a;
+          if (typeof value !== `boolean`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+              const coercion = BOOLEAN_COERCIONS.get(value);
+              if (typeof coercion !== `undefined`) {
+                state.coercions.push([
+                  (_a = state.p) !== null && _a !== void 0 ? _a : `.`,
+                  state.coercion.bind(null, coercion)
+                ]);
+                return true;
+              }
+            }
+            return pushError(state, `Expected a boolean (got ${getPrintable(value)})`);
+          }
+          return true;
+        }, "test")
+      });
+    }
+    __name(isBoolean, "isBoolean");
+    function isNumber2() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          var _a;
+          if (typeof value !== `number`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+              let coercion;
+              if (typeof value === `string`) {
+                let val;
+                try {
+                  val = JSON.parse(value);
+                } catch (_b) {
+                }
+                if (typeof val === `number`) {
+                  if (JSON.stringify(val) === value) {
+                    coercion = val;
+                  } else {
+                    return pushError(state, `Received a number that can't be safely represented by the runtime (${value})`);
+                  }
+                }
+              }
+              if (typeof coercion !== `undefined`) {
+                state.coercions.push([
+                  (_a = state.p) !== null && _a !== void 0 ? _a : `.`,
+                  state.coercion.bind(null, coercion)
+                ]);
+                return true;
+              }
+            }
+            return pushError(state, `Expected a number (got ${getPrintable(value)})`);
+          }
+          return true;
+        }, "test")
+      });
+    }
+    __name(isNumber2, "isNumber");
+    function isPayload(spec) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          var _a;
+          if (typeof (state === null || state === void 0 ? void 0 : state.coercions) === `undefined`) return pushError(state, `The isPayload predicate can only be used with coercion enabled`);
+          if (typeof state.coercion === `undefined`) return pushError(state, `Unbound coercion result`);
+          if (typeof value !== `string`) return pushError(state, `Expected a string (got ${getPrintable(value)})`);
+          let inner;
+          try {
+            inner = JSON.parse(value);
+          } catch (_b) {
+            return pushError(state, `Expected a JSON string (got ${getPrintable(value)})`);
+          }
+          const wrapper = {
+            value: inner
+          };
+          if (!spec(inner, Object.assign(Object.assign({}, state), {
+            coercion: makeCoercionFn(wrapper, `value`)
+          }))) return false;
+          state.coercions.push([
+            (_a = state.p) !== null && _a !== void 0 ? _a : `.`,
+            state.coercion.bind(null, wrapper.value)
+          ]);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isPayload, "isPayload");
+    function isDate() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          var _a;
+          if (!(value instanceof Date)) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+              let coercion;
+              if (typeof value === `string` && iso8601RegExp.test(value)) {
+                coercion = new Date(value);
+              } else {
+                let timestamp;
+                if (typeof value === `string`) {
+                  let val;
+                  try {
+                    val = JSON.parse(value);
+                  } catch (_b) {
+                  }
+                  if (typeof val === `number`) {
+                    timestamp = val;
+                  }
+                } else if (typeof value === `number`) {
+                  timestamp = value;
+                }
+                if (typeof timestamp !== `undefined`) {
+                  if (Number.isSafeInteger(timestamp) || !Number.isSafeInteger(timestamp * 1e3)) {
+                    coercion = new Date(timestamp * 1e3);
+                  } else {
+                    return pushError(state, `Received a timestamp that can't be safely represented by the runtime (${value})`);
+                  }
+                }
+              }
+              if (typeof coercion !== `undefined`) {
+                state.coercions.push([
+                  (_a = state.p) !== null && _a !== void 0 ? _a : `.`,
+                  state.coercion.bind(null, coercion)
+                ]);
+                return true;
+              }
+            }
+            return pushError(state, `Expected a date (got ${getPrintable(value)})`);
+          }
+          return true;
+        }, "test")
+      });
+    }
+    __name(isDate, "isDate");
+    function isArray(spec, { delimiter } = {}) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          var _a;
+          const originalValue = value;
+          if (typeof value === `string` && typeof delimiter !== `undefined`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+              value = value.split(delimiter);
+            }
+          }
+          if (!Array.isArray(value)) return pushError(state, `Expected an array (got ${getPrintable(value)})`);
+          let valid = true;
+          for (let t2 = 0, T = value.length; t2 < T; ++t2) {
+            valid = spec(value[t2], Object.assign(Object.assign({}, state), {
+              p: computeKey(state, t2),
+              coercion: makeCoercionFn(value, t2)
+            })) && valid;
+            if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+              break;
+            }
+          }
+          if (value !== originalValue) state.coercions.push([
+            (_a = state.p) !== null && _a !== void 0 ? _a : `.`,
+            state.coercion.bind(null, value)
+          ]);
+          return valid;
+        }, "test")
+      });
+    }
+    __name(isArray, "isArray");
+    function isSet(spec, { delimiter } = {}) {
+      const isArrayValidator = isArray(spec, {
+        delimiter
+      });
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          var _a, _b;
+          if (Object.getPrototypeOf(value).toString() === `[object Set]`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+              const originalValues = [
+                ...value
+              ];
+              const coercedValues = [
+                ...value
+              ];
+              if (!isArrayValidator(coercedValues, Object.assign(Object.assign({}, state), {
+                coercion: void 0
+              }))) return false;
+              const updateValue = /* @__PURE__ */ __name(() => coercedValues.some((val, t2) => val !== originalValues[t2]) ? new Set(coercedValues) : value, "updateValue");
+              state.coercions.push([
+                (_a = state.p) !== null && _a !== void 0 ? _a : `.`,
+                makeLazyCoercionFn(state.coercion, value, updateValue)
+              ]);
+              return true;
+            } else {
+              let valid = true;
+              for (const subValue of value) {
+                valid = spec(subValue, Object.assign({}, state)) && valid;
+                if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+                  break;
+                }
+              }
+              return valid;
+            }
+          }
+          if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+            const store = {
+              value
+            };
+            if (!isArrayValidator(value, Object.assign(Object.assign({}, state), {
+              coercion: makeCoercionFn(store, `value`)
+            }))) return false;
+            state.coercions.push([
+              (_b = state.p) !== null && _b !== void 0 ? _b : `.`,
+              makeLazyCoercionFn(state.coercion, value, () => new Set(store.value))
+            ]);
+            return true;
+          }
+          return pushError(state, `Expected a set (got ${getPrintable(value)})`);
+        }, "test")
+      });
+    }
+    __name(isSet, "isSet");
+    function isMap(keySpec, valueSpec) {
+      const isArrayValidator = isArray(isTuple([
+        keySpec,
+        valueSpec
+      ]));
+      const isRecordValidator = isRecord(valueSpec, {
+        keys: keySpec
+      });
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          var _a, _b, _c;
+          if (Object.getPrototypeOf(value).toString() === `[object Map]`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+              const originalValues = [
+                ...value
+              ];
+              const coercedValues = [
+                ...value
+              ];
+              if (!isArrayValidator(coercedValues, Object.assign(Object.assign({}, state), {
+                coercion: void 0
+              }))) return false;
+              const updateValue = /* @__PURE__ */ __name(() => coercedValues.some((val, t2) => val[0] !== originalValues[t2][0] || val[1] !== originalValues[t2][1]) ? new Map(coercedValues) : value, "updateValue");
+              state.coercions.push([
+                (_a = state.p) !== null && _a !== void 0 ? _a : `.`,
+                makeLazyCoercionFn(state.coercion, value, updateValue)
+              ]);
+              return true;
+            } else {
+              let valid = true;
+              for (const [key, subValue] of value) {
+                valid = keySpec(key, Object.assign({}, state)) && valid;
+                if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+                  break;
+                }
+                valid = valueSpec(subValue, Object.assign(Object.assign({}, state), {
+                  p: computeKey(state, key)
+                })) && valid;
+                if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+                  break;
+                }
+              }
+              return valid;
+            }
+          }
+          if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+            const store = {
+              value
+            };
+            if (Array.isArray(value)) {
+              if (!isArrayValidator(value, Object.assign(Object.assign({}, state), {
+                coercion: void 0
+              }))) return false;
+              state.coercions.push([
+                (_b = state.p) !== null && _b !== void 0 ? _b : `.`,
+                makeLazyCoercionFn(state.coercion, value, () => new Map(store.value))
+              ]);
+              return true;
+            } else {
+              if (!isRecordValidator(value, Object.assign(Object.assign({}, state), {
+                coercion: makeCoercionFn(store, `value`)
+              }))) return false;
+              state.coercions.push([
+                (_c = state.p) !== null && _c !== void 0 ? _c : `.`,
+                makeLazyCoercionFn(state.coercion, value, () => new Map(Object.entries(store.value)))
+              ]);
+              return true;
+            }
+          }
+          return pushError(state, `Expected a map (got ${getPrintable(value)})`);
+        }, "test")
+      });
+    }
+    __name(isMap, "isMap");
+    function isTuple(spec, { delimiter } = {}) {
+      const lengthValidator = hasExactLength(spec.length);
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          var _a;
+          if (typeof value === `string` && typeof delimiter !== `undefined`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+              value = value.split(delimiter);
+              state.coercions.push([
+                (_a = state.p) !== null && _a !== void 0 ? _a : `.`,
+                state.coercion.bind(null, value)
+              ]);
+            }
+          }
+          if (!Array.isArray(value)) return pushError(state, `Expected a tuple (got ${getPrintable(value)})`);
+          let valid = lengthValidator(value, Object.assign({}, state));
+          for (let t2 = 0, T = value.length; t2 < T && t2 < spec.length; ++t2) {
+            valid = spec[t2](value[t2], Object.assign(Object.assign({}, state), {
+              p: computeKey(state, t2),
+              coercion: makeCoercionFn(value, t2)
+            })) && valid;
+            if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+              break;
+            }
+          }
+          return valid;
+        }, "test")
+      });
+    }
+    __name(isTuple, "isTuple");
+    function isRecord(spec, { keys: keySpec = null } = {}) {
+      const isArrayValidator = isArray(isTuple([
+        keySpec !== null && keySpec !== void 0 ? keySpec : isString(),
+        spec
+      ]));
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          var _a;
+          if (Array.isArray(value)) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+              if (!isArrayValidator(value, Object.assign(Object.assign({}, state), {
+                coercion: void 0
+              }))) return false;
+              value = Object.fromEntries(value);
+              state.coercions.push([
+                (_a = state.p) !== null && _a !== void 0 ? _a : `.`,
+                state.coercion.bind(null, value)
+              ]);
+              return true;
+            }
+          }
+          if (typeof value !== `object` || value === null) return pushError(state, `Expected an object (got ${getPrintable(value)})`);
+          const keys = Object.keys(value);
+          let valid = true;
+          for (let t2 = 0, T = keys.length; t2 < T && (valid || (state === null || state === void 0 ? void 0 : state.errors) != null); ++t2) {
+            const key = keys[t2];
+            const sub = value[key];
+            if (key === `__proto__` || key === `constructor`) {
+              valid = pushError(Object.assign(Object.assign({}, state), {
+                p: computeKey(state, key)
+              }), `Unsafe property name`);
+              continue;
+            }
+            if (keySpec !== null && !keySpec(key, state)) {
+              valid = false;
+              continue;
+            }
+            if (!spec(sub, Object.assign(Object.assign({}, state), {
+              p: computeKey(state, key),
+              coercion: makeCoercionFn(value, key)
+            }))) {
+              valid = false;
+              continue;
+            }
+          }
+          return valid;
+        }, "test")
+      });
+    }
+    __name(isRecord, "isRecord");
+    function isDict(spec, opts = {}) {
+      return isRecord(spec, opts);
+    }
+    __name(isDict, "isDict");
+    function isObject(props, { extra: extraSpec = null } = {}) {
+      const specKeys = Object.keys(props);
+      const validator = makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (typeof value !== `object` || value === null) return pushError(state, `Expected an object (got ${getPrintable(value)})`);
+          const keys = /* @__PURE__ */ new Set([
+            ...specKeys,
+            ...Object.keys(value)
+          ]);
+          const extra = {};
+          let valid = true;
+          for (const key of keys) {
+            if (key === `constructor` || key === `__proto__`) {
+              valid = pushError(Object.assign(Object.assign({}, state), {
+                p: computeKey(state, key)
+              }), `Unsafe property name`);
+            } else {
+              const spec = Object.prototype.hasOwnProperty.call(props, key) ? props[key] : void 0;
+              const sub = Object.prototype.hasOwnProperty.call(value, key) ? value[key] : void 0;
+              if (typeof spec !== `undefined`) {
+                valid = spec(sub, Object.assign(Object.assign({}, state), {
+                  p: computeKey(state, key),
+                  coercion: makeCoercionFn(value, key)
+                })) && valid;
+              } else if (extraSpec === null) {
+                valid = pushError(Object.assign(Object.assign({}, state), {
+                  p: computeKey(state, key)
+                }), `Extraneous property (got ${getPrintable(sub)})`);
+              } else {
+                Object.defineProperty(extra, key, {
+                  enumerable: true,
+                  get: /* @__PURE__ */ __name(() => sub, "get"),
+                  set: makeSetter(value, key)
+                });
+              }
+            }
+            if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+              break;
+            }
+          }
+          if (extraSpec !== null && (valid || (state === null || state === void 0 ? void 0 : state.errors) != null)) valid = extraSpec(extra, state) && valid;
+          return valid;
+        }, "test")
+      });
+      return Object.assign(validator, {
+        properties: props
+      });
+    }
+    __name(isObject, "isObject");
+    function isPartial(props) {
+      return isObject(props, {
+        extra: isRecord(isUnknown())
+      });
+    }
+    __name(isPartial, "isPartial");
+    var isInstanceOf = /* @__PURE__ */ __name((constructor) => makeValidator({
+      test: /* @__PURE__ */ __name((value, state) => {
+        if (!(value instanceof constructor)) return pushError(state, `Expected an instance of ${constructor.name} (got ${getPrintable(value)})`);
+        return true;
+      }, "test")
+    }), "isInstanceOf");
+    var isOneOf = /* @__PURE__ */ __name((specs, { exclusive = false } = {}) => makeValidator({
+      test: /* @__PURE__ */ __name((value, state) => {
+        var _a, _b, _c;
+        const matches = [];
+        const errorBuffer = typeof (state === null || state === void 0 ? void 0 : state.errors) !== `undefined` ? [] : void 0;
+        for (let t2 = 0, T = specs.length; t2 < T; ++t2) {
+          const subErrors = typeof (state === null || state === void 0 ? void 0 : state.errors) !== `undefined` ? [] : void 0;
+          const subCoercions = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? [] : void 0;
+          if (specs[t2](value, Object.assign(Object.assign({}, state), {
+            errors: subErrors,
+            coercions: subCoercions,
+            p: `${(_a = state === null || state === void 0 ? void 0 : state.p) !== null && _a !== void 0 ? _a : `.`}#${t2 + 1}`
+          }))) {
+            matches.push([
+              `#${t2 + 1}`,
+              subCoercions
+            ]);
+            if (!exclusive) {
+              break;
+            }
+          } else {
+            errorBuffer === null || errorBuffer === void 0 ? void 0 : errorBuffer.push(subErrors[0]);
+          }
+        }
+        if (matches.length === 1) {
+          const [, subCoercions] = matches[0];
+          if (typeof subCoercions !== `undefined`) (_b = state === null || state === void 0 ? void 0 : state.coercions) === null || _b === void 0 ? void 0 : _b.push(...subCoercions);
+          return true;
+        }
+        if (matches.length > 1) pushError(state, `Expected to match exactly a single predicate (matched ${matches.join(`, `)})`);
+        else (_c = state === null || state === void 0 ? void 0 : state.errors) === null || _c === void 0 ? void 0 : _c.push(...errorBuffer);
+        return false;
+      }, "test")
+    }), "isOneOf");
+    function makeTrait(value) {
+      return () => {
+        return value;
+      };
+    }
+    __name(makeTrait, "makeTrait");
+    function makeValidator({ test }) {
+      return makeTrait(test)();
+    }
+    __name(makeValidator, "makeValidator");
+    var TypeAssertionError = class TypeAssertionError extends Error {
+      static {
+        __name(this, "TypeAssertionError");
+      }
+      constructor({ errors } = {}) {
+        let errorMessage = `Type mismatch`;
+        if (errors && errors.length > 0) {
+          errorMessage += `
+`;
+          for (const error of errors) {
+            errorMessage += `
+- ${error}`;
+          }
+        }
+        super(errorMessage);
+      }
+    };
+    function assert(val, validator) {
+      if (!validator(val)) {
+        throw new TypeAssertionError();
+      }
+    }
+    __name(assert, "assert");
+    function assertWithErrors(val, validator) {
+      const errors = [];
+      if (!validator(val, {
+        errors
+      })) {
+        throw new TypeAssertionError({
+          errors
+        });
+      }
+    }
+    __name(assertWithErrors, "assertWithErrors");
+    function softAssert(val, validator) {
+    }
+    __name(softAssert, "softAssert");
+    function as(value, validator, { coerce = false, errors: storeErrors, throw: throws } = {}) {
+      const errors = storeErrors ? [] : void 0;
+      if (!coerce) {
+        if (validator(value, {
+          errors
+        })) {
+          return throws ? value : {
+            value,
+            errors: void 0
+          };
+        } else if (!throws) {
+          return {
+            value: void 0,
+            errors: errors !== null && errors !== void 0 ? errors : true
+          };
+        } else {
+          throw new TypeAssertionError({
+            errors
+          });
+        }
+      }
+      const state = {
+        value
+      };
+      const coercion = makeCoercionFn(state, `value`);
+      const coercions = [];
+      if (!validator(value, {
+        errors,
+        coercion,
+        coercions
+      })) {
+        if (!throws) {
+          return {
+            value: void 0,
+            errors: errors !== null && errors !== void 0 ? errors : true
+          };
+        } else {
+          throw new TypeAssertionError({
+            errors
+          });
+        }
+      }
+      for (const [, apply] of coercions) apply();
+      if (throws) {
+        return state.value;
+      } else {
+        return {
+          value: state.value,
+          errors: void 0
+        };
+      }
+    }
+    __name(as, "as");
+    function fn(validators, fn2) {
+      const isValidArgList = isTuple(validators);
+      return (...args) => {
+        const check = isValidArgList(args);
+        if (!check) throw new TypeAssertionError();
+        return fn2(...args);
+      };
+    }
+    __name(fn, "fn");
+    function hasMinLength(length) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!(value.length >= length)) return pushError(state, `Expected to have a length of at least ${length} elements (got ${value.length})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(hasMinLength, "hasMinLength");
+    function hasMaxLength(length) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!(value.length <= length)) return pushError(state, `Expected to have a length of at most ${length} elements (got ${value.length})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(hasMaxLength, "hasMaxLength");
+    function hasExactLength(length) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!(value.length === length)) return pushError(state, `Expected to have a length of exactly ${length} elements (got ${value.length})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(hasExactLength, "hasExactLength");
+    function hasUniqueItems({ map } = {}) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          const set = /* @__PURE__ */ new Set();
+          const dup = /* @__PURE__ */ new Set();
+          for (let t2 = 0, T = value.length; t2 < T; ++t2) {
+            const sub = value[t2];
+            const key = typeof map !== `undefined` ? map(sub) : sub;
+            if (set.has(key)) {
+              if (dup.has(key)) continue;
+              pushError(state, `Expected to contain unique elements; got a duplicate with ${getPrintable(value)}`);
+              dup.add(key);
+            } else {
+              set.add(key);
+            }
+          }
+          return dup.size === 0;
+        }, "test")
+      });
+    }
+    __name(hasUniqueItems, "hasUniqueItems");
+    function isNegative() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!(value <= 0)) return pushError(state, `Expected to be negative (got ${value})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isNegative, "isNegative");
+    function isPositive() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!(value >= 0)) return pushError(state, `Expected to be positive (got ${value})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isPositive, "isPositive");
+    function isAtLeast(n) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!(value >= n)) return pushError(state, `Expected to be at least ${n} (got ${value})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isAtLeast, "isAtLeast");
+    function isAtMost(n) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!(value <= n)) return pushError(state, `Expected to be at most ${n} (got ${value})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isAtMost, "isAtMost");
+    function isInInclusiveRange(a, b) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!(value >= a && value <= b)) return pushError(state, `Expected to be in the [${a}; ${b}] range (got ${value})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isInInclusiveRange, "isInInclusiveRange");
+    function isInExclusiveRange(a, b) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!(value >= a && value < b)) return pushError(state, `Expected to be in the [${a}; ${b}[ range (got ${value})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isInExclusiveRange, "isInExclusiveRange");
+    function isInteger({ unsafe = false } = {}) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (value !== Math.round(value)) return pushError(state, `Expected to be an integer (got ${value})`);
+          if (!unsafe && !Number.isSafeInteger(value)) return pushError(state, `Expected to be a safe integer (got ${value})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isInteger, "isInteger");
+    function matchesRegExp(regExp) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!regExp.test(value)) return pushError(state, `Expected to match the pattern ${regExp.toString()} (got ${getPrintable(value)})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(matchesRegExp, "matchesRegExp");
+    function isLowerCase() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (value !== value.toLowerCase()) return pushError(state, `Expected to be all-lowercase (got ${value})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isLowerCase, "isLowerCase");
+    function isUpperCase() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (value !== value.toUpperCase()) return pushError(state, `Expected to be all-uppercase (got ${value})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isUpperCase, "isUpperCase");
+    function isUUID4() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!uuid4RegExp.test(value)) return pushError(state, `Expected to be a valid UUID v4 (got ${getPrintable(value)})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isUUID4, "isUUID4");
+    function isISO8601() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!iso8601RegExp.test(value)) return pushError(state, `Expected to be a valid ISO 8601 date string (got ${getPrintable(value)})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isISO8601, "isISO8601");
+    function isHexColor({ alpha = false }) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          const res = alpha ? colorStringRegExp.test(value) : colorStringAlphaRegExp.test(value);
+          if (!res) return pushError(state, `Expected to be a valid hexadecimal color string (got ${getPrintable(value)})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isHexColor, "isHexColor");
+    function isBase64() {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (!base64RegExp.test(value)) return pushError(state, `Expected to be a valid base 64 string (got ${getPrintable(value)})`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(isBase64, "isBase64");
+    function isJSON(spec = isUnknown()) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          let data;
+          try {
+            data = JSON.parse(value);
+          } catch (_a) {
+            return pushError(state, `Expected to be a valid JSON string (got ${getPrintable(value)})`);
+          }
+          return spec(data, state);
+        }, "test")
+      });
+    }
+    __name(isJSON, "isJSON");
+    function cascade(spec, ...followups) {
+      const resolvedFollowups = Array.isArray(followups[0]) ? followups[0] : followups;
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          var _a, _b;
+          const context = {
+            value
+          };
+          const subCoercion = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? makeCoercionFn(context, `value`) : void 0;
+          const subCoercions = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? [] : void 0;
+          if (!spec(value, Object.assign(Object.assign({}, state), {
+            coercion: subCoercion,
+            coercions: subCoercions
+          }))) return false;
+          const reverts = [];
+          if (typeof subCoercions !== `undefined`) for (const [, coercion] of subCoercions) reverts.push(coercion());
+          try {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (context.value !== value) {
+                if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
+                state.coercions.push([
+                  (_a = state.p) !== null && _a !== void 0 ? _a : `.`,
+                  state.coercion.bind(null, context.value)
+                ]);
+              }
+              (_b = state === null || state === void 0 ? void 0 : state.coercions) === null || _b === void 0 ? void 0 : _b.push(...subCoercions);
+            }
+            return resolvedFollowups.every((spec2) => {
+              return spec2(context.value, state);
+            });
+          } finally {
+            for (const revert of reverts) {
+              revert();
+            }
+          }
+        }, "test")
+      });
+    }
+    __name(cascade, "cascade");
+    function applyCascade(spec, ...followups) {
+      const resolvedFollowups = Array.isArray(followups[0]) ? followups[0] : followups;
+      return cascade(spec, resolvedFollowups);
+    }
+    __name(applyCascade, "applyCascade");
+    function isOptional(spec) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (typeof value === `undefined`) return true;
+          return spec(value, state);
+        }, "test")
+      });
+    }
+    __name(isOptional, "isOptional");
+    function isNullable(spec) {
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          if (value === null) return true;
+          return spec(value, state);
+        }, "test")
+      });
+    }
+    __name(isNullable, "isNullable");
+    var checks = {
+      missing: /* @__PURE__ */ __name((keys, key) => keys.has(key), "missing"),
+      undefined: /* @__PURE__ */ __name((keys, key, value) => keys.has(key) && typeof value[key] !== `undefined`, "undefined"),
+      nil: /* @__PURE__ */ __name((keys, key, value) => keys.has(key) && value[key] != null, "nil"),
+      falsy: /* @__PURE__ */ __name((keys, key, value) => keys.has(key) && !!value[key], "falsy")
+    };
+    function hasRequiredKeys(requiredKeys, options) {
+      var _a;
+      const requiredSet = new Set(requiredKeys);
+      const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          const keys = new Set(Object.keys(value));
+          const problems = [];
+          for (const key of requiredSet) if (!check(keys, key, value)) problems.push(key);
+          if (problems.length > 0) return pushError(state, `Missing required ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, `and`)}`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(hasRequiredKeys, "hasRequiredKeys");
+    function hasAtLeastOneKey(requiredKeys, options) {
+      var _a;
+      const requiredSet = new Set(requiredKeys);
+      const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          const keys = Object.keys(value);
+          const valid = keys.some((key) => check(requiredSet, key, value));
+          if (!valid) return pushError(state, `Missing at least one property from ${getPrintableArray(Array.from(requiredSet), `or`)}`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(hasAtLeastOneKey, "hasAtLeastOneKey");
+    function hasForbiddenKeys(forbiddenKeys, options) {
+      var _a;
+      const forbiddenSet = new Set(forbiddenKeys);
+      const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          const keys = new Set(Object.keys(value));
+          const problems = [];
+          for (const key of forbiddenSet) if (check(keys, key, value)) problems.push(key);
+          if (problems.length > 0) return pushError(state, `Forbidden ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, `and`)}`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(hasForbiddenKeys, "hasForbiddenKeys");
+    function hasMutuallyExclusiveKeys(exclusiveKeys, options) {
+      var _a;
+      const exclusiveSet = new Set(exclusiveKeys);
+      const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          const keys = new Set(Object.keys(value));
+          const used = [];
+          for (const key of exclusiveSet) if (check(keys, key, value)) used.push(key);
+          if (used.length > 1) return pushError(state, `Mutually exclusive properties ${getPrintableArray(used, `and`)}`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(hasMutuallyExclusiveKeys, "hasMutuallyExclusiveKeys");
+    (function(KeyRelationship) {
+      KeyRelationship["Forbids"] = "Forbids";
+      KeyRelationship["Requires"] = "Requires";
+    })(exports2.KeyRelationship || (exports2.KeyRelationship = {}));
+    var keyRelationships = {
+      [exports2.KeyRelationship.Forbids]: {
+        expect: false,
+        message: `forbids using`
+      },
+      [exports2.KeyRelationship.Requires]: {
+        expect: true,
+        message: `requires using`
+      }
+    };
+    function hasKeyRelationship(subject, relationship, others, options) {
+      var _a, _b;
+      const skipped = new Set((_a = options === null || options === void 0 ? void 0 : options.ignore) !== null && _a !== void 0 ? _a : []);
+      const check = checks[(_b = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _b !== void 0 ? _b : "missing"];
+      const otherSet = new Set(others);
+      const spec = keyRelationships[relationship];
+      const conjunction = relationship === exports2.KeyRelationship.Forbids ? `or` : `and`;
+      return makeValidator({
+        test: /* @__PURE__ */ __name((value, state) => {
+          const keys = new Set(Object.keys(value));
+          if (!check(keys, subject, value) || skipped.has(value[subject])) return true;
+          const problems = [];
+          for (const key of otherSet) if ((check(keys, key, value) && !skipped.has(value[key])) !== spec.expect) problems.push(key);
+          if (problems.length >= 1) return pushError(state, `Property "${subject}" ${spec.message} ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, conjunction)}`);
+          return true;
+        }, "test")
+      });
+    }
+    __name(hasKeyRelationship, "hasKeyRelationship");
+    exports2.TypeAssertionError = TypeAssertionError;
+    exports2.applyCascade = applyCascade;
+    exports2.as = as;
+    exports2.assert = assert;
+    exports2.assertWithErrors = assertWithErrors;
+    exports2.cascade = cascade;
+    exports2.fn = fn;
+    exports2.hasAtLeastOneKey = hasAtLeastOneKey;
+    exports2.hasExactLength = hasExactLength;
+    exports2.hasForbiddenKeys = hasForbiddenKeys;
+    exports2.hasKeyRelationship = hasKeyRelationship;
+    exports2.hasMaxLength = hasMaxLength;
+    exports2.hasMinLength = hasMinLength;
+    exports2.hasMutuallyExclusiveKeys = hasMutuallyExclusiveKeys;
+    exports2.hasRequiredKeys = hasRequiredKeys;
+    exports2.hasUniqueItems = hasUniqueItems;
+    exports2.isArray = isArray;
+    exports2.isAtLeast = isAtLeast;
+    exports2.isAtMost = isAtMost;
+    exports2.isBase64 = isBase64;
+    exports2.isBoolean = isBoolean;
+    exports2.isDate = isDate;
+    exports2.isDict = isDict;
+    exports2.isEnum = isEnum;
+    exports2.isHexColor = isHexColor;
+    exports2.isISO8601 = isISO8601;
+    exports2.isInExclusiveRange = isInExclusiveRange;
+    exports2.isInInclusiveRange = isInInclusiveRange;
+    exports2.isInstanceOf = isInstanceOf;
+    exports2.isInteger = isInteger;
+    exports2.isJSON = isJSON;
+    exports2.isLiteral = isLiteral;
+    exports2.isLowerCase = isLowerCase;
+    exports2.isMap = isMap;
+    exports2.isNegative = isNegative;
+    exports2.isNullable = isNullable;
+    exports2.isNumber = isNumber2;
+    exports2.isObject = isObject;
+    exports2.isOneOf = isOneOf;
+    exports2.isOptional = isOptional;
+    exports2.isPartial = isPartial;
+    exports2.isPayload = isPayload;
+    exports2.isPositive = isPositive;
+    exports2.isRecord = isRecord;
+    exports2.isSet = isSet;
+    exports2.isString = isString;
+    exports2.isTuple = isTuple;
+    exports2.isUUID4 = isUUID4;
+    exports2.isUnknown = isUnknown;
+    exports2.isUpperCase = isUpperCase;
+    exports2.makeTrait = makeTrait;
+    exports2.makeValidator = makeValidator;
+    exports2.matchesRegExp = matchesRegExp;
+    exports2.softAssert = softAssert;
+  }
+});
+
+// src/app/console/migrate/MigrateRollbackCommand.ts
+var import_clipanion4, import_neko_context4, import_path4, import_promises2, import_neko_config4, t, MigrateRollbackCommand;
+var init_MigrateRollbackCommand = __esm({
+  "src/app/console/migrate/MigrateRollbackCommand.ts"() {
+    "use strict";
+    init_facades();
+    import_clipanion4 = require("clipanion");
+    import_neko_context4 = require("@devbro/neko-context");
+    import_path4 = __toESM(require("path"));
+    import_promises2 = __toESM(require("fs/promises"));
+    import_neko_config4 = require("@devbro/neko-config");
+    t = __toESM(require_lib());
+    MigrateRollbackCommand = class extends import_clipanion4.Command {
+      static {
+        __name(this, "MigrateRollbackCommand");
+      }
+      static paths = [
+        [
+          `migrate`,
+          "rollback"
+        ]
+      ];
+      steps = import_clipanion4.Option.String(`--steps`, {
+        description: `how many migrations to rollback`,
+        validator: t.isNumber()
+      });
+      async execute() {
+        await import_neko_context4.context_provider.run(async () => {
+          const db2 = db();
+          const schema = db2.getSchema();
+          const migrationsDir = import_neko_config4.config.get("migration.path");
+          let files = [];
+          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: []
+          });
+          const count = 0;
+          for (const migration of migrations) {
+            const class_to_migrate = migration.filename;
+            this.context.stdout.write(`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());
+            await db2.runQuery({
+              sql: "delete from migrations where id = $1",
+              bindings: [
+                migration.id
+              ]
+            });
+          }
+        });
+      }
+    };
+    cli().register(MigrateRollbackCommand);
+  }
+});
+
+// src/app/console/migrate/index.ts
+var init_migrate = __esm({
+  "src/app/console/migrate/index.ts"() {
+    "use strict";
+    init_MigrateCommand();
+    init_GenerateMigrateCommand();
+    init_MigrateRollbackCommand();
+  }
+});
+
+// src/app/console/StartCommand.ts
+var import_clipanion5, import_neko_config5, import_neko_sql, StartCommand;
+var init_StartCommand = __esm({
+  "src/app/console/StartCommand.ts"() {
+    "use strict";
+    import_clipanion5 = require("clipanion");
+    import_neko_config5 = require("@devbro/neko-config");
+    init_facades();
+    import_neko_sql = require("@devbro/neko-sql");
+    StartCommand = class extends import_clipanion5.Command {
+      static {
+        __name(this, "StartCommand");
+      }
+      scheduler = import_clipanion5.Option.Boolean(`--scheduler`, false);
+      http = import_clipanion5.Option.Boolean(`--http`, false);
+      all = import_clipanion5.Option.Boolean("--all", false);
+      static paths = [
+        [
+          `start`
+        ]
+      ];
+      async execute() {
+        if ([
+          this.all,
+          this.http,
+          this.scheduler
+        ].filter((x) => x).length == 0) {
+          this.context.stdout.write(`No service was selected. please check -h for details
+`);
+          return;
+        }
+        logger().info(`Starting Server
+`);
+        import_neko_sql.PostgresqlConnection.defaults.idleTimeoutMillis = 1e4;
+        if (this.scheduler || this.all) {
+          logger().info(`starting scheduler
+`);
+          scheduler().start();
+        }
+        if (this.http || this.all) {
+          const server = httpServer();
+          await server.listen(import_neko_config5.config.get("port"), () => {
+            logger().info("Server is running on http://localhost:" + import_neko_config5.config.get("port"));
+          });
+        }
+      }
+    };
+    cli().register(StartCommand);
+  }
+});
+
+// src/app/console/DefaultCommand.ts
+var import_clipanion6, DefaultCommand;
+var init_DefaultCommand = __esm({
+  "src/app/console/DefaultCommand.ts"() {
+    "use strict";
+    import_clipanion6 = require("clipanion");
+    init_facades();
+    DefaultCommand = class extends import_clipanion6.Command {
+      static {
+        __name(this, "DefaultCommand");
+      }
+      static usage = import_clipanion6.Command.Usage({
+        category: `Main`,
+        description: `server management command line.`,
+        details: `
+      The base command for running and managing your server.
+
+      Make sure you understand how things work.
+    `,
+        examples: []
+      });
+      async execute() {
+        const commandList = cli().registrations;
+        const paths = [];
+        commandList.forEach((index, val) => paths.push(index.builder.paths[0]?.join(" ") || ""));
+        console.log("Available commands:");
+        for (const cmd of paths) {
+          if (cmd) {
+            console.log(cmd);
+          }
+        }
+      }
+    };
+    cli().register(DefaultCommand);
+  }
+});
+
+// src/app/console/KeyGenerateCommand.ts
+var import_clipanion7, import_crypto, import_promises3, import_path5, KeyGenerateCommand;
+var init_KeyGenerateCommand = __esm({
+  "src/app/console/KeyGenerateCommand.ts"() {
+    "use strict";
+    import_clipanion7 = require("clipanion");
+    import_crypto = require("crypto");
+    import_promises3 = __toESM(require("fs/promises"));
+    import_path5 = __toESM(require("path"));
+    init_facades();
+    KeyGenerateCommand = class extends import_clipanion7.Command {
+      static {
+        __name(this, "KeyGenerateCommand");
+      }
+      static paths = [
+        [
+          `generate`,
+          "key"
+        ]
+      ];
+      static usage = import_clipanion7.Command.Usage({
+        category: `Main`,
+        description: `generate keys`,
+        details: `
+      This command generates RSA key pair for JWT signing.
+      Use --rotate flag to preserve old public key.
+    `,
+        examples: [
+          [
+            `Generate new keys`,
+            `generate key`
+          ],
+          [
+            `Rotate existing keys`,
+            `generate key --rotate`
+          ]
+        ]
+      });
+      rotate = import_clipanion7.Option.Boolean(`--rotate`, false, {
+        description: `Rotate existing keys (backup old keys before replacement)`
+      });
+      async execute() {
+        logger().info("generating keys for jwt token and adding to .env file");
+        const { publicKey, privateKey } = (0, import_crypto.generateKeyPairSync)("rsa", {
+          modulusLength: 2048,
+          publicKeyEncoding: {
+            type: "spki",
+            format: "pem"
+          },
+          privateKeyEncoding: {
+            type: "pkcs8",
+            format: "pem"
+          }
+        });
+        let envfile = "";
+        try {
+          envfile = await import_promises3.default.readFile(import_path5.default.join(process.cwd(), ".env"), "utf-8");
+        } catch {
+        }
+        let old_public_key = envfile.match(/^jwt_secret_public=(.*)/m);
+        envfile = this.addEnvParam(envfile, "jwt_secret_public", this.stripPemHeaders(publicKey));
+        envfile = this.addEnvParam(envfile, "jwt_secret_private", this.stripPemHeaders(privateKey));
+        if (this.rotate && old_public_key && old_public_key[1]) {
+          envfile = this.addEnvParam(envfile, "jwt_secret_public_retired", old_public_key[1]);
+        }
+        await import_promises3.default.writeFile(import_path5.default.join(process.cwd(), ".env"), envfile, "utf-8");
+      }
+      addEnvParam(file, key, value) {
+        let regex = new RegExp(`^${key}=.*`, "gm");
+        file = file.replace(regex, `${key}=${value}`);
+        const match = file.match(regex);
+        if (!match) {
+          file = file + `
+${key}=${value}`;
+        }
+        return file;
+      }
+      stripPemHeaders(pem) {
+        return pem.replace(/-----BEGIN [\w\s]+-----/g, "").replace(/-----END [\w\s]+-----/g, "").replace(/\r?\n|\r/g, "");
+      }
+    };
+    cli().register(KeyGenerateCommand);
+  }
+});
+
+// src/app/console/generate/GenerateControllerCommand.ts
+var import_clipanion8, import_change_case_all2, import_path6, fs5, import_neko_config6, import_handlebars2, import_url2, import_pluralize, import_meta2, GenerateControllerCommand;
+var init_GenerateControllerCommand = __esm({
+  "src/app/console/generate/GenerateControllerCommand.ts"() {
+    "use strict";
+    init_facades();
+    import_clipanion8 = require("clipanion");
+    import_change_case_all2 = require("change-case-all");
+    import_path6 = __toESM(require("path"));
+    fs5 = __toESM(require("fs/promises"));
+    import_neko_config6 = require("@devbro/neko-config");
+    import_handlebars2 = __toESM(require("handlebars"));
+    import_url2 = require("url");
+    import_pluralize = __toESM(require("pluralize"));
+    import_meta2 = {};
+    GenerateControllerCommand = class extends import_clipanion8.Command {
+      static {
+        __name(this, "GenerateControllerCommand");
+      }
+      static paths = [
+        [
+          `make`,
+          `controller`
+        ],
+        [
+          `generate`,
+          `controller`
+        ]
+      ];
+      name = import_clipanion8.Option.String({
+        required: true
+      });
+      async execute() {
+        const rootDir = process.cwd();
+        const date = /* @__PURE__ */ new Date();
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        const secondsOfDay = String(date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds()).padStart(5, "0");
+        const fixed_name = import_change_case_all2.Case.snake(this.name);
+        const filename = `${import_change_case_all2.Case.capital(this.name)}Controller.ts`;
+        this.context.stdout.write(`creating migration file ${filename}
+`);
+        await fs5.mkdir(import_neko_config6.config.get("migration.path"), {
+          recursive: true
+        });
+        let dirname = typeof __dirname === "string" ? __dirname : void 0;
+        if (!dirname) {
+          dirname = import_path6.default.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
+        }
+        const compiledTemplate = import_handlebars2.default.compile((await fs5.readFile(import_path6.default.join(dirname, "./controller.tpl"))).toString());
+        const template = await compiledTemplate({
+          className: import_change_case_all2.Case.pascal(this.name),
+          classNameLower: import_change_case_all2.Case.snake(this.name),
+          routeName: import_change_case_all2.Case.kebab((0, import_pluralize.default)(this.name))
+        });
+        await fs5.writeFile(import_path6.default.join(rootDir, "src/app/controllers", filename), template);
+      }
+    };
+    cli().register(GenerateControllerCommand);
+  }
+});
+
+// src/app/console/generate/index.ts
+var init_generate = __esm({
+  "src/app/console/generate/index.ts"() {
+    "use strict";
+    init_GenerateControllerCommand();
+  }
+});
+
+// src/app/console/project/CreateProjectCommand.ts
+var import_clipanion9, import_change_case_all3, import_path7, fs6, import_url3, import_handlebars3, import_child_process, import_meta3, CreateProjectCommand;
+var init_CreateProjectCommand = __esm({
+  "src/app/console/project/CreateProjectCommand.ts"() {
+    "use strict";
+    import_clipanion9 = require("clipanion");
+    import_change_case_all3 = require("change-case-all");
+    import_path7 = __toESM(require("path"));
+    fs6 = __toESM(require("fs/promises"));
+    import_url3 = require("url");
+    import_handlebars3 = __toESM(require("handlebars"));
+    import_child_process = require("child_process");
+    import_meta3 = {};
+    CreateProjectCommand = class extends import_clipanion9.Command {
+      static {
+        __name(this, "CreateProjectCommand");
+      }
+      static paths = [
+        [
+          `create`,
+          `project`
+        ]
+      ];
+      static usage = import_clipanion9.Command.Usage({
+        category: `Project`,
+        description: `Create a new project`,
+        details: `
+      This command creates a new project with the specified name at the given path.
+      If no path is provided, the project will be created in the current directory.
+    `,
+        examples: [
+          [
+            `Create a new project in specified directory`,
+            `create project --path /path/to/my-project --git`
+          ],
+          [
+            `Create a new project at a specific path with git initialized`,
+            `create project --path /path/to/my-project --git`
+          ]
+        ]
+      });
+      projectPath = import_clipanion9.Option.String("--path", {
+        required: true
+      });
+      git = import_clipanion9.Option.Boolean(`--git`, false, {
+        description: `Initialize a git repository in the new project`
+      });
+      async folderExists(folderPath) {
+        try {
+          const stats = await fs6.stat(folderPath);
+          return stats.isDirectory();
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return false;
+          }
+          throw error;
+        }
+      }
+      async execute() {
+        const projectPath = import_path7.default.join(this.projectPath);
+        try {
+          await fs6.access(projectPath);
+          console.error(`Error: Directory ${projectPath} already exists.`);
+          return 1;
+        } catch {
+        }
+        await fs6.mkdir(projectPath, {
+          recursive: true
+        });
+        console.log(`Created project directory at: ${projectPath}`);
+        const dirname = typeof __dirname === "undefined" ? import_path7.default.dirname((0, import_url3.fileURLToPath)(import_meta3.url)) : __dirname;
+        let basePath = import_path7.default.join(dirname, `./base_project`);
+        if (await this.folderExists(basePath) === false) {
+          basePath = import_path7.default.join(dirname, `../app/console/project/base_project`);
+        }
+        console.log(`Using base project path: ${basePath}`);
+        const baseProjectPath = basePath;
+        await this.processTplFolder(baseProjectPath, projectPath, {});
+        console.log(`Copied base project files to: ${projectPath}`);
+        const packageJsonPath = import_path7.default.join(projectPath, `package.json`);
+        const packageJson = JSON.parse(await fs6.readFile(packageJsonPath, `utf-8`));
+        packageJson.name = import_change_case_all3.Case.snake(import_path7.default.basename(projectPath));
+        await fs6.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        console.log(`Updated package.json with project name: ${packageJson.name}`);
+        if (this.git) {
+          try {
+            (0, import_child_process.execSync)('git init; git add --all; git commit --allow-empty -m "chore: first commit for pashmak"', {
+              cwd: projectPath
+            });
+          } catch (error) {
+            console.error(`Failed to create project.`, error);
+            return 1;
+          }
+        }
+      }
+      async processTplFolder(src, dest, data = {}) {
+        const files = await fs6.readdir(src, {
+          withFileTypes: true
+        });
+        for (const file of files) {
+          const srcPath = import_path7.default.join(src, file.name);
+          const destPath = file.isFile() && file.name.endsWith(".tpl") ? import_path7.default.join(dest, file.name.substring(0, file.name.length - 4)) : import_path7.default.join(dest, file.name);
+          if (file.isDirectory()) {
+            await fs6.mkdir(destPath, {
+              recursive: true
+            });
+            await this.processTplFolder(srcPath, destPath, data);
+          } else if (file.name.endsWith(".tpl")) {
+            await this.processTplFile(srcPath, destPath, {});
+          } else {
+            throw new Error("unexpected non tpl file: " + srcPath + " " + file.name);
+          }
+        }
+      }
+      async processTplFile(src, dest, data = {}) {
+        const compiledTemplate = import_handlebars3.default.compile((await fs6.readFile(src)).toString());
+        const template = await compiledTemplate(data);
+        await fs6.writeFile(dest, template);
+      }
+    };
+  }
+});
+
+// src/app/console/index.ts
+var console_exports = {};
+__export(console_exports, {
+  CreateProjectCommand: () => CreateProjectCommand,
+  DefaultCommand: () => DefaultCommand,
+  GenerateControllerCommand: () => GenerateControllerCommand,
+  GenerateMigrateCommand: () => GenerateMigrateCommand,
+  KeyGenerateCommand: () => KeyGenerateCommand,
+  MigrateCommand: () => MigrateCommand,
+  MigrateRollbackCommand: () => MigrateRollbackCommand,
+  StartCommand: () => StartCommand
+});
+var init_console = __esm({
+  "src/app/console/index.ts"() {
+    "use strict";
+    init_migrate();
+    init_StartCommand();
+    init_DefaultCommand();
+    init_KeyGenerateCommand();
+    init_generate();
+    init_CreateProjectCommand();
+    init_facades();
+    init_CreateProjectCommand();
+    cli().register(CreateProjectCommand);
+  }
+});
+
+// src/DatabaseServiceProvider.mts
+var DatabaseServiceProvider_exports = {};
+__export(DatabaseServiceProvider_exports, {
+  DatabaseServiceProvider: () => DatabaseServiceProvider
+});
+var import_neko_sql2, 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_orm = require("@devbro/neko-orm");
+    import_neko_context5 = require("@devbro/neko-context");
+    import_neko_config7 = require("@devbro/neko-config");
+    DatabaseServiceProvider = class _DatabaseServiceProvider extends Middleware {
+      static {
+        __name(this, "DatabaseServiceProvider");
+      }
+      async call(req, res, next) {
+        const db_configs = import_neko_config7.config.get("databases");
+        const conns = [];
+        try {
+          for (const [name, db_config] of Object.entries(db_configs)) {
+            const conn = await this.getConnection(db_config);
+            (0, import_neko_context5.ctx)().set(["database", name], conn);
+            conns.push(conn);
+          }
+          import_neko_orm.BaseModel.setConnection(
+            () => (0, import_neko_context5.ctx)().getOrThrow(["database", "default"])
+          );
+          await next();
+        } finally {
+          for (const conn of conns) {
+            await conn.disconnect();
+          }
+        }
+      }
+      static instance;
+      async register() {
+      }
+      static getInstance() {
+        if (!_DatabaseServiceProvider.instance) {
+          _DatabaseServiceProvider.instance = new _DatabaseServiceProvider();
+        }
+        return _DatabaseServiceProvider.instance;
+      }
+      async getConnection(db_config) {
+        const conn = new import_neko_sql2.PostgresqlConnection(db_config);
+        if (!await conn.connect()) {
+          throw new Error("Failed to connect to the database");
+        }
+        return conn;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  bootstrap: () => bootstrap,
+  config: () => import_neko_config8.config
+});
+module.exports = __toCommonJS(index_exports);
+var import_dotenv = __toESM(require("dotenv"));
+var import_neko_context6 = require("@devbro/neko-context");
+init_dist();
+var import_neko_config8 = require("@devbro/neko-config");
+async function bootstrap(options) {
+  import_dotenv.default.config();
+  console.log("Bootstrapping application...");
+  console.log(`Root directory: ${options.root_dir}`);
+  let a = (await import(`${options.root_dir}/config/default`)).default;
+  import_neko_config8.config.load(a);
+  console.log("Loading application modules...");
+  await Promise.resolve().then(() => (init_console(), console_exports));
+  console.log("Loading Database Provider ...");
+  const { DatabaseServiceProvider: DatabaseServiceProvider2 } = await Promise.resolve().then(() => (init_DatabaseServiceProvider(), DatabaseServiceProvider_exports));
+  console.log("Setting up pre-loader for context provider...");
+  import_neko_context6.context_provider.setPreLoader(async (f) => {
+    const middlewares = [];
+    middlewares.push(DatabaseServiceProvider2.getInstance());
+    return await runNext(
+      middlewares,
+      {},
+      {},
+      // @ts-ignore
+      f
+    );
+  });
+  console.log("Application bootstrapped successfully.");
+}
+__name(bootstrap, "bootstrap");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bootstrap,
+  config
+});