@devbro/pashmak 0.1.7 → 0.1.9

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

@@ -0,0 +1,1829 @@
+"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 __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);
+
+// ../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/index.ts
+var migrate_exports = {};
+__export(migrate_exports, {
+  GenerateMigrateCommand: () => GenerateMigrateCommand,
+  MigrateCommand: () => MigrateCommand,
+  MigrateRollbackCommand: () => MigrateRollbackCommand
+});
+module.exports = __toCommonJS(migrate_exports);
+
+// src/router.mts
+var import_neko_context = require("@devbro/neko-context");
+var import_errors = require("@devbro/neko-http/errors");
+
+// ../neko-router/dist/Middleware.mjs
+var Middleware = class {
+  static {
+    __name(this, "Middleware");
+  }
+  constructor(params = {}) {
+  }
+  static getInstance(params) {
+    throw new Error("Method not implemented. Please implement a static getInstance method.");
+  }
+};
+
+// ../neko-router/dist/MiddlewareFactory.mjs
+var MiddlewareFactory = class {
+  static {
+    __name(this, "MiddlewareFactory");
+  }
+  static create(func) {
+    const cls = class extends Middleware {
+      static {
+        __name(this, "cls");
+      }
+      call(req, res, next) {
+        return func(req, res, next);
+      }
+      constructor(params = {}) {
+        super(params);
+      }
+    };
+    return new cls();
+  }
+};
+
+// ../neko-router/dist/CompiledRoute.mjs
+var CompiledRoute = class {
+  static {
+    __name(this, "CompiledRoute");
+  }
+  constructor(route, request, response, globalMiddlewares = []) {
+    this.route = route;
+    this.request = request;
+    this.response = response;
+    this.globalMiddlewares = globalMiddlewares;
+    this.prepareMiddlewares();
+  }
+  middlewares = [];
+  getMiddlewares() {
+    return this.middlewares;
+  }
+  prepareMiddlewares() {
+    this.middlewares = [];
+    for (const middleware of [...this.globalMiddlewares, ...this.route.getMiddlewares()]) {
+      if (middleware instanceof Middleware) {
+        this.middlewares.push(middleware);
+      } else if (this.isClass(middleware)) {
+        this.middlewares.push(middleware.getInstance({}));
+      } else if (typeof middleware === "function") {
+        this.middlewares.push(MiddlewareFactory.create(middleware));
+      } else {
+        throw new Error("Invalid middleware type");
+      }
+    }
+  }
+  isClass(func) {
+    return typeof func === "function" && /^class\s/.test(Function.prototype.toString.call(func));
+  }
+  async run() {
+    return await this.runMiddlewares(this.middlewares, this.request, this.response);
+  }
+  prepareOutputJsonFormat(obj) {
+    function traverse(value) {
+      if (!value || 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/Route.mjs
+var Route = class {
+  static {
+    __name(this, "Route");
+  }
+  constructor(methods, path5, handler) {
+    this.methods = methods;
+    this.path = path5;
+    this.handler = handler;
+    this.urlRegex = this.pathToRegex(path5);
+  }
+  middlewares = [];
+  urlRegex;
+  pathToRegex(path5) {
+    const lex = this.lexUrlPath(path5);
+    return this.tokensToRegex(lex);
+  }
+  lexUrlPath(path5) {
+    const tokens = [];
+    let i = 0;
+    while (i < path5.length) {
+      const char = path5[i];
+      if (char === "/") {
+        tokens.push({ type: "SLASH", value: "/" });
+        i++;
+      } else if (char === ":") {
+        let start = i + 1;
+        while (start < path5.length && /[a-zA-Z0-9_]/.test(path5[start])) {
+          start++;
+        }
+        tokens.push({ type: "PARAM", value: path5.slice(i + 1, start) });
+        i = start;
+      } else if (char === "*") {
+        let start = i + 1;
+        while (start < path5.length && /[a-zA-Z0-9_]/.test(path5[start])) {
+          start++;
+        }
+        tokens.push({ type: "WILDCARD", value: path5.slice(i + 1, start) });
+        i = start;
+      } else {
+        let start = i;
+        while (start < path5.length && !["/", ":", "*"].includes(path5[start])) {
+          start++;
+        }
+        tokens.push({ type: "TEXT", value: path5.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 = __toESM(require("path"), 1);
+var Router = class {
+  static {
+    __name(this, "Router");
+  }
+  middlewares = [];
+  routes = [];
+  addRoute(methods, path22, handler) {
+    const route = new Route(methods, path22, handler);
+    this.routes.push(route);
+    return route;
+  }
+  getMiddlewares() {
+    return [...this.middlewares];
+  }
+  addController(controller) {
+    const basePath = controller.basePath || "";
+    for (const route of controller.routes) {
+      const urlPath = import_path.default.join(basePath, route.path);
+      this.addRoute(route.methods, urlPath, async (req, res) => {
+        const controllerInstance = controller.getInstance();
+        return await controllerInstance[route.handler]();
+      }).addMiddleware([...controller.baseMiddlewares, ...route.middlewares]);
+    }
+  }
+  addGlobalMiddleware(middlewares) {
+    this.middlewares = this.middlewares.concat(middlewares);
+  }
+  resolve(request) {
+    for (const route of this.routes) {
+      if (route.test(request)) {
+        return route;
+      }
+    }
+    return void 0;
+  }
+  resolveMultiple(request) {
+    const rc = [];
+    const url = new URL(request.url || "/", "http://localhost");
+    for (const route of this.routes) {
+      if (route.testPath(url.pathname)) {
+        rc.push(route);
+      }
+    }
+    return rc;
+  }
+  getCompiledRoute(request, response) {
+    const route = this.resolve(request);
+    if (!route) {
+      return void 0;
+    }
+    const match = route.match(request);
+    if (!match) {
+      return void 0;
+    }
+    request.params = match.params;
+    return new CompiledRoute(route, request, response, this.middlewares);
+  }
+};
+
+// src/facades.mts
+var import_neko_scheduler = require("@devbro/neko-scheduler");
+var import_neko_helper = require("@devbro/neko-helper");
+var import_neko_context2 = require("@devbro/neko-context");
+var import_neko_storage = require("@devbro/neko-storage");
+var import_neko_mailer = require("@devbro/neko-mailer");
+var import_neko_config = require("@devbro/neko-config");
+var import_clipanion = require("clipanion");
+
+// src/http.mts
+var http_exports = {};
+__reExport(http_exports, require("@devbro/neko-http"));
+
+// src/facades.mts
+var yup = __toESM(require("yup"), 1);
+var import_neko_logger = require("@devbro/neko-logger");
+var router = (0, import_neko_helper.createSingleton)(() => new Router());
+var 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;
+});
+var db = /* @__PURE__ */ __name((label = "default") => (0, import_neko_context2.ctx)().getOrThrow(["database", label]), "db");
+var storage = (0, import_neko_helper.createSingleton)(
+  (label = "default") => import_neko_storage.StorageFactory.create(import_neko_config.config.get(["storages", label].join(".")))
+);
+var 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`
+  });
+});
+var 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;
+});
+var 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;
+});
+var mailer = (0, import_neko_helper.createSingleton)((label) => {
+  const mailer_config = import_neko_config.config.get(["mailer", label].join("."));
+  let provider;
+  if (mailer_config.provider === "logger") {
+    provider = new import_neko_mailer.FunctionProvider((mail) => {
+      logger().info({
+        msg: "Sending email",
+        mail
+      });
+    });
+  } else if (mailer_config.provider === "SES") {
+    provider = new import_neko_mailer.SESProvider(mailer_config.config);
+  } else if (mailer_config.provider === "SMTP") {
+    provider = new import_neko_mailer.SMTPProvider(mailer_config.config);
+  } else if (mailer_config.provider === "MEMORY") {
+    provider = new import_neko_mailer.MemoryProvider();
+  }
+  if (!provider) {
+    throw new Error(
+      `cannot initiate mailer provider: ${mailer_config?.provider}`
+    );
+  }
+  const rc = new import_neko_mailer.Mailer(provider);
+  return rc;
+});
+
+// src/app/console/migrate/MigrateCommand.ts
+var import_clipanion2 = require("clipanion");
+var import_neko_context3 = require("@devbro/neko-context");
+var import_path2 = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+var import_neko_config2 = require("@devbro/neko-config");
+var 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 = require("clipanion");
+var import_change_case_all = require("change-case-all");
+var import_path3 = __toESM(require("path"));
+var fs2 = __toESM(require("fs/promises"));
+var import_neko_config3 = require("@devbro/neko-config");
+var import_handlebars = __toESM(require("handlebars"));
+var import_url = require("url");
+var import_meta = {};
+var 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);
+
+// src/app/console/migrate/MigrateRollbackCommand.ts
+var import_clipanion4 = require("clipanion");
+var import_neko_context4 = require("@devbro/neko-context");
+var import_path4 = __toESM(require("path"));
+var import_promises2 = __toESM(require("fs/promises"));
+var import_neko_config4 = require("@devbro/neko-config");
+var t = __toESM(require_lib());
+var 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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenerateMigrateCommand,
+  MigrateCommand,
+  MigrateRollbackCommand
+});