equipped 5.0.6 → 5.0.8

package/dist/cjs/chunk-UBQPLHM4.cjs

@@ -0,0 +1,2507 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10;var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/validations/index.ts
+var _valleyed = require('valleyed'); _createStarExport(_valleyed);
+
+// src/validations/valleyed.ts
+var valleyed_exports = {};
+__export(valleyed_exports, {
+  incomingFile: () => incomingFile,
+  incomingFiles: () => incomingFiles,
+  requestLocalStorage: () => requestLocalStorage,
+  responseLocalStorage: () => responseLocalStorage,
+  withRequest: () => withRequest,
+  withResponse: () => withResponse
+});
+var _async_hooks = require('async_hooks');
+
+
+// src/instance/index.ts
+
+
+// src/instance/hooks.ts
+async function runHooks(hooks, onError = (error) => {
+  throw error;
+}) {
+  const grouped = hooks.reduce((acc, cur) => {
+    const key = cur.order.toString();
+    if (!acc[key]) acc[key] = [];
+    acc[key].push(cur);
+    return acc;
+  }, {});
+  const groups = Object.keys(grouped).sort((a, b) => parseInt(a) - parseInt(b)).map((key) => grouped[key]);
+  for (const group of groups)
+    await Promise.all(
+      group.map(async (h) => {
+        try {
+          if (typeof h.cb === "function") return await h.cb();
+          return await h.cb;
+        } catch (error) {
+          return onError(error instanceof Error ? error : new Error(`${error}`));
+        }
+      })
+    );
+}
+
+// src/instance/settings.ts
+var _pino = require('pino'); var _pino2 = _interopRequireDefault(_pino);
+
+
+// src/cache/base.ts
+var Cache = class {
+};
+
+// src/cache/pipes.ts
+
+var redisConfigPipe = _valleyed.v.meta(
+  _valleyed.v.object({
+    host: _valleyed.v.string(),
+    port: _valleyed.v.optional(_valleyed.v.number()),
+    password: _valleyed.v.optional(_valleyed.v.string()),
+    username: _valleyed.v.optional(_valleyed.v.string()),
+    tls: _valleyed.v.optional(_valleyed.v.boolean()),
+    cluster: _valleyed.v.optional(_valleyed.v.boolean())
+  }),
+  { title: "Redis Config", $refId: "RedisConfig" }
+);
+
+// src/cache/types/redis.ts
+var _ioredis = require('ioredis');
+
+// src/errors/equippedError.ts
+var EquippedError = class extends Error {
+  constructor(message, context, cause) {
+    super(message, { cause });
+    this.message = message;
+    this.context = context;
+    this.cause = cause;
+  }
+};
+
+// src/errors/requestError.ts
+var RequestError = class extends EquippedError {
+  constructor(message, serializedErrors, cause) {
+    super(message, { serializedErrors }, cause);
+    this.message = message;
+    this.serializedErrors = serializedErrors;
+  }
+};
+
+// src/server/impls/base.ts
+var _socketio = require('socket.io'); var _socketio2 = _interopRequireDefault(_socketio);
+var _supertest = require('supertest'); var _supertest2 = _interopRequireDefault(_supertest);
+
+
+// src/server/types.ts
+var Methods = {
+  head: "head",
+  get: "get",
+  post: "post",
+  put: "put",
+  patch: "patch",
+  delete: "delete",
+  options: "options"
+};
+var StatusCodes = {
+  Ok: 200,
+  Found: 302,
+  BadRequest: 400,
+  NotAuthenticated: 401,
+  NotAuthorized: 403,
+  NotFound: 404,
+  ValidationError: 422,
+  TooManyRequests: 429,
+  AuthorizationExpired: 461
+};
+function makeMiddlewareHandler(cb, onSetup) {
+  return { cb, onSetup };
+}
+var makeMiddleware = (...args) => makeMiddlewareHandler(...args);
+var makeErrorMiddleware = (...args) => makeMiddlewareHandler(...args);
+
+// src/server/middlewares/parseAuthUser.ts
+var parseAuthUser = makeMiddleware(async (request) => {
+  const requestsAuth = _optionalChain([Instance, 'access', _2 => _2.get, 'call', _3 => _3(), 'access', _4 => _4.settings, 'access', _5 => _5.server, 'optionalAccess', _6 => _6.requestsAuth]);
+  if (!requestsAuth) return;
+  const { Authorization, ApiKey } = request.headers;
+  function makeErrorHandler(key) {
+    return function(err) {
+      request.users[key].error = err instanceof RequestError ? err : new BadRequestError("failed to parse auth user", err);
+      request.users[key].error.context[key] = key;
+      return void 0;
+    };
+  }
+  if (requestsAuth.tokens && Authorization)
+    request.users.access.value = await requestsAuth.tokens.verifyAccessToken(Authorization).catch(makeErrorHandler("access"));
+  else if (requestsAuth.apiKey && ApiKey)
+    request.users.apiKey.value = await requestsAuth.apiKey.verifyApiKey(ApiKey).catch(makeErrorHandler("apiKey"));
+});
+
+// src/server/openapi.ts
+var _jsonschematoopenapischema = require('@openapi-contrib/json-schema-to-openapi-schema');
+
+
+// src/server/routes.ts
+
+function mergeSchemas(...schemas) {
+  const k = {
+    params: "",
+    headers: "",
+    query: "",
+    body: "",
+    response: "",
+    responseHeaders: "",
+    defaultStatusCode: "",
+    defaultContentType: "",
+    context: ""
+  };
+  function merge(acc, cur) {
+    if (!acc) return cur;
+    if (!cur) return acc;
+    if (typeof acc === "number") return cur;
+    if (typeof acc === "string") return cur;
+    if (typeof acc === "function") return cur;
+    return _valleyed.v.merge(acc, cur);
+  }
+  return Object.fromEntries(
+    Object.keys(k).map((key) => [
+      key,
+      schemas.map((s) => s[key]).reduce(merge, null)
+    ])
+  );
+}
+var groupRoutes = (config, routes) => routes.map((route) => ({
+  ...config,
+  ...route,
+  path: `${config.path}/${route.path}`,
+  groups: [..._nullishCoalesce(config.groups, () => ( [])), ..._nullishCoalesce(route.groups, () => ( []))],
+  middlewares: [..._nullishCoalesce(config.middlewares, () => ( [])), ..._nullishCoalesce(route.middlewares, () => ( []))],
+  schema: mergeSchemas(_nullishCoalesce(config.schema, () => ( {})), _nullishCoalesce(route.schema, () => ( {}))),
+  security: [..._nullishCoalesce(config.security, () => ( [])), ..._nullishCoalesce(route.security, () => ( []))]
+}));
+var Router = (_class = class {
+  #config = { path: "" };
+  #routes = [];
+  #children = [];
+  constructor(config = { path: "" }) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);
+    this.#config = config;
+  }
+  #wrap(method) {
+    return (path, config = {}) => (handler) => {
+      const route = groupRoutes(this.#config, [{ ...config, path, method, handler }])[0];
+      this.#routes.push(route);
+      return route;
+    };
+  }
+  __init() {this.head = this.#wrap(Methods.head)}
+  __init2() {this.get = this.#wrap(Methods.get)}
+  __init3() {this.post = this.#wrap(Methods.post)}
+  __init4() {this.put = this.#wrap(Methods.put)}
+  __init5() {this.patch = this.#wrap(Methods.patch)}
+  __init6() {this.delete = this.#wrap(Methods.delete)}
+  __init7() {this.options = this.#wrap(Methods.options)}
+  nest(...routers) {
+    routers.forEach((router) => this.#children.push(router));
+  }
+  get routes() {
+    return [...this.#routes].concat(this.#children.flatMap((child) => groupRoutes(this.#config, child.routes)));
+  }
+}, _class);
+
+// src/server/openapi.ts
+var OpenApi = class {
+  constructor(config) {
+    this.config = config;
+    this.#baseOpenapiDoc = {
+      openapi: "3.0.0",
+      info: {
+        title: `${config.app.name} ${config.app.id}`,
+        version: _nullishCoalesce(config.config.openapi.docsVersion, () => ( ""))
+      },
+      servers: _optionalChain([config, 'access', _7 => _7.config, 'access', _8 => _8.openapi, 'access', _9 => _9.docsBaseUrl, 'optionalAccess', _10 => _10.map, 'call', _11 => _11((url) => ({ url }))]),
+      paths: {},
+      components: {
+        schemas: {},
+        securitySchemes: {
+          Authorization: {
+            type: "apiKey",
+            name: "authorization",
+            in: "header"
+          },
+          RefreshToken: {
+            type: "apiKey",
+            name: "x-refresh-token",
+            in: "header"
+          },
+          ApiKey: {
+            type: "apiKey",
+            name: "x-api-key",
+            in: "header"
+          }
+        }
+      },
+      tags: [],
+      "x-tagGroups": []
+    };
+  }
+  #registeredTags = {};
+  #registeredTagGroups = {};
+  #baseOpenapiDoc;
+  cleanPath(path) {
+    let cleaned = path.replace(/(\/\s*)+/g, "/");
+    if (!cleaned.startsWith("/")) cleaned = `/${cleaned}`;
+    if (cleaned !== "/" && cleaned.endsWith("/")) cleaned = cleaned.slice(0, -1);
+    return cleaned;
+  }
+  async register(route, def) {
+    if (route.hide) return;
+    const tag = this.#buildTag(_nullishCoalesce(route.groups, () => ( [])));
+    const cleanPath = this.cleanPath(route.path);
+    const operationId = `(${route.method.toUpperCase()}) ${cleanPath}`;
+    await this.#addRouteToOpenApiDoc(cleanPath, route.method.toLowerCase(), def, {
+      operationId,
+      summary: _nullishCoalesce(route.title, () => ( cleanPath)),
+      description: _optionalChain([route, 'access', _12 => _12.descriptions, 'optionalAccess', _13 => _13.join, 'call', _14 => _14("\n\n")]),
+      tags: tag ? [tag] : void 0,
+      security: route.security
+    });
+  }
+  async #addRouteToOpenApiDoc(path, method, def, methodObj) {
+    if (_optionalChain([def, 'access', _15 => _15.response, 'access', _16 => _16.response, 'optionalAccess', _17 => _17.length])) {
+      methodObj.responses ??= {};
+      for (const resp of def.response.response) {
+        methodObj.responses[resp.status] ??= { description: "", content: {} };
+        const res = methodObj.responses[resp.status];
+        res.content[resp.contentType] = { schema: await _jsonschematoopenapischema.convert.call(void 0, this.#visit(resp.schema)) };
+      }
+    }
+    if (_optionalChain([def, 'access', _18 => _18.response, 'access', _19 => _19.responseHeaders, 'optionalAccess', _20 => _20.length])) {
+      methodObj.responses ??= {};
+      for (const resp of def.response.responseHeaders) {
+        methodObj.responses[resp.status] ??= { description: "", content: {} };
+        methodObj.responses[resp.status];
+        const res = methodObj.responses[resp.status];
+        res.headers = { schema: await _jsonschematoopenapischema.convert.call(void 0, this.#visit(resp.schema)) };
+      }
+    }
+    if (def.request.body)
+      methodObj.requestBody = {
+        required: true,
+        content: {
+          "application/json": { schema: await _jsonschematoopenapischema.convert.call(void 0, this.#visit(def.request.body)) }
+        }
+      };
+    const parameters = [];
+    const addParams = async (location, schema) => {
+      if (!schema) return;
+      const flat = this.#flattenForParameters(schema);
+      for (const schema2 of flat) {
+        if (!schema2.properties) continue;
+        for (const [name, value] of Object.entries(schema2.properties))
+          parameters.push({
+            name,
+            in: location,
+            schema: await _jsonschematoopenapischema.convert.call(void 0, this.#visit(value)),
+            required: (schema2.required || []).includes(name)
+          });
+      }
+    };
+    await Promise.all([
+      addParams("query", def.request.query),
+      addParams("path", def.request.params),
+      addParams("header", def.request.headers)
+    ]);
+    if (parameters.length) methodObj.parameters = parameters;
+    const base = this.#baseOpenapiDoc;
+    if (!base.paths) base.paths = {};
+    if (!base.paths[path]) base.paths[path] = {};
+    base.paths[path][method] = methodObj;
+  }
+  router() {
+    const jsonPath = "/openapi.json";
+    const router = new Router({ path: _nullishCoalesce(this.config.config.openapi.docsPath, () => ( "/")), hide: true });
+    router.get("/")((req) => req.res({ body: this.#html(`.${jsonPath}`), contentType: "text/html" }));
+    router.get(jsonPath)((req) => req.res({ body: this.#baseOpenapiDoc }));
+    return router;
+  }
+  #flattenForParameters(node) {
+    const { allOf, oneOf, anyOf, ...schema } = node;
+    if (allOf) return allOf.flatMap((n) => this.#flattenForParameters(n));
+    return [schema];
+  }
+  #visit(node) {
+    if (!node || typeof node !== "object") return node;
+    if (typeof node.$refId === "string") {
+      const { $refId: id, ...rest } = node;
+      const res = this.#visit(rest);
+      if (_optionalChain([this, 'access', _21 => _21.#baseOpenapiDoc, 'access', _22 => _22.components, 'optionalAccess', _23 => _23.schemas])) {
+        this.#baseOpenapiDoc.components.schemas[id] = res;
+        return { $ref: `#/components/schemas/${id}` };
+      } else return res;
+    }
+    if (Array.isArray(node)) return node.map((n) => this.#visit(n));
+    return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, this.#visit(value)]));
+  }
+  #buildTag(groups) {
+    if (!groups.length) return void 0;
+    const parsed = groups.map((g) => typeof g === "string" ? { name: g } : g);
+    const name = parsed.map((g) => g.name).join(" > ");
+    const displayName = _nullishCoalesce(_optionalChain([parsed, 'access', _24 => _24.at, 'call', _25 => _25(-1), 'optionalAccess', _26 => _26.name]), () => ( ""));
+    const description = parsed.map((g) => _nullishCoalesce(_optionalChain([g, 'access', _27 => _27.description, 'optionalAccess', _28 => _28.trim, 'call', _29 => _29()]), () => ( ""))).filter(Boolean).join("\n\n\n\n");
+    if (!this.#registeredTags[name]) {
+      this.#registeredTags[name] = true;
+      this.#baseOpenapiDoc.tags.push({ name, "x-displayName": displayName, description });
+      const tagGroups = parsed.slice(0, -1);
+      const groupName = tagGroups.map((g) => g.name).join(" > ") || "default";
+      if (!this.#registeredTagGroups[groupName]) {
+        const group = { name: groupName, tags: [] };
+        this.#baseOpenapiDoc["x-tagGroups"].push(group);
+        this.#registeredTagGroups[groupName] = group;
+      }
+      this.#registeredTagGroups[groupName].tags = [.../* @__PURE__ */ new Set([...this.#registeredTagGroups[groupName].tags, name])];
+    }
+    return name;
+  }
+  #html(jsonPath) {
+    const title = _valleyed.capitalize.call(void 0, `${this.config.app.name} ${this.config.app.id}`);
+    return `
+<!doctype html>
+<html>
+  <head>
+    <title>${title}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+	<style>
+      .darklight-reference {
+        display: none;
+      }
+    </style>
+  </head>
+  <body>
+    <script id="api-reference" data-url="${jsonPath}"></script>
+    <script>
+      const configuration = { theme: 'purple' };
+      document.getElementById('api-reference').dataset.configuration = JSON.stringify(configuration);
+    </script>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference@1.28.33"></script>
+  </body>
+</html>
+`;
+  }
+};
+
+// src/utilities/authProviders.ts
+var authProviders_exports = {};
+__export(authProviders_exports, {
+  signinWithApple: () => signinWithApple,
+  signinWithFacebook: () => signinWithFacebook,
+  signinWithGoogle: () => signinWithGoogle
+});
+var _axios = require('axios'); var _axios2 = _interopRequireDefault(_axios);
+var _jsonwebtoken = require('jsonwebtoken'); var _jsonwebtoken2 = _interopRequireDefault(_jsonwebtoken);
+var _jwksrsa = require('jwks-rsa'); var _jwksrsa2 = _interopRequireDefault(_jwksrsa);
+var signinWithGoogle = async (idToken) => {
+  const authUrl = `https://oauth2.googleapis.com/tokeninfo?id_token=${idToken}`;
+  const { data } = await _axios2.default.get(authUrl).catch((err) => {
+    throw new EquippedError("Failed to sign in with google", { idToken }, err);
+  });
+  data.first_name = data.given_name;
+  data.last_name = data.family_name;
+  return data;
+};
+var signinWithApple = async (idToken) => {
+  try {
+    const APPLE_BASE = "https://appleid.apple.com";
+    const json = _jsonwebtoken2.default.decode(idToken, { complete: true });
+    if (!_optionalChain([json, 'optionalAccess', _30 => _30.header])) throw new Error("");
+    const { kid, alg } = json.header;
+    const publicKey = await _jwksrsa2.default.call(void 0, { jwksUri: `${APPLE_BASE}/auth/keys`, cache: true }).getSigningKey(kid).then((key) => key.getPublicKey()).catch(() => null);
+    if (!publicKey) throw new EquippedError("no publicKey", { idToken, publicKey, json });
+    const data = _jsonwebtoken2.default.verify(idToken, publicKey, { algorithms: [alg] });
+    if (!data) throw new EquippedError("no data", { idToken, data });
+    if (data.iss !== APPLE_BASE) throw new EquippedError("iss doesnt match", { idToken, data });
+    if (data.exp * 1e3 < Date.now()) throw new EquippedError("expired idToken", { idToken, data });
+    return data;
+  } catch (err) {
+    throw new EquippedError("Failed to sign in with apple", { idToken }, err);
+  }
+};
+var signinWithFacebook = async (accessToken, fields = []) => {
+  fields = [.../* @__PURE__ */ new Set([...fields, "name", "picture", "email"])];
+  const { data } = await _axios2.default.request({
+    method: "get",
+    url: "https://graph.facebook.com/v15.0/me",
+    params: {
+      fields: fields.join(","),
+      access_token: accessToken
+    }
+  }).catch((err) => {
+    throw new EquippedError("Failed to sign in with facebook", { accessToken, fields }, err);
+  });
+  const isValidData = fields.every((key) => key in data);
+  if (!isValidData) throw new Error("Incomplete scope for access token");
+  data.email_verified = "true";
+  return data;
+};
+
+// src/utilities/hash.ts
+var hash_exports = {};
+__export(hash_exports, {
+  compare: () => compare2,
+  hash: () => hash2
+});
+var _bcryptjs = require('bcryptjs'); var bcrypt = _interopRequireWildcard(_bcryptjs);
+var hash2 = async (password) => {
+  password = password.trim();
+  if (!password) return "";
+  return await bcrypt.hash(password, Instance.get().settings.utils.hashSaltRounds);
+};
+var compare2 = async (plainPassword, hashed) => {
+  plainPassword = plainPassword.trim();
+  if (!plainPassword && plainPassword === hashed) return true;
+  return await bcrypt.compare(plainPassword, hashed);
+};
+
+// src/utilities/json.ts
+var parseJSONValue = (data) => {
+  try {
+    if (_optionalChain([data, 'optionalAccess', _31 => _31.constructor, 'optionalAccess', _32 => _32.name]) !== "String") return data;
+    return JSON.parse(data);
+  } catch (e2) {
+    return data;
+  }
+};
+function parseJSONObject(data) {
+  return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, parseJSONValue(value)]));
+}
+
+// src/utilities/media.ts
+var _musicmetadata = require('music-metadata');
+var getMediaDuration = async (buffer) => {
+  try {
+    const meta = await _musicmetadata.parseBuffer.call(void 0, buffer);
+    return _nullishCoalesce(meta.format.duration, () => ( 0));
+  } catch (e3) {
+    return 0;
+  }
+};
+
+// src/utilities/retry.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var retry = async (cb, tries, waitTimeInMs) => {
+  if (tries <= 0) throw new EquippedError("out of tries", { tries, waitTimeInMs });
+  const result = await cb();
+  if (result.done === true) return result.value;
+  await sleep(waitTimeInMs);
+  return await retry(cb, tries - 1, waitTimeInMs);
+};
+
+// src/utilities/random.ts
+var random_exports = {};
+__export(random_exports, {
+  number: () => number,
+  string: () => string
+});
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+function string(length = 20) {
+  return _crypto2.default.randomBytes(length).toString("hex").slice(0, length);
+}
+function number(min = 0, max = 2 ** 48 - 1) {
+  return _crypto2.default.randomInt(min, max);
+}
+
+// src/server/requests.ts
+var Request = (_class2 = class {
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  __init8() {this.users = {
+    access: {},
+    refresh: {},
+    apiKey: {}
+  }}
+  
+  constructor({
+    ip,
+    body,
+    cookies,
+    params,
+    query,
+    method,
+    path,
+    context,
+    headers,
+    files
+  }) {;_class2.prototype.__init8.call(this);
+    this.ip = ip;
+    this.method = method;
+    this.path = path;
+    this.params = params;
+    this.cookies = cookies;
+    this.headers = headers;
+    this.query = parseJSONObject(query);
+    this.body = Object.assign(parseJSONObject(body), files);
+    this.context = context;
+  }
+  pipe(stream, opts = {}) {
+    return new Response({ ...opts, piped: true, body: stream });
+  }
+  res(params) {
+    return new Response({ ...params, piped: false });
+  }
+  error(params) {
+    return new Response({ ...params, piped: false });
+  }
+}, _class2);
+var Response = class {
+  
+  
+  
+  
+  
+  constructor({ body, status = 200, headers = {}, piped = false, contentType = "application/json" }) {
+    this.body = body;
+    this.status = status;
+    this.contentType = contentType;
+    this.headers = headers;
+    this.piped = piped;
+    if (!this.piped) {
+      this.headers["Content-Type"] = contentType;
+    }
+  }
+};
+
+// src/server/sockets.ts
+var _pathtoregexp = require('path-to-regexp');
+var EmitterEvent = "__listener_emitter";
+var defaultTo = "*";
+var SocketEmitter = class {
+  
+  #connectionCallbacks = { onConnect: async () => {
+  }, onDisconnect: async () => {
+  } };
+  #routes = {};
+  #publish = async () => {
+  };
+  constructor(socket, eventBus) {
+    this.socketInstance = socket;
+    this.#setupSocketConnection();
+    Instance.on(
+      "setup",
+      () => {
+        this.#publish = eventBus ? eventBus.createPublisher(EmitterEvent) : async (data) => {
+          socket.to(data.channel).emit(data.channel, data);
+        };
+        _optionalChain([eventBus, 'optionalAccess', _33 => _33.createSubscriber, 'call', _34 => _34(
+          EmitterEvent,
+          async (data) => {
+            socket.to(data.channel).emit(data.channel, data);
+          },
+          { fanout: true }
+        )]);
+      },
+      1
+    );
+  }
+  async created(channels, data, to) {
+    await this.#emit(channels, "created" /* created */, { after: data.toJSON(), before: null }, to);
+  }
+  async updated(channels, { after, before }, to) {
+    await this.#emit(channels, "updated" /* updated */, { after: after.toJSON(), before: before.toJSON() }, to);
+  }
+  async deleted(channels, data, to) {
+    await this.#emit(channels, "deleted" /* deleted */, { before: data.toJSON(), after: null }, to);
+  }
+  async #emit(channels, type, { before, after }, to) {
+    const toArray = Array.isArray(to) ? to : [_nullishCoalesce(to, () => ( defaultTo))];
+    const channelMap = channels.flatMap((c) => toArray.map((to2) => `${to2}:${c}`));
+    await Promise.all(channelMap.map(async (channel) => this.#publish({ channel, type, before, after })));
+  }
+  set connectionCallbacks(callbacks) {
+    this.#connectionCallbacks = callbacks;
+    this.#setupSocketConnection();
+  }
+  register(channel, onJoin) {
+    this.#routes[channel] = onJoin;
+    this.#routes[channel + "/:id"] = onJoin;
+    return this;
+  }
+  #getConfig(channel) {
+    const matcher = (key) => _pathtoregexp.match.call(void 0, key)(channel);
+    const matchedChannel = _nullishCoalesce(Object.keys(this.#routes).find(matcher), () => ( null));
+    if (!matchedChannel) return null;
+    const match = matcher(matchedChannel);
+    if (!match) return null;
+    return {
+      config: this.#routes[matchedChannel],
+      params: match.params
+    };
+  }
+  #setupSocketConnection = () => {
+    this.socketInstance.removeAllListeners("connection");
+    this.socketInstance.on("connection", async (socket) => {
+      const socketId = socket.id;
+      let user = null;
+      const tokensUtil = _optionalChain([Instance, 'access', _35 => _35.get, 'call', _36 => _36(), 'access', _37 => _37.settings, 'access', _38 => _38.server, 'optionalAccess', _39 => _39.requestsAuth, 'access', _40 => _40.tokens]);
+      if (socket.handshake.auth.authorization && tokensUtil)
+        user = await tokensUtil.verifyAccessToken(_nullishCoalesce(socket.handshake.auth.authorization, () => ( ""))).catch(() => null);
+      socket.on("leave", async (data, callback) => {
+        if (!data.channel)
+          return typeof callback === "function" && callback({
+            code: StatusCodes.ValidationError,
+            message: "channel is required",
+            channel: ""
+          });
+        socket.leave(data.channel);
+        return typeof callback === "function" && callback({
+          code: StatusCodes.Ok,
+          message: "",
+          channel: data.channel
+        });
+      });
+      socket.on("join", async (data, callback) => {
+        if (!data.channel)
+          return typeof callback === "function" && callback({
+            code: StatusCodes.ValidationError,
+            message: "channel is required",
+            channel: ""
+          });
+        const channel = data.channel;
+        const route = _nullishCoalesce(this.#getConfig(channel), () => ( null));
+        if (!route)
+          return typeof callback === "function" && callback({
+            code: StatusCodes.BadRequest,
+            message: "unknown channel",
+            channel
+          });
+        const to = await route.config({ channel, user }, route.params, _nullishCoalesce(data.query, () => ( {})));
+        const newChannel = `${_nullishCoalesce(to, () => ( defaultTo))}:${channel}`;
+        socket.join(newChannel);
+        return typeof callback === "function" && callback({
+          code: StatusCodes.Ok,
+          message: "",
+          channel: newChannel
+        });
+      });
+      if (user) await this.#connectionCallbacks.onConnect(user.id, socketId);
+      socket.on("disconnect", async () => {
+        if (user) await this.#connectionCallbacks.onDisconnect(user.id, socketId);
+      });
+    });
+  };
+};
+
+// src/server/impls/base.ts
+var errorsSchemas = Object.entries(StatusCodes).filter(([, value]) => value > 399).map(([key, value]) => ({
+  status: value,
+  contentType: "application/json",
+  pipe: _valleyed.v.meta(_valleyed.v.array(_valleyed.v.object({ message: _valleyed.v.string(), field: _valleyed.v.optional(_valleyed.v.string()) })), {
+    $refId: `Errors.${key}Response`,
+    description: `${key} Response`
+  })
+}));
+var Server = (_class3 = class {
+  constructor(server, config, implementations) {;_class3.prototype.__init9.call(this);
+    this.config = config;
+    this.implementations = implementations;
+    this.server = server;
+    this.#openapi = new OpenApi(this.config);
+    const socketInstance = new _socketio2.default.Server(server, { cors: this.cors });
+    this.socket = new SocketEmitter(socketInstance, config.eventBus);
+    this.addRouter(this.#openapi.router());
+  }
+  #queue = [];
+  #routesByKey = /* @__PURE__ */ new Map();
+  #openapi;
+  
+  
+  __init9() {this.cors = {
+    origin: "*",
+    methods: Object.values(Methods).filter((m) => m !== Methods.options).map((m) => m.toUpperCase())
+  }}
+  addRouter(...routers) {
+    routers.map((router) => router.routes).forEach((routes) => this.addRoute(...routes));
+  }
+  addRoute(...routes) {
+    routes.forEach((route) => {
+      this.#queue.push(async () => {
+        const { method, path, schema = {}, onError, middlewares = [] } = route;
+        const key = `(${method.toUpperCase()}) ${this.#openapi.cleanPath(path)}`;
+        if (this.#routesByKey.get(key))
+          throw new EquippedError(`Route key ${key} already registered. All route keys must be unique`, { route, key });
+        middlewares.unshift(parseAuthUser);
+        middlewares.forEach((m) => _optionalChain([m, 'access', _41 => _41.onSetup, 'optionalCall', _42 => _42(route)]));
+        _optionalChain([onError, 'optionalAccess', _43 => _43.onSetup, 'optionalCall', _44 => _44(route)]);
+        const { validateRequest, validateResponse, jsonSchema } = this.#resolveSchema(method, schema);
+        this.#routesByKey.set(key, true);
+        await this.#openapi.register(route, jsonSchema);
+        this.implementations.registerRoute(method, this.#openapi.cleanPath(path), async (req, res) => {
+          const request = await validateRequest(await this.implementations.parseRequest(req));
+          try {
+            for (const middleware of middlewares) await middleware.cb(request);
+            const rawRes = await route.handler(request);
+            const response = rawRes instanceof Response ? rawRes : new Response({ body: rawRes, status: StatusCodes.Ok, headers: {}, piped: false });
+            return await this.implementations.handleResponse(res, await validateResponse(response));
+          } catch (error) {
+            if (_optionalChain([onError, 'optionalAccess', _45 => _45.cb])) {
+              const rawResponse = await onError.cb(request, error);
+              const response = rawResponse instanceof Response ? rawResponse : new Response({ body: rawResponse, status: StatusCodes.BadRequest, headers: {} });
+              return await this.implementations.handleResponse(res, await validateResponse(response));
+            }
+            throw error;
+          }
+        });
+      });
+    });
+  }
+  #resolveSchema(method, schema) {
+    const defaultStatusCode = _nullishCoalesce(_optionalChain([schema, 'optionalAccess', _46 => _46.defaultStatusCode]), () => ( StatusCodes.Ok));
+    const defaultContentType = _nullishCoalesce(_optionalChain([schema, 'optionalAccess', _47 => _47.defaultContentType]), () => ( "application/json"));
+    let status = defaultStatusCode;
+    let contentType = defaultContentType;
+    const jsonSchema = { response: {}, request: {} };
+    const requestPipe = {};
+    const responsePipe = {};
+    const defs = [
+      { key: "params", type: "request" },
+      { key: "headers", type: "request" },
+      { key: "query", type: "request" },
+      { key: "body", type: "request", skip: ![Methods.post, Methods.put, Methods.patch].includes(method) },
+      { key: "response", type: "response" },
+      { key: "responseHeaders", type: "response" }
+    ];
+    defs.forEach((def) => {
+      const pipe = _nullishCoalesce(schema[def.key], () => ( _valleyed.v.any()));
+      if (def.skip) return;
+      if (def.type === "request") {
+        requestPipe[def.key] = pipe;
+        jsonSchema.request[def.key] = _valleyed.v.schema(pipe);
+      }
+      if (def.type === "response") {
+        const pipeRecords = errorsSchemas.concat({ status: defaultStatusCode, contentType, pipe });
+        responsePipe[def.key] = _valleyed.v.any().pipe((input) => {
+          const p = _optionalChain([pipeRecords, 'access', _48 => _48.find, 'call', _49 => _49((r) => r.status === status), 'optionalAccess', _50 => _50.pipe]);
+          if (!p) throw _valleyed.PipeError.root(`schema not defined for status code: ${status}`, input);
+          return _valleyed.v.assert(p, input);
+        });
+        jsonSchema.response[def.key] = pipeRecords.map((record) => ({
+          status: record.status,
+          contentType: record.contentType,
+          schema: _valleyed.v.schema(record.pipe)
+        }));
+      }
+    });
+    const validateRequest = async (request) => {
+      if (!Object.keys(requestPipe)) return request;
+      const context = schema.context ? await schema.context(request) : {};
+      request.context = context;
+      const validity = requestLocalStorage.run(
+        request,
+        () => _valleyed.v.validate(_valleyed.v.object(requestPipe), {
+          params: request.params,
+          headers: request.headers,
+          query: request.query,
+          body: request.body
+        })
+      );
+      if (!validity.valid) throw pipeErrorToValidationError(validity.error);
+      request.params = validity.value.params;
+      request.headers = validity.value.headers;
+      request.query = validity.value.query;
+      request.body = validity.value.body;
+      return request;
+    };
+    const validateResponse = async (response) => {
+      if (!Object.keys(responsePipe)) return response;
+      status = response.status;
+      contentType = response.contentType;
+      contentType;
+      const validity = responseLocalStorage.run(
+        response,
+        () => _valleyed.v.validate(_valleyed.v.object(responsePipe), {
+          responseHeaders: response.headers,
+          response: response.body
+        })
+      );
+      if (!validity.valid) throw pipeErrorToValidationError(validity.error);
+      response.body = validity.value.response;
+      response.headers = validity.value.responseHeaders;
+      return response;
+    };
+    return {
+      jsonSchema,
+      validateRequest,
+      validateResponse
+    };
+  }
+  test() {
+    return _supertest2.default.call(void 0, this.server);
+  }
+  async start() {
+    const port = this.config.config.port;
+    if (this.config.config.healthPath)
+      this.addRoute({
+        method: Methods.get,
+        path: this.config.config.healthPath,
+        handler: async (req) => req.res({
+          body: `${this.config.app.id}(${this.config.app.name}) service running`,
+          contentType: "text/plain"
+        })
+      });
+    this.implementations.registerNotFoundHandler(async (req) => {
+      const request = await this.implementations.parseRequest(req);
+      throw new NotFoundError(`Route ${request.path} not found`);
+    });
+    this.implementations.registerErrorHandler(async (error, _, res) => {
+      Instance.get().log.error(error);
+      const response = error instanceof RequestError ? new Response({
+        body: error.serializedErrors,
+        status: error.statusCode
+      }) : new Response({
+        body: [{ message: "Something went wrong", data: error.message }],
+        status: StatusCodes.BadRequest
+      });
+      return await this.implementations.handleResponse(res, response);
+    });
+    await Promise.all(this.#queue.map((cb) => cb()));
+    const started = await this.implementations.start(port);
+    if (started) Instance.get().log.info(`${this.config.app.id}(${this.config.app.name}) service listening on port ${port}`);
+    return started;
+  }
+}, _class3);
+
+// src/server/impls/express.ts
+var _http = require('http'); var _http2 = _interopRequireDefault(_http);
+var _cookieparser = require('cookie-parser'); var _cookieparser2 = _interopRequireDefault(_cookieparser);
+var _cors = require('cors'); var _cors2 = _interopRequireDefault(_cors);
+var _express = require('express'); var _express2 = _interopRequireDefault(_express);
+var _expressfileupload = require('express-fileupload'); var _expressfileupload2 = _interopRequireDefault(_expressfileupload);
+var _expressratelimit = require('express-rate-limit');
+var _helmet = require('helmet'); var _helmet2 = _interopRequireDefault(_helmet);
+var _pinohttp = require('pino-http');
+var ExpressServer = class extends Server {
+  #expressApp;
+  constructor(config) {
+    const app = _express2.default.call(void 0, );
+    super(_http2.default.createServer(app), config, {
+      parseRequest: async (req) => {
+        const allHeaders = Object.fromEntries(Object.entries(req.headers).map(([key, val]) => [key, _nullishCoalesce(val, () => ( null))]));
+        const headers = {
+          ...allHeaders,
+          Authorization: req.get("authorization"),
+          RefreshToken: req.get("x-refresh-token"),
+          ApiKey: req.get("x-api-key"),
+          ContentType: req.get("content-type"),
+          Referer: req.get("referer"),
+          UserAgent: req.get("user-agent")
+        };
+        const files = Object.fromEntries(
+          await Promise.all(
+            Object.entries(_nullishCoalesce(req.files, () => ( {}))).map(async ([key, file]) => {
+              const uploads = Array.isArray(file) ? file : [file];
+              const fileArray = await Promise.all(
+                uploads.map(async (f) => ({
+                  name: f.name,
+                  type: f.mimetype,
+                  size: f.size,
+                  isTruncated: f.truncated,
+                  data: f.data,
+                  duration: await getMediaDuration(f.data)
+                }))
+              );
+              return [key, fileArray];
+            })
+          )
+        );
+        return new Request({
+          ip: req.ip,
+          body: _nullishCoalesce(req.body, () => ( {})),
+          cookies: _nullishCoalesce(req.cookies, () => ( {})),
+          params: _nullishCoalesce(req.params, () => ( {})),
+          query: _nullishCoalesce(req.query, () => ( {})),
+          method: req.method,
+          path: req.path,
+          headers,
+          files,
+          context: {}
+        });
+      },
+      handleResponse: async (res, response) => {
+        if (!response.piped) {
+          Object.entries(response.headers).forEach(([key, value]) => res.header(key, value));
+          const type = response.body === null || response.body === void 0 ? "json" : "send";
+          res.status(response.status)[type](response.body).end();
+        } else {
+          response.body.pipe(res);
+        }
+      },
+      registerRoute: (method, path, cb) => {
+        _optionalChain([this, 'access', _51 => _51.#expressApp, 'access', _52 => _52[method], 'optionalCall', _53 => _53(path, cb)]);
+      },
+      registerErrorHandler: (cb) => {
+        this.#expressApp.use(async (err, req, res, _next) => cb(err, req, res));
+      },
+      registerNotFoundHandler: (cb) => {
+        this.#expressApp.use(cb);
+      },
+      start: async (port) => new Promise((resolve, reject) => {
+        try {
+          const app2 = this.server.listen({ host: "0.0.0.0", port }, async () => resolve(true));
+          Instance.on("close", app2.close, 1);
+        } catch (err) {
+          reject(err);
+        }
+      })
+    });
+    this.#expressApp = app;
+    app.disable("x-powered-by");
+    if (config.config.requests.log) app.use(_pinohttp.pinoHttp.call(void 0, { logger: config.log }));
+    app.use(_express2.default.json());
+    app.use(_express2.default.text());
+    app.use(_cookieparser2.default.call(void 0, ));
+    app.use(
+      _helmet2.default.call(void 0, {
+        crossOriginResourcePolicy: { policy: "cross-origin" },
+        contentSecurityPolicy: false
+      })
+    );
+    app.use(_cors2.default.call(void 0, this.cors));
+    app.use(_express2.default.urlencoded({ extended: false }));
+    if (config.config.publicPath) app.use(_express2.default.static(config.config.publicPath));
+    app.use(
+      _expressfileupload2.default.call(void 0, {
+        limits: { fileSize: config.config.requests.maxFileUploadSizeInMb * 1024 * 1024 },
+        useTempFiles: false
+      })
+    );
+    if (config.config.requests.rateLimit.enabled)
+      app.use(
+        _expressratelimit.rateLimit.call(void 0, {
+          windowMs: config.config.requests.rateLimit.periodInMs,
+          limit: config.config.requests.rateLimit.limit,
+          handler: (_, res) => res.status(StatusCodes.TooManyRequests).json([{ message: "Too Many Requests" }])
+        })
+      );
+  }
+};
+
+// src/server/impls/fastify.ts
+var _cookie = require('@fastify/cookie'); var _cookie2 = _interopRequireDefault(_cookie);
+var _cors3 = require('@fastify/cors'); var _cors4 = _interopRequireDefault(_cors3);
+var _formbody = require('@fastify/formbody'); var _formbody2 = _interopRequireDefault(_formbody);
+var _helmet3 = require('@fastify/helmet'); var _helmet4 = _interopRequireDefault(_helmet3);
+var _multipart = require('@fastify/multipart'); var _multipart2 = _interopRequireDefault(_multipart);
+var _ratelimit = require('@fastify/rate-limit'); var _ratelimit2 = _interopRequireDefault(_ratelimit);
+var _static = require('@fastify/static'); var _static2 = _interopRequireDefault(_static);
+var _fastify = require('fastify'); var _fastify2 = _interopRequireDefault(_fastify);
+var _qs = require('qs'); var _qs2 = _interopRequireDefault(_qs);
+var FastifyServer = class extends Server {
+  constructor(config) {
+    const app = _fastify2.default.call(void 0, {
+      ignoreTrailingSlash: true,
+      caseSensitive: false,
+      disableRequestLogging: !config.config.requests.log,
+      loggerInstance: config.config.requests.log ? config.log : void 0,
+      ajv: { customOptions: { coerceTypes: false } },
+      schemaErrorFormatter: (errors, data) => new ValidationError(
+        errors.map((error) => ({
+          messages: [_nullishCoalesce(error.message, () => ( ""))],
+          field: `${data}${error.instancePath}`.replaceAll("/", ".")
+        }))
+      )
+    });
+    super(app.server, config, {
+      parseRequest: async (req) => {
+        const allHeaders = Object.fromEntries(Object.entries(req.headers).map(([key, val]) => [key, _nullishCoalesce(val, () => ( null))]));
+        const headers = {
+          ...allHeaders,
+          Authorization: _optionalChain([req, 'access', _54 => _54.headers, 'access', _55 => _55["authorization"], 'optionalAccess', _56 => _56.toString, 'call', _57 => _57()]),
+          RefreshToken: _optionalChain([req, 'access', _58 => _58.headers, 'access', _59 => _59["x-refresh-token"], 'optionalAccess', _60 => _60.toString, 'call', _61 => _61()]),
+          ApiKey: _optionalChain([req, 'access', _62 => _62.headers, 'access', _63 => _63["x-api-key"], 'optionalAccess', _64 => _64.toString, 'call', _65 => _65()]),
+          ContentType: _optionalChain([req, 'access', _66 => _66.headers, 'access', _67 => _67["content-type"], 'optionalAccess', _68 => _68.toString, 'call', _69 => _69()]),
+          Referer: _optionalChain([req, 'access', _70 => _70.headers, 'access', _71 => _71["referer"], 'optionalAccess', _72 => _72.toString, 'call', _73 => _73()]),
+          UserAgent: _optionalChain([req, 'access', _74 => _74.headers, 'access', _75 => _75["user-agent"], 'optionalAccess', _76 => _76.toString, 'call', _77 => _77()])
+        };
+        const { body, files } = excludeBufferKeys(_nullishCoalesce(req.body, () => ( {})));
+        return new Request({
+          ip: req.ip,
+          body,
+          cookies: _nullishCoalesce(req.cookies, () => ( {})),
+          params: _nullishCoalesce(req.params, () => ( {})),
+          query: _nullishCoalesce(req.query, () => ( {})),
+          method: req.method,
+          path: req.url,
+          headers,
+          files,
+          context: {}
+        });
+      },
+      handleResponse: async (res, response) => {
+        await res.status(response.status).headers(response.headers).send(response.body);
+      },
+      registerRoute: (method, path, cb) => {
+        app.register(async (inst) => {
+          inst.route({ url: path, method, handler: cb });
+        });
+      },
+      registerErrorHandler: (cb) => {
+        app.setErrorHandler(cb);
+      },
+      registerNotFoundHandler: (cb) => {
+        app.setNotFoundHandler(cb);
+      },
+      start: async (port) => {
+        await app.ready();
+        await app.listen({ port, host: "0.0.0.0" });
+        Instance.on("close", app.close, 1);
+        return true;
+      }
+    });
+    app.decorateRequest("savedReq", null);
+    app.setValidatorCompiler(() => () => true);
+    app.setSerializerCompiler(() => (data) => JSON.stringify(data));
+    if (config.config.publicPath) app.register(_static2.default, { root: config.config.publicPath });
+    app.register(_cookie2.default, {});
+    app.register(_cors4.default, this.cors);
+    app.register(_formbody2.default, { parser: (str) => _qs2.default.parse(str) });
+    app.register(_helmet4.default, { crossOriginResourcePolicy: { policy: "cross-origin" }, contentSecurityPolicy: false });
+    app.register(_multipart2.default, {
+      attachFieldsToBody: "keyValues",
+      throwFileSizeLimit: false,
+      limits: { fileSize: config.config.requests.maxFileUploadSizeInMb * 1024 * 1024 },
+      onFile: async (f) => {
+        const buffer = await f.toBuffer();
+        const parsed = {
+          name: f.filename,
+          type: f.mimetype,
+          size: buffer.byteLength,
+          isTruncated: f.file.truncated,
+          data: buffer,
+          duration: await getMediaDuration(buffer)
+        };
+        f.value = parsed;
+      }
+    });
+    if (config.config.requests.rateLimit.enabled)
+      app.register(_ratelimit2.default, {
+        max: config.config.requests.rateLimit.limit,
+        timeWindow: config.config.requests.rateLimit.periodInMs,
+        errorResponseBuilder: (_, context) => ({
+          statusCode: StatusCodes.TooManyRequests,
+          message: JSON.stringify([{ message: `Too Many Requests. Retry in ${context.after}` }])
+        })
+      });
+  }
+};
+function excludeBufferKeys(body) {
+  if (typeof body !== "object") return { body, files: {} };
+  const entries = Object.entries(_nullishCoalesce(body, () => ( {})));
+  const isFile = (val) => Array.isArray(val) ? isFile(val.at(0)) : Buffer.isBuffer(_optionalChain([val, 'optionalAccess', _78 => _78.data]));
+  const fileEntries = entries.filter(([_, value]) => isFile(value)).map(([key, value]) => [key, Array.isArray(value) ? value : [value]]);
+  const nonFileEntries = entries.filter(([_, value]) => !isFile(value));
+  return {
+    body: Object.fromEntries(nonFileEntries),
+    files: Object.fromEntries(fileEntries)
+  };
+}
+
+// src/server/middlewares/requireAuthUser.ts
+var requireAuthUser = makeMiddleware(
+  async (request) => {
+    const user = request.users.access.value || request.users.apiKey.value;
+    const error = request.users.access.error || request.users.apiKey.error;
+    if (!user && error) throw error;
+    request.authUser = user;
+    if (!request.authUser) throw new NotAuthenticatedError();
+  },
+  (route) => {
+    route.security ??= [];
+    route.security.push({ Authorization: [] }, { ApiKey: [] });
+    route.descriptions ??= [];
+    route.descriptions.push("Requires a valid means of authentication.");
+  }
+);
+var requireAuthorizationUser = makeMiddleware(
+  async (request) => {
+    if (request.users.access.error) throw request.users.access.error;
+    request.authUser = request.users.access.value;
+    if (!request.authUser) throw new NotAuthenticatedError();
+  },
+  (route) => {
+    route.security ??= [];
+    route.security.push({ Authorization: [] });
+    route.descriptions ??= [];
+    route.descriptions.push("Requires a valid authorization header.");
+  }
+);
+var requireApiKeyUser = makeMiddleware(
+  async (request) => {
+    if (request.users.apiKey.error) throw request.users.apiKey.error;
+    request.authUser = request.users.apiKey.value;
+    if (!request.authUser) throw new NotAuthenticatedError();
+  },
+  (route) => {
+    route.security ??= [];
+    route.security.push({ ApiKey: [] });
+    route.descriptions ??= [];
+    route.descriptions.push("Requires a valid x-api-key header.");
+  }
+);
+var requireRefreshTokenUser = makeMiddleware(
+  async (request) => {
+    if (request.users.refresh.error) throw request.users.refresh.error;
+    const refreshToken = request.headers.RefreshToken;
+    if (!refreshToken) throw new NotAuthorizedError("x-refresh-token header missing");
+    request.users.refresh.value = await _optionalChain([Instance, 'access', _79 => _79.get, 'call', _80 => _80(), 'access', _81 => _81.settings, 'access', _82 => _82.server, 'optionalAccess', _83 => _83.requestsAuth, 'access', _84 => _84.tokens, 'optionalAccess', _85 => _85.verifyRefreshToken, 'call', _86 => _86(refreshToken)]);
+    if (!request.users.refresh.value) throw new NotAuthorizedError();
+  },
+  (route) => {
+    route.security ??= [];
+    route.security.push({ RefreshToken: [] });
+    route.descriptions ??= [];
+    route.descriptions.push("Requires a valid x-refresh-token header.");
+  }
+);
+
+// src/server/pipes.ts
+
+
+// src/server/requests-auth/apiKeys.ts
+var BaseApiKeysUtility = class {
+};
+
+// src/server/requests-auth/tokens.ts
+
+var BaseTokensUtility = class {
+  extractAccessTokenValue(headerValue) {
+    if (!headerValue.startsWith("Bearer ")) throw new EquippedError(`authorization header must begin with 'Bearer '`, { headerValue });
+    return headerValue.slice(7);
+  }
+  async exchangeTokens(tokens, getPayload) {
+    const authUser = await this.verifyAccessToken(tokens.accessToken).catch((err) => {
+      const error = err;
+      if (error.statusCode === StatusCodes.AuthorizationExpired) return null;
+      else throw err;
+    });
+    if (authUser) return tokens;
+    const refreshUser = await this.verifyRefreshToken(tokens.refreshToken);
+    const payloads = await getPayload(refreshUser.id);
+    return {
+      accessToken: await this.createAccessToken(payloads.access),
+      refreshToken: await this.createRefreshToken(payloads.refresh)
+    };
+  }
+};
+var CacheTokensUtility = class extends BaseTokensUtility {
+  #getAccessTokenKey;
+  #getRefreshTokenKey;
+  
+  constructor(options) {
+    super();
+    this.options = {
+      accessTokenKey: "accessTokenKey",
+      refreshTokenKey: "refreshTokenKey",
+      accessTokenTTL: 60 * 60,
+      refreshTokenTTL: 14 * 24 * 60 * 60,
+      accessTokenPrefix: "tokens:access:",
+      refreshTokenPrefix: "tokens:refresh:",
+      ...options
+    };
+    this.#getAccessTokenKey = (userId) => `${this.options.accessTokenPrefix}${userId}`;
+    this.#getRefreshTokenKey = (userId) => `${this.options.refreshTokenPrefix}${userId}`;
+  }
+  async createAccessToken(payload) {
+    const token = _jsonwebtoken2.default.sign(payload, this.options.accessTokenKey, { expiresIn: this.options.accessTokenTTL });
+    await Instance.get().cache.set(this.#getAccessTokenKey(payload.id), token, this.options.accessTokenTTL);
+    return token;
+  }
+  async createRefreshToken(payload) {
+    const token = _jsonwebtoken2.default.sign(payload, this.options.refreshTokenKey, { expiresIn: this.options.refreshTokenTTL });
+    await Instance.get().cache.set(this.#getRefreshTokenKey(payload.id), token, this.options.refreshTokenTTL);
+    return token;
+  }
+  async verifyAccessToken(authHeader) {
+    try {
+      const accessToken = this.extractAccessTokenValue(authHeader);
+      const user = _jsonwebtoken2.default.verify(accessToken, this.options.accessTokenKey);
+      if (!user) throw new NotAuthenticatedError();
+      const cachedToken = await this.retrieveAccessTokenFor(user.id);
+      if (accessToken && accessToken !== cachedToken) throw new AuthorizationExpired();
+      return user;
+    } catch (err) {
+      if (err instanceof AuthorizationExpired) throw err;
+      if (err instanceof _jsonwebtoken2.default.TokenExpiredError) throw new AuthorizationExpired(void 0, err);
+      else throw new NotAuthenticatedError(void 0, err);
+    }
+  }
+  async verifyRefreshToken(token) {
+    try {
+      const user = _jsonwebtoken2.default.verify(token, this.options.refreshTokenKey);
+      if (!user) throw new NotAuthenticatedError();
+      return user;
+    } catch (err) {
+      throw new NotAuthenticatedError(void 0, err);
+    }
+  }
+  async retrieveAccessTokenFor(userId) {
+    return Instance.get().cache.get(this.#getAccessTokenKey(userId));
+  }
+  async retrieveRefreshTokenFor(userId) {
+    return Instance.get().cache.get(this.#getRefreshTokenKey(userId));
+  }
+  async deleteAccessTokenFor(userId) {
+    await Instance.get().cache.delete(this.#getAccessTokenKey(userId));
+  }
+  async deleteRefreshTokenFor(userId) {
+    await Instance.get().cache.delete(this.#getRefreshTokenKey(userId));
+  }
+};
+
+// src/server/pipes.ts
+var serverPipe = _valleyed.v.object({
+  type: _valleyed.v.in(["fastify", "express"]),
+  port: _valleyed.v.number(),
+  publicPath: _valleyed.v.optional(_valleyed.v.string()),
+  healthPath: _valleyed.v.optional(_valleyed.v.string()),
+  openapi: _valleyed.v.defaults(
+    _valleyed.v.object({
+      docsVersion: _valleyed.v.defaults(_valleyed.v.string(), "1.0.0"),
+      docsBaseUrl: _valleyed.v.defaults(_valleyed.v.array(_valleyed.v.string()), ["/"]),
+      docsPath: _valleyed.v.defaults(_valleyed.v.string(), "/__docs")
+    }),
+    {}
+  ),
+  requests: _valleyed.v.defaults(
+    _valleyed.v.object({
+      log: _valleyed.v.defaults(_valleyed.v.boolean(), true),
+      paginationDefaultLimit: _valleyed.v.defaults(_valleyed.v.number(), 100),
+      maxFileUploadSizeInMb: _valleyed.v.defaults(_valleyed.v.number(), 500),
+      rateLimit: _valleyed.v.defaults(
+        _valleyed.v.object({
+          enabled: _valleyed.v.defaults(_valleyed.v.boolean(), false),
+          periodInMs: _valleyed.v.defaults(_valleyed.v.number(), 60 * 60 * 1e3),
+          limit: _valleyed.v.defaults(_valleyed.v.number(), 5e3)
+        }),
+        {}
+      ),
+      slowdown: _valleyed.v.defaults(
+        _valleyed.v.object({
+          enabled: _valleyed.v.defaults(_valleyed.v.boolean(), false),
+          periodInMs: _valleyed.v.defaults(_valleyed.v.number(), 10 * 60 * 1e3),
+          delayAfter: _valleyed.v.defaults(_valleyed.v.number(), 2e3),
+          delayInMs: _valleyed.v.defaults(_valleyed.v.number(), 500)
+        }),
+        {}
+      )
+    }),
+    {}
+  ),
+  requestsAuth: _valleyed.v.defaults(
+    _valleyed.v.object({
+      tokens: _valleyed.v.optional(_valleyed.v.instanceOf(BaseTokensUtility)),
+      apiKey: _valleyed.v.optional(_valleyed.v.instanceOf(BaseApiKeysUtility))
+    }),
+    {}
+  )
+});
+
+// src/errors/types/authorizationExpired.ts
+var AuthorizationExpired = (_class4 = class extends RequestError {
+  __init10() {this.statusCode = StatusCodes.AuthorizationExpired}
+  constructor(message = "Access token expired", cause) {
+    super(message, [{ message }], cause);_class4.prototype.__init10.call(this);;
+  }
+}, _class4);
+
+// src/errors/types/badRequestError.ts
+var BadRequestError = (_class5 = class extends RequestError {
+  __init11() {this.statusCode = StatusCodes.BadRequest}
+  constructor(message, cause) {
+    super(message, [{ message }], cause);_class5.prototype.__init11.call(this);;
+  }
+}, _class5);
+
+// src/errors/types/notAuthenticatedError.ts
+var NotAuthenticatedError = (_class6 = class extends RequestError {
+  __init12() {this.statusCode = StatusCodes.NotAuthenticated}
+  constructor(message = "Not authenticated", cause) {
+    super(message, [{ message }], cause);_class6.prototype.__init12.call(this);;
+  }
+}, _class6);
+
+// src/errors/types/notAuthorizedError.ts
+var NotAuthorizedError = (_class7 = class extends RequestError {
+  __init13() {this.statusCode = StatusCodes.NotAuthorized}
+  constructor(message = "Not authorized", cause) {
+    super(message, [{ message }], cause);_class7.prototype.__init13.call(this);;
+  }
+}, _class7);
+
+// src/errors/types/notFoundError.ts
+var NotFoundError = (_class8 = class extends RequestError {
+  __init14() {this.statusCode = StatusCodes.NotFound}
+  constructor(message = "Not found", cause) {
+    super(message, [{ message }], cause);_class8.prototype.__init14.call(this);;
+  }
+}, _class8);
+
+// src/errors/types/refreshTokenMisusedError.ts
+var RefreshTokenMisusedError = (_class9 = class extends RequestError {
+  __init15() {this.statusCode = StatusCodes.NotAuthenticated}
+  constructor(message = "Refresh token misused", cause) {
+    super(message, [{ message }], cause);_class9.prototype.__init15.call(this);;
+  }
+}, _class9);
+
+// src/errors/types/validationError.ts
+var ValidationError = (_class10 = class extends RequestError {
+  __init16() {this.statusCode = StatusCodes.ValidationError}
+  constructor(errors, cause) {
+    super(
+      "Unprocessable Entity",
+      errors.flatMap(({ field, messages }) => messages.map((message) => ({ message, field }))),
+      cause
+    );_class10.prototype.__init16.call(this);;
+  }
+}, _class10);
+
+// src/cache/types/redis.ts
+var RedisCache = class extends Cache {
+  
+  constructor(settings, extraConfig) {
+    super();
+    const node = {
+      ...settings.host ? { host: settings.host } : {},
+      ...settings.port ? { port: settings.port } : {}
+    };
+    const common = {
+      ...extraConfig,
+      ...settings.password ? { password: settings.password } : {},
+      ...settings.username ? { username: settings.username } : {},
+      ...settings.tls ? { tls: {} } : {},
+      lazyConnect: true
+    };
+    this.client = settings.cluster ? new (0, _ioredis.Cluster)([node], {
+      ...extraConfig,
+      redisOptions: common,
+      lazyConnect: true
+    }) : new (0, _ioredis.Redis)({ ...common, ...node });
+    this.client.on("error", async (error) => {
+      Instance.crash(new EquippedError(`Redis failed with error`, {}, error));
+    });
+    if (!extraConfig) Instance.on("start", async () => this.client.connect(), 1);
+    Instance.on("close", async () => this.client.quit(), 1);
+  }
+  async delete(key) {
+    await this.client.del(Instance.get().getScopedName(key, ":"));
+  }
+  async get(key) {
+    return await this.client.get(Instance.get().getScopedName(key, ":"));
+  }
+  async set(key, data, ttlInSecs) {
+    if (ttlInSecs > 0) await this.client.setex(Instance.get().getScopedName(key, ":"), ttlInSecs, data);
+    else this.client.set(Instance.get().getScopedName(key), data);
+  }
+  async getOrSet(key, fn, ttlInSecs) {
+    const cached = await this.get(Instance.get().getScopedName(key, ":"));
+    if (cached) return JSON.parse(cached);
+    const result = await fn();
+    await this.set(Instance.get().getScopedName(key, ":"), JSON.stringify(result), ttlInSecs);
+  }
+};
+
+// src/dbs/base/_instance.ts
+
+var TopicPrefix = "db-changes";
+var Db = class {
+  constructor(config) {
+    this.config = config;
+  }
+  getScopedDb(db) {
+    return Instance.get().getScopedName(db).replaceAll(".", "-");
+  }
+};
+var DbChange = class {
+  constructor(config, callbacks, mapper) {
+    this.config = config;
+    this.#callbacks = callbacks;
+    this.#mapper = mapper;
+  }
+  #callbacks = {};
+  #mapper;
+  get callbacks() {
+    return Object.freeze(this.#callbacks);
+  }
+  get mapper() {
+    return this.#mapper;
+  }
+  async configureConnector(key, data) {
+    const instance = _axios2.default.create({ baseURL: this.config.debeziumUrl });
+    return await instance.put(`/connectors/${key}/config`, {
+      "topic.prefix": TopicPrefix,
+      "topic.creation.enable": "false",
+      "topic.creation.default.replication.factor": `-1`,
+      "topic.creation.default.partitions": "-1",
+      "key.converter": "org.apache.kafka.connect.json.JsonConverter",
+      "key.converter.schemas.enable": "false",
+      "value.converter": "org.apache.kafka.connect.json.JsonConverter",
+      "value.converter.schemas.enable": "false",
+      ...data
+    }).then(async () => {
+      const topics = await instance.get(`/connectors/${key}/topics`);
+      return _nullishCoalesce(_optionalChain([topics, 'access', _87 => _87.data, 'access', _88 => _88[key], 'optionalAccess', _89 => _89.topics, 'optionalAccess', _90 => _90.includes, 'optionalCall', _91 => _91(key)]), () => ( false));
+    }).catch((err) => {
+      throw new EquippedError(`Failed to configure watcher`, { key }, err);
+    });
+  }
+};
+
+// src/dbs/mongo/changes.ts
+var _mongodb = require('mongodb');
+
+var MongoDbChange = class extends DbChange {
+  #started = false;
+  constructor(config, change, client, dbName, colName, callbacks, mapper) {
+    super(change, callbacks, mapper);
+    const hydrate = (data) => data._id ? {
+      ...data,
+      _id: makeId(_nullishCoalesce(data._id["$oid"], () => ( data._id)))
+    } : void 0;
+    const dbColName = `${dbName}.${colName}`;
+    const topic = `${TopicPrefix}.${dbColName}`;
+    const hexId = "5f5f65717569707065645f5f";
+    const TestId = makeId(hexId);
+    const condition = { _id: TestId };
+    change.eventBus.createSubscriber(
+      topic,
+      async (data) => {
+        const op = data.op;
+        let before = JSON.parse(_nullishCoalesce(data.before, () => ( "null")));
+        let after = JSON.parse(_nullishCoalesce(data.after, () => ( "null")));
+        if (before) before = hydrate(before);
+        if (after) after = hydrate(after);
+        if (_optionalChain([before, 'optionalAccess', _92 => _92.__id]) === TestId || _optionalChain([after, 'optionalAccess', _93 => _93.__id]) === TestId) return;
+        if (op === "c" && this.callbacks.created && after)
+          await this.callbacks.created({
+            before: null,
+            after: this.mapper(after)
+          });
+        else if (op === "u" && this.callbacks.updated && before && after)
+          await this.callbacks.updated({
+            before: this.mapper(before),
+            after: this.mapper(after),
+            changes: _valleyed.differ.from(_valleyed.differ.diff(before, after))
+          });
+        else if (op === "d" && this.callbacks.deleted && before)
+          await this.callbacks.deleted({
+            before: this.mapper(before),
+            after: null
+          });
+      },
+      { skipScope: true }
+    );
+    Instance.on(
+      "start",
+      async () => {
+        if (this.#started) return;
+        this.#started = true;
+        const collection = client.db(dbName).collection(colName);
+        await retry(
+          async () => {
+            const started = await this.configureConnector(topic, {
+              "connector.class": "io.debezium.connector.mongodb.MongoDbConnector",
+              "capture.mode": "change_streams_update_full_with_pre_image",
+              "mongodb.connection.string": config.uri,
+              "collection.include.list": dbColName,
+              "snapshot.mode": "when_needed"
+            });
+            if (started) return { done: true, value: true };
+            await collection.findOneAndUpdate(condition, { $set: { colName } }, { upsert: true });
+            await collection.findOneAndDelete(condition);
+            Instance.get().log.warn(`Waiting for db changes for ${dbColName} to start...`);
+            return { done: false };
+          },
+          6,
+          1e4
+        ).catch((err) => Instance.crash(new EquippedError(`Failed to start db changes`, { dbColName }, err)));
+      },
+      10
+    );
+  }
+};
+var makeId = (id) => {
+  try {
+    return new (0, _mongodb.ObjectId)(id);
+  } catch (e4) {
+    return id;
+  }
+};
+
+// src/dbs/mongo/index.ts
+
+
+// src/dbs/mongo/api.ts
+
+
+// src/dbs/pipes.ts
+
+var QueryKeys = /* @__PURE__ */ ((QueryKeys2) => {
+  QueryKeys2["and"] = "and";
+  QueryKeys2["or"] = "or";
+  return QueryKeys2;
+})(QueryKeys || {});
+var Conditions = /* @__PURE__ */ ((Conditions2) => {
+  Conditions2["lt"] = "lt";
+  Conditions2["lte"] = "lte";
+  Conditions2["gt"] = "gt";
+  Conditions2["gte"] = "gte";
+  Conditions2["eq"] = "eq";
+  Conditions2["ne"] = "ne";
+  Conditions2["in"] = "in";
+  Conditions2["nin"] = "nin";
+  Conditions2["exists"] = "exists";
+  return Conditions2;
+})(Conditions || {});
+var queryKeys = _valleyed.v.catch(_valleyed.v.defaults(_valleyed.v.in(["and" /* and */, "or" /* or */]), "and" /* and */), "and" /* and */);
+var queryWhere = _valleyed.v.object({
+  field: _valleyed.v.string(),
+  value: _valleyed.v.any(),
+  condition: _valleyed.v.catch(_valleyed.v.defaults(_valleyed.v.in(Object.values(Conditions)), "eq" /* eq */), "eq" /* eq */)
+});
+var queryWhereBlock = _valleyed.v.object({
+  condition: queryKeys,
+  value: _valleyed.v.array(queryWhere)
+});
+var queryWhereClause = _valleyed.v.defaults(_valleyed.v.array(_valleyed.v.or([queryWhere, queryWhereBlock])), []);
+function queryParamsPipe() {
+  const pagLimit = _nullishCoalesce(_optionalChain([Instance, 'access', _94 => _94.get, 'call', _95 => _95(), 'access', _96 => _96.settings, 'access', _97 => _97.server, 'optionalAccess', _98 => _98.requests, 'access', _99 => _99.paginationDefaultLimit]), () => ( 100));
+  return _valleyed.v.meta(
+    _valleyed.v.object({
+      all: _valleyed.v.defaults(_valleyed.v.boolean(), false),
+      limit: _valleyed.v.catch(_valleyed.v.defaults(_valleyed.v.number().pipe(_valleyed.v.lte(pagLimit)), pagLimit), pagLimit),
+      page: _valleyed.v.catch(_valleyed.v.defaults(_valleyed.v.number().pipe(_valleyed.v.gte(1)), 1), 1),
+      search: _valleyed.v.defaults(
+        _valleyed.v.nullish(
+          _valleyed.v.object({
+            value: _valleyed.v.string(),
+            fields: _valleyed.v.array(_valleyed.v.string())
+          })
+        ),
+        null
+      ),
+      sort: _valleyed.v.defaults(
+        _valleyed.v.array(
+          _valleyed.v.object({
+            field: _valleyed.v.string(),
+            desc: _valleyed.v.defaults(_valleyed.v.boolean(), false)
+          })
+        ),
+        []
+      ),
+      whereType: queryKeys,
+      where: queryWhereClause
+    }).pipe((p) => ({ ...p, auth: [], authType: "and" /* and */ })),
+    { title: "Query Params", $refId: "QueryParams" }
+  );
+}
+function queryResultsPipe(model) {
+  return _valleyed.v.object({
+    pages: _valleyed.v.object({
+      current: _valleyed.v.number(),
+      start: _valleyed.v.number(),
+      last: _valleyed.v.number(),
+      previous: _valleyed.v.nullable(_valleyed.v.number()),
+      next: _valleyed.v.nullable(_valleyed.v.number())
+    }),
+    docs: _valleyed.v.object({
+      limit: _valleyed.v.number(),
+      total: _valleyed.v.number(),
+      count: _valleyed.v.number()
+    }),
+    results: _valleyed.v.array(model)
+  });
+}
+function wrapQueryParams(params) {
+  return _valleyed.v.assert(queryParamsPipe(), params);
+}
+var mongoDbConfigPipe = _valleyed.v.meta(
+  _valleyed.v.object({
+    uri: _valleyed.v.string()
+  }),
+  { title: "Mongodb Config", $refId: "MongodbConfig" }
+);
+
+// src/dbs/mongo/query.ts
+var parseMongodbQueryParams = async (collection, params) => {
+  const query = [];
+  const where = buildWhereQuery(params.where, params.whereType);
+  if (where) query.push(where);
+  const auth = buildWhereQuery(params.auth, params.authType);
+  if (auth) query.push(auth);
+  if (params.search && params.search.fields.length > 0) {
+    const search = params.search.fields.map((field) => ({
+      [field]: {
+        $regex: new RegExp(params.search.value, "i")
+      }
+    }));
+    query.push({ $or: search });
+  }
+  const totalClause = {};
+  if (query.length > 0) totalClause["$and"] = query;
+  const sort = params.sort.map((p) => [p.field, p.desc ? "desc" : "asc"]);
+  const all = _nullishCoalesce(params.all, () => ( false));
+  const limit = params.limit;
+  const page = params.page;
+  const total = await collection.countDocuments(totalClause);
+  let builtQuery = collection.find(totalClause);
+  if (sort.length) builtQuery = builtQuery.sort(Object.fromEntries(sort));
+  if (!all && limit) {
+    builtQuery = builtQuery.limit(limit);
+    if (page) builtQuery = builtQuery.skip((page - 1) * limit);
+  }
+  const results = await builtQuery.toArray();
+  const start = 1;
+  const last = Math.ceil(total / limit) || 1;
+  const next = page >= last ? null : page + 1;
+  const previous = page <= start ? null : page - 1;
+  return {
+    pages: { start, last, next, previous, current: page },
+    docs: { limit, total, count: results.length },
+    results
+  };
+};
+function isWhereBlock(param) {
+  return Object.values(QueryKeys).includes(param.condition);
+}
+var buildWhereQuery = (params, key = "and" /* and */) => {
+  const where = (Array.isArray(params) ? params : []).map((param) => {
+    if (isWhereBlock(param)) return buildWhereQuery(param.value, param.condition);
+    const { field } = param;
+    const checkedField = field === "id" ? "_id" : _nullishCoalesce(field, () => ( ""));
+    const checkedValue = param.value === void 0 ? "" : param.value;
+    return {
+      field: checkedField,
+      value: checkedValue,
+      condition: param.condition,
+      isWhere: true
+    };
+  }).filter((c) => !!c).map((c) => {
+    if (c.isWhere) return { [`${c.field}`]: { [`$${c.condition}`]: c.value } };
+    else return c;
+  });
+  return where.length > 0 ? { [`$${key}`]: where } : null;
+};
+
+// src/dbs/mongo/api.ts
+var idKey = "_id";
+function getTable(config, collection) {
+  async function transform(doc) {
+    const docs = Array.isArray(doc) ? doc : [doc];
+    const mapped = docs.map((d) => config.mapper(d));
+    return Array.isArray(doc) ? mapped : mapped[0];
+  }
+  function prepInsertValue(value, id, now, skipUpdate) {
+    const base = {
+      [idKey]: id,
+      ..._optionalChain([config, 'access', _100 => _100.options, 'optionalAccess', _101 => _101.skipAudit]) ? {} : {
+        createdAt: now.getTime(),
+        ...skipUpdate ? {} : { updatedAt: now.getTime() }
+      }
+    };
+    return {
+      ...value,
+      ...base
+    };
+  }
+  function prepUpdateValue(value, now) {
+    return {
+      ...value,
+      $set: {
+        ...value.$set,
+        ...Object.keys(value).length > 0 && !_optionalChain([config, 'access', _102 => _102.options, 'optionalAccess', _103 => _103.skipAudit]) ? {
+          updatedAt: now.getTime()
+        } : {}
+      }
+    };
+  }
+  const table = {
+    config,
+    extras: { collection },
+    query: async (params) => {
+      const results = await parseMongodbQueryParams(collection, params);
+      return {
+        ...results,
+        results: await transform(results.results)
+      };
+    },
+    findMany: async (filter, options = {}) => {
+      const sortArray = Array.isArray(options.sort) ? options.sort : options.sort ? [options.sort] : [];
+      const sort = sortArray.map((p) => [p.field, p.desc ? "desc" : "asc"]);
+      const docs = await collection.find(filter, {
+        session: options.session,
+        limit: options.limit,
+        sort
+      }).toArray();
+      return transform(docs);
+    },
+    findOne: async (filter, options = {}) => {
+      const result = await table.findMany(filter, { ...options, limit: 1 });
+      return _nullishCoalesce(result.at(0), () => ( null));
+    },
+    findById: async (id, options = {}) => {
+      const result = await table.findOne({ [idKey]: id }, options);
+      return result;
+    },
+    insertMany: async (values, options = {}) => {
+      const now = _nullishCoalesce(_optionalChain([options, 'access', _104 => _104.getTime, 'optionalCall', _105 => _105()]), () => ( /* @__PURE__ */ new Date()));
+      const payload = values.map((value, i) => prepInsertValue(value, _nullishCoalesce(_optionalChain([options, 'access', _106 => _106.makeId, 'optionalCall', _107 => _107(i)]), () => ( new (0, _mongodb.ObjectId)().toString())), now));
+      await collection.insertMany(payload, { session: options.session });
+      const insertedData = await Promise.all(payload.map(async (data) => await table.findById(data[idKey], options)));
+      return insertedData.filter((value) => !!value);
+    },
+    insertOne: async (values, options = {}) => {
+      const result = await table.insertMany([values], options);
+      return result[0];
+    },
+    updateMany: async (filter, values, options = {}) => {
+      const now = _nullishCoalesce(_optionalChain([options, 'access', _108 => _108.getTime, 'optionalCall', _109 => _109()]), () => ( /* @__PURE__ */ new Date()));
+      await collection.updateMany(filter, prepUpdateValue(values, now), { session: options.session });
+      return table.findMany(filter, options);
+    },
+    updateOne: async (filter, values, options = {}) => {
+      const now = _nullishCoalesce(_optionalChain([options, 'access', _110 => _110.getTime, 'optionalCall', _111 => _111()]), () => ( /* @__PURE__ */ new Date()));
+      const doc = await collection.findOneAndUpdate(filter, prepUpdateValue(values, now), {
+        returnDocument: "after",
+        session: options.session
+      });
+      return doc ? transform(doc) : null;
+    },
+    updateById: async (id, values, options = {}) => {
+      const result = await table.updateOne({ [idKey]: id }, values, options);
+      return result;
+    },
+    upsertOne: async (filter, values, options = {}) => {
+      const now = _nullishCoalesce(_optionalChain([options, 'access', _112 => _112.getTime, 'optionalCall', _113 => _113()]), () => ( /* @__PURE__ */ new Date()));
+      const doc = await collection.findOneAndUpdate(
+        filter,
+        {
+          ...prepUpdateValue("update" in values ? values.update : {}, now),
+          // @ts-expect-error fighting ts
+          $setOnInsert: prepInsertValue(values.insert, _nullishCoalesce(_optionalChain([options, 'access', _114 => _114.makeId, 'optionalCall', _115 => _115()]), () => ( new (0, _mongodb.ObjectId)().toString())), now, true)
+        },
+        { returnDocument: "after", session: options.session, upsert: true }
+      );
+      return transform(doc);
+    },
+    deleteMany: async (filter, options = {}) => {
+      const docs = await table.findMany(filter, options);
+      await collection.deleteMany(filter, { session: options.session });
+      return docs;
+    },
+    deleteOne: async (filter, options) => {
+      const doc = await collection.findOneAndDelete(filter, { session: _optionalChain([options, 'optionalAccess', _116 => _116.session]) });
+      return doc ? transform(doc) : null;
+    },
+    deleteById: async (id, options) => {
+      const result = await table.deleteOne({ [idKey]: id }, options);
+      return result;
+    },
+    bulkWrite: async (operations, options = {}) => {
+      const bulk = collection.initializeUnorderedBulkOp({ session: options.session });
+      const now = _nullishCoalesce(_optionalChain([options, 'access', _117 => _117.getTime, 'optionalCall', _118 => _118()]), () => ( /* @__PURE__ */ new Date()));
+      operations.forEach((operation, i) => {
+        switch (operation.op) {
+          case "insert":
+            bulk.insert(prepInsertValue(operation.value, _nullishCoalesce(_optionalChain([operation, 'access', _119 => _119.makeId, 'optionalCall', _120 => _120(i)]), () => ( new (0, _mongodb.ObjectId)().toString())), now));
+            break;
+          case "delete":
+            bulk.find(operation.filter).delete();
+            break;
+          case "update":
+            bulk.find(operation.filter).update(prepUpdateValue(operation.value, now));
+            break;
+          case "upsert":
+            bulk.find(operation.filter).upsert().update({
+              ...prepUpdateValue("update" in operation ? operation.update : {}, now),
+              $setOnInsert: prepInsertValue(
+                operation.insert,
+                _nullishCoalesce(_optionalChain([operation, 'access', _121 => _121.makeId, 'optionalCall', _122 => _122(i)]), () => ( new (0, _mongodb.ObjectId)().toString())),
+                now,
+                true
+              )
+            });
+            break;
+          default:
+            throw new EquippedError(`Unknown bulkWrite operation`, { operation });
+        }
+      });
+      await bulk.execute({ session: options.session });
+    }
+  };
+  return table;
+}
+
+// src/dbs/mongo/index.ts
+var MongoDb = class extends Db {
+  constructor(mongoConfig, dbConfig) {
+    super(dbConfig);
+    this.mongoConfig = mongoConfig;
+    this.#client = new (0, _mongodb.MongoClient)(mongoConfig.uri);
+    Instance.on(
+      "start",
+      async () => {
+        await this.#client.connect();
+        const grouped = this.#cols.reduce((acc, cur) => {
+          if (!acc[cur.db]) acc[cur.db] = [];
+          acc[cur.db].push(cur.col);
+          return acc;
+        }, {});
+        const options = {
+          changeStreamPreAndPostImages: { enabled: true }
+        };
+        await Promise.all(
+          Object.entries(grouped).map(async ([dbName, colNames]) => {
+            const db = this.#client.db(dbName);
+            const collections = await db.listCollections().toArray();
+            return colNames.map(async (colName) => {
+              const existing = collections.find((collection) => collection.name === colName);
+              if (existing) {
+                if (_optionalChain([existing, 'access', _123 => _123.options, 'optionalAccess', _124 => _124.changeStreamPreAndPostImages, 'optionalAccess', _125 => _125.enabled]) !== options.changeStreamPreAndPostImages.enabled)
+                  await db.command({ collMod: colName, ...options });
+              } else await db.createCollection(colName, options);
+            });
+          })
+        );
+      },
+      3
+    );
+    Instance.on("close", async () => this.#client.close(), 1);
+  }
+  #client;
+  #cols = [];
+  async session(callback) {
+    return this.#client.withSession(callback);
+  }
+  id() {
+    return new (0, _mongodb.ObjectId)();
+  }
+  use(config) {
+    if (config.change) {
+      if (!this.config.changes) Instance.crash(new EquippedError("Db changes are not enabled in the configuration.", { config }));
+      new MongoDbChange(
+        this.mongoConfig,
+        this.config.changes,
+        this.#client,
+        this.getScopedDb(config.db),
+        config.col,
+        config.change,
+        config.mapper
+      );
+    }
+    this.#cols.push({ db: this.getScopedDb(config.db), col: config.col });
+    const collection = this.#client.db(this.getScopedDb(config.db)).collection(config.col);
+    return getTable(config, collection);
+  }
+};
+
+// src/events/base.ts
+var EventBus = class {
+};
+var DefaultSubscribeOptions = {
+  fanout: false
+};
+
+// src/events/pipes.ts
+
+var rabbitmqConfigPipe = _valleyed.v.meta(
+  _valleyed.v.object({
+    uri: _valleyed.v.string(),
+    eventColumnName: _valleyed.v.string()
+  }),
+  { title: "Rabbitmq Config", $refId: "RabbitmqConfig" }
+);
+var kafkaConfigPipe = _valleyed.v.meta(
+  _valleyed.v.object({
+    brokers: _valleyed.v.array(_valleyed.v.string()),
+    ssl: _valleyed.v.optional(_valleyed.v.boolean()),
+    sasl: _valleyed.v.optional(
+      _valleyed.v.object({
+        mechanism: _valleyed.v.is("plain"),
+        username: _valleyed.v.string(),
+        password: _valleyed.v.string()
+      })
+    ),
+    confluent: _valleyed.v.optional(_valleyed.v.boolean()),
+    clientId: _valleyed.v.optional(_valleyed.v.string())
+  }),
+  { title: "Kafka Config", $refId: "KafkaConfig" }
+);
+
+// src/events/types/kafka.ts
+var _kafkajavascript = require('@confluentinc/kafka-javascript'); var _kafkajavascript2 = _interopRequireDefault(_kafkajavascript);
+var _kafkajs = require('kafkajs'); var _kafkajs2 = _interopRequireDefault(_kafkajs);
+var KafkaEventBus = class extends EventBus {
+  #client;
+  #confluent;
+  #admin;
+  constructor(config) {
+    super();
+    const { confluent = false, ...kafkaSettings } = config;
+    this.#confluent = confluent;
+    this.#client = confluent ? new _kafkajavascript2.default.KafkaJS.Kafka({
+      kafkaJS: { ...kafkaSettings, logLevel: _kafkajavascript2.default.KafkaJS.logLevel.NOTHING }
+    }) : new _kafkajs2.default.Kafka({ ...kafkaSettings, logLevel: _kafkajs2.default.logLevel.NOTHING });
+  }
+  createPublisher(topicName, options = {}) {
+    const topic = options.skipScope ? topicName : Instance.get().getScopedName(topicName);
+    return async (data) => {
+      try {
+        const producer = this.#client.producer();
+        await producer.connect();
+        await producer.send({
+          topic,
+          messages: [{ value: JSON.stringify(data) }]
+        });
+        return true;
+      } catch (e5) {
+        return false;
+      }
+    };
+  }
+  createSubscriber(topicName, onMessage, options = {}) {
+    options = { ...DefaultSubscribeOptions, ...options };
+    const topic = options.skipScope ? topicName : Instance.get().getScopedName(topicName);
+    const subscribe = async () => {
+      await this.#createTopic(topic);
+      const groupId = options.fanout ? Instance.get().getScopedName(`${Instance.get().settings.app.id}-fanout-${random_exports.string(10)}`) : topic;
+      const consumer = this.#client.consumer(this.#confluent ? { kafkaJS: { groupId } } : { groupId });
+      await consumer.connect();
+      await consumer.subscribe({ topic });
+      await consumer.run({
+        eachMessage: async ({ message }) => {
+          Instance.resolveBeforeCrash(async () => {
+            if (!message.value) return;
+            await onMessage(parseJSONValue(message.value.toString()));
+          });
+        }
+      });
+      if (options.fanout)
+        Instance.on(
+          "close",
+          async () => {
+            await consumer.disconnect();
+            await this.#deleteGroup(groupId);
+          },
+          10
+        );
+    };
+    Instance.on("start", subscribe, 2);
+  }
+  async #getAdmin() {
+    if (!this.#admin) {
+      this.#admin = this.#client.admin();
+      await this.#admin.connect();
+    }
+    return this.#admin;
+  }
+  async #createTopic(topic) {
+    const admin = await this.#getAdmin();
+    await admin.createTopics({ topics: [{ topic }], timeout: 5e3 });
+  }
+  async #deleteGroup(groupId) {
+    const admin = await this.#getAdmin();
+    await admin.deleteGroups([groupId]).catch(() => {
+    });
+  }
+};
+
+// src/events/types/rabbitmq.ts
+var _amqpconnectionmanager = require('amqp-connection-manager');
+var RabbitMQEventBus = class extends EventBus {
+  #client;
+  #columnName;
+  constructor(config) {
+    super();
+    this.#columnName = config.eventColumnName;
+    this.#client = _amqpconnectionmanager.connect.call(void 0, [config.uri]).createChannel({
+      json: false,
+      setup: async (channel) => {
+        await channel.assertExchange(this.#columnName, "direct", { durable: true });
+        await channel.prefetch(1);
+      }
+    });
+  }
+  createPublisher(topicName, options = {}) {
+    const topic = options.skipScope ? topicName : Instance.get().getScopedName(topicName);
+    return async (data) => await this.#client.publish(this.#columnName, topic, JSON.stringify(data), { persistent: true });
+  }
+  createSubscriber(topicName, onMessage, options = {}) {
+    options = { ...DefaultSubscribeOptions, ...options };
+    const topic = options.skipScope ? topicName : Instance.get().getScopedName(topicName);
+    const subscribe = async () => {
+      await this.#client.addSetup(async (channel) => {
+        const queueName = options.fanout ? Instance.get().getScopedName(`${Instance.get().settings.app.id}-fanout-${random_exports.string(10)}`) : topic;
+        const { queue } = await channel.assertQueue(queueName, { durable: !options.fanout, exclusive: options.fanout });
+        await channel.bindQueue(queue, this.#columnName, topic);
+        channel.consume(
+          queue,
+          async (msg) => {
+            Instance.resolveBeforeCrash(async () => {
+              if (!msg) return;
+              try {
+                await onMessage(parseJSONValue(msg.content.toString()));
+                channel.ack(msg);
+              } catch (e6) {
+                channel.nack(msg);
+              }
+            });
+          },
+          { noAck: false }
+        );
+      });
+    };
+    Instance.on("start", subscribe, 2);
+  }
+};
+
+// src/jobs/pipes.ts
+
+var redisJobsConfigPipe = _valleyed.v.meta(
+  _valleyed.v.object({
+    redisConfig: redisConfigPipe,
+    queueName: _valleyed.v.string()
+  }),
+  { title: "Redis Jobs Config", $refId: "RedisJobsConfig" }
+);
+
+// src/jobs/types/redis.ts
+var _bull = require('bull'); var _bull2 = _interopRequireDefault(_bull);
+var RedisJob = class _RedisJob {
+  #queue;
+  #callbacks = {};
+  #crons = [];
+  constructor(config) {
+    const redisCache = new RedisCache(config.redisConfig, {
+      maxRetriesPerRequest: null,
+      enableReadyCheck: false
+    });
+    this.#queue = new (0, _bull2.default)(config.queueName, { createClient: () => redisCache.client });
+    Instance.on(
+      "start",
+      async () => {
+        await this.#cleanup();
+        await Promise.all(this.#crons.map(({ cron, name }) => this.#addCron(name, cron)));
+        Promise.all([
+          this.#queue.process("DelayedJob" /* DelayedJob */, async (job) => await _optionalChain([this, 'access', _126 => _126.#callbacks, 'access', _127 => _127.onDelayed, 'optionalCall', _128 => _128(job.data)])),
+          this.#queue.process("CronJob" /* CronJob */, async (job) => await _optionalChain([this, 'access', _129 => _129.#callbacks, 'access', _130 => _130.onCron, 'optionalCall', _131 => _131(job.data.type)])),
+          this.#queue.process("RepeatableJob" /* RepeatableJob */, async (job) => await _optionalChain([this, 'access', _132 => _132.#callbacks, 'access', _133 => _133.onRepeatable, 'optionalCall', _134 => _134(job.data)]))
+        ]);
+      },
+      10
+    );
+  }
+  set callbacks(callbacks) {
+    this.#callbacks = callbacks;
+  }
+  set crons(crons) {
+    this.#crons = crons;
+  }
+  static #getNewId() {
+    return [Date.now(), random_exports.string()].join(":");
+  }
+  async addDelayed(data, delayInMs) {
+    const job = await this.#queue.add("DelayedJob" /* DelayedJob */, data, {
+      jobId: _RedisJob.#getNewId(),
+      delay: delayInMs,
+      removeOnComplete: true,
+      backoff: 1e3,
+      attempts: 3
+    });
+    return job.id.toString();
+  }
+  async addRepeatable(data, cron, tz) {
+    const job = await this.#queue.add("RepeatableJob" /* RepeatableJob */, data, {
+      jobId: _RedisJob.#getNewId(),
+      repeat: { cron, ...tz ? { tz } : {} },
+      removeOnComplete: true,
+      backoff: 1e3,
+      attempts: 3
+    });
+    return _nullishCoalesce(_optionalChain([job, 'access', _135 => _135.opts, 'optionalAccess', _136 => _136.repeat, 'optionalAccess', _137 => _137.key]), () => ( ""));
+  }
+  async removeDelayed(jobId) {
+    const job = await this.#queue.getJob(jobId);
+    if (job) await job.discard();
+  }
+  async removeRepeatable(jobKey) {
+    await this.#queue.removeRepeatableByKey(jobKey);
+  }
+  async retryAllFailedJobs() {
+    const failedJobs = await this.#queue.getFailed();
+    await Promise.all(failedJobs.map((job) => job.retry()));
+  }
+  async #addCron(type, cron) {
+    const job = await this.#queue.add(
+      "CronJob" /* CronJob */,
+      { type },
+      {
+        jobId: _RedisJob.#getNewId(),
+        repeat: { cron },
+        removeOnComplete: true,
+        backoff: 1e3,
+        attempts: 3
+      }
+    );
+    return job.id.toString();
+  }
+  async #cleanup() {
+    await this.retryAllFailedJobs();
+    const repeatableJobs = await this.#queue.getRepeatableJobs();
+    await Promise.all(
+      repeatableJobs.filter((job) => job.name === "CronJob" /* CronJob */).map((job) => this.#queue.removeRepeatableByKey(job.key))
+    );
+  }
+};
+
+// src/instance/settings.ts
+var instanceSettingsPipe = () => _valleyed.v.object({
+  app: _valleyed.v.object({
+    id: _valleyed.v.string(),
+    name: _valleyed.v.string()
+  }),
+  log: _valleyed.v.defaults(
+    _valleyed.v.object({
+      level: _valleyed.v.defaults(_valleyed.v.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
+    }),
+    {}
+  ),
+  dbs: _valleyed.v.optional(
+    _valleyed.v.object({
+      types: _valleyed.v.record(
+        _valleyed.v.string(),
+        _valleyed.v.discriminate((e) => _optionalChain([e, 'optionalAccess', _138 => _138.type]), {
+          mongo: _valleyed.v.merge(mongoDbConfigPipe, _valleyed.v.object({ type: _valleyed.v.is("mongo") }))
+        })
+      ),
+      changes: _valleyed.v.optional(
+        _valleyed.v.object({
+          debeziumUrl: _valleyed.v.string(),
+          kafkaConfig: kafkaConfigPipe
+        })
+      )
+    })
+  ),
+  eventBus: _valleyed.v.optional(
+    _valleyed.v.discriminate((e) => _optionalChain([e, 'optionalAccess', _139 => _139.type]), {
+      kafka: _valleyed.v.merge(kafkaConfigPipe, _valleyed.v.object({ type: _valleyed.v.is("kafka") })),
+      rabbitmq: _valleyed.v.merge(rabbitmqConfigPipe, _valleyed.v.object({ type: _valleyed.v.is("rabbitmq") }))
+    })
+  ),
+  cache: _valleyed.v.discriminate((e) => _optionalChain([e, 'optionalAccess', _140 => _140.type]), {
+    redis: _valleyed.v.merge(redisConfigPipe, _valleyed.v.object({ type: _valleyed.v.is("redis") }))
+  }),
+  jobs: _valleyed.v.optional(_valleyed.v.merge(redisJobsConfigPipe, _valleyed.v.object({ type: _valleyed.v.is("redis") }))),
+  server: _valleyed.v.optional(
+    _valleyed.v.object({
+      type: _valleyed.v.in(["fastify", "express"]),
+      port: _valleyed.v.number(),
+      publicPath: _valleyed.v.optional(_valleyed.v.string()),
+      healthPath: _valleyed.v.optional(_valleyed.v.string()),
+      openapi: _valleyed.v.defaults(
+        _valleyed.v.object({
+          docsVersion: _valleyed.v.defaults(_valleyed.v.string(), "1.0.0"),
+          docsBaseUrl: _valleyed.v.defaults(_valleyed.v.array(_valleyed.v.string()), ["/"]),
+          docsPath: _valleyed.v.defaults(_valleyed.v.string(), "/__docs")
+        }),
+        {}
+      ),
+      requests: _valleyed.v.defaults(
+        _valleyed.v.object({
+          log: _valleyed.v.defaults(_valleyed.v.boolean(), true),
+          paginationDefaultLimit: _valleyed.v.defaults(_valleyed.v.number(), 100),
+          maxFileUploadSizeInMb: _valleyed.v.defaults(_valleyed.v.number(), 500),
+          rateLimit: _valleyed.v.defaults(
+            _valleyed.v.object({
+              enabled: _valleyed.v.defaults(_valleyed.v.boolean(), false),
+              periodInMs: _valleyed.v.defaults(_valleyed.v.number(), 60 * 60 * 1e3),
+              limit: _valleyed.v.defaults(_valleyed.v.number(), 5e3)
+            }),
+            {}
+          ),
+          slowdown: _valleyed.v.defaults(
+            _valleyed.v.object({
+              enabled: _valleyed.v.defaults(_valleyed.v.boolean(), false),
+              periodInMs: _valleyed.v.defaults(_valleyed.v.number(), 10 * 60 * 1e3),
+              delayAfter: _valleyed.v.defaults(_valleyed.v.number(), 2e3),
+              delayInMs: _valleyed.v.defaults(_valleyed.v.number(), 500)
+            }),
+            {}
+          )
+        }),
+        {}
+      ),
+      requestsAuth: _valleyed.v.defaults(
+        _valleyed.v.object({
+          tokens: _valleyed.v.optional(_valleyed.v.instanceOf(BaseTokensUtility)),
+          apiKey: _valleyed.v.optional(_valleyed.v.instanceOf(BaseApiKeysUtility))
+        }),
+        {}
+      )
+    })
+  ),
+  utils: _valleyed.v.defaults(
+    _valleyed.v.object({
+      hashSaltRounds: _valleyed.v.defaults(_valleyed.v.number(), 10)
+    }),
+    {}
+  )
+});
+function mapSettingsToInstance(settings) {
+  const log = _pino2.default.call(void 0, {
+    level: settings.log.level,
+    serializers: {
+      err: _pino2.default.stdSerializers.err,
+      error: _pino2.default.stdSerializers.err,
+      req: _pino2.default.stdSerializers.req,
+      res: _pino2.default.stdSerializers.res
+    }
+  });
+  const cache = new RedisCache(settings.cache);
+  const jobs = settings.jobs ? new RedisJob(settings.jobs) : void 0;
+  const eventBus = _optionalChain([settings, 'access', _141 => _141.eventBus, 'optionalAccess', _142 => _142.type]) === "kafka" ? new KafkaEventBus(deleteKeys(settings.eventBus, ["type"])) : _optionalChain([settings, 'access', _143 => _143.eventBus, 'optionalAccess', _144 => _144.type]) === "rabbitmq" ? new RabbitMQEventBus(deleteKeys(settings.eventBus, ["type"])) : void 0;
+  const serverConfig = {
+    app: settings.app,
+    log,
+    eventBus
+  };
+  const server = _optionalChain([settings, 'access', _145 => _145.server, 'optionalAccess', _146 => _146.type]) === "express" ? new ExpressServer({ ...serverConfig, config: settings.server }) : _optionalChain([settings, 'access', _147 => _147.server, 'optionalAccess', _148 => _148.type]) === "fastify" ? new FastifyServer({ ...serverConfig, config: settings.server }) : void 0;
+  const changesConfig = _optionalChain([settings, 'access', _149 => _149.dbs, 'optionalAccess', _150 => _150.changes]) ? {
+    debeziumUrl: settings.dbs.changes.debeziumUrl,
+    eventBus: new KafkaEventBus(settings.dbs.changes.kafkaConfig)
+  } : void 0;
+  const dbs = Object.fromEntries(
+    Object.entries(_nullishCoalesce(_optionalChain([settings, 'access', _151 => _151.dbs, 'optionalAccess', _152 => _152.types]), () => ( {}))).map(([key, config]) => [
+      key,
+      config.type === "mongo" ? new MongoDb(config, { changes: changesConfig }) : void 0
+    ])
+  );
+  return {
+    app: settings.app,
+    utils: settings.utils,
+    log,
+    eventBus,
+    cache,
+    jobs,
+    server,
+    dbs
+  };
+}
+function deleteKeys(data, keys) {
+  for (const key of keys) delete data[key];
+  return data;
+}
+
+// src/instance/index.ts
+var Instance = class _Instance extends _valleyed.DataClass {
+  static #instance;
+  static #hooks = {};
+  
+  
+  constructor(envs, settings) {
+    super(mapSettingsToInstance(settings));
+    _Instance.#instance = this;
+    this.envs = Object.freeze(envs);
+    this.settings = Object.freeze(settings);
+    _Instance.#registerOnExitHandler();
+  }
+  getScopedName(name, key = ".") {
+    return [this.settings.app.name, name].join(key);
+  }
+  async start() {
+    try {
+      await runHooks(_nullishCoalesce(_Instance.#hooks["setup"], () => ( [])));
+      await runHooks(_nullishCoalesce(_Instance.#hooks["start"], () => ( [])));
+    } catch (error) {
+      _Instance.crash(new EquippedError(`Error starting instance`, {}, error));
+    }
+  }
+  static create(envsPipe, settings) {
+    if (_Instance.#instance) throw _Instance.crash(new EquippedError("An instance has already been created. Use that instead", {}));
+    const envValidity = _valleyed.v.validate(envsPipe, process.env);
+    if (!envValidity.valid) {
+      _Instance.crash(
+        new EquippedError(`Environment variables are not valid
+${envValidity.error.toString()}`, {
+          messages: envValidity.error.messages
+        })
+      );
+    }
+    const settingsValidity = _valleyed.v.validate(instanceSettingsPipe(), settings(envValidity.value));
+    if (!settingsValidity.valid) {
+      _Instance.crash(
+        new EquippedError(`Settings are not valid
+${settingsValidity.error.toString()}`, {
+          messages: settingsValidity.error.messages
+        })
+      );
+    }
+    return new _Instance(envValidity.value, settingsValidity.value);
+  }
+  static get() {
+    if (!_Instance.#instance)
+      return _Instance.crash(
+        new EquippedError("Has not been initialized. Make sure an instance has been created before you get an instance", {})
+      );
+    return _Instance.#instance;
+  }
+  static on(event, cb, order) {
+    _Instance.#hooks[event] ??= [];
+    _Instance.#hooks[event].push({ cb, order });
+  }
+  static #registerOnExitHandler() {
+    const signals = {
+      SIGHUP: 1,
+      SIGINT: 2,
+      SIGTERM: 15
+    };
+    Object.entries(signals).forEach(([signal, code]) => {
+      process.on(signal, async () => {
+        await runHooks(_nullishCoalesce(_Instance.#hooks["close"], () => ( [])), () => {
+        });
+        process.exit(128 + code);
+      });
+    });
+  }
+  static resolveBeforeCrash(cb) {
+    const value = cb();
+    _Instance.on("close", async () => await value, 10);
+    return value;
+  }
+  static crash(error) {
+    console.error(error);
+    process.exit(1);
+  }
+};
+
+// src/validations/valleyed.ts
+var filePipe = (err) => _valleyed.v.array(
+  _valleyed.v.file(err).pipe((input) => {
+    const err2 = `is larger than allowed limit of ${_optionalChain([Instance, 'access', _153 => _153.get, 'call', _154 => _154(), 'access', _155 => _155.settings, 'access', _156 => _156.server, 'optionalAccess', _157 => _157.requests, 'access', _158 => _158.maxFileUploadSizeInMb])}mb`;
+    const valid = input ? !input.isTruncated : true;
+    if (valid) return input;
+    throw _valleyed.PipeError.root(err2, input);
+  })
+);
+var incomingFile = (err) => _valleyed.v.pipe(
+  (input) => _valleyed.v.assert(
+    filePipe(err).pipe(_valleyed.v.min(1, "no file provided")).pipe((files) => files[0]),
+    input
+  ),
+  { schema: () => ({ type: "string", format: "binary" }) }
+);
+var incomingFiles = (err) => _valleyed.v.pipe((input) => _valleyed.v.assert(filePipe(err), input), {
+  schema: () => ({ type: "string", format: "binary" })
+});
+var requestLocalStorage = new (0, _async_hooks.AsyncLocalStorage)();
+var responseLocalStorage = new (0, _async_hooks.AsyncLocalStorage)();
+var withRequest = (fn) => _valleyed.v.pipe((input) => {
+  const req = requestLocalStorage.getStore();
+  if (!req) throw _valleyed.PipeError.root("Request not found in context", input);
+  return _valleyed.v.assert(fn(req), input);
+});
+var withResponse = (fn) => _valleyed.v.pipe((input) => {
+  const res = responseLocalStorage.getStore();
+  if (!res) throw _valleyed.PipeError.root("Response not found in context", input);
+  return _valleyed.v.assert(fn(res), input);
+});
+
+// src/validations/index.ts
+
+function pipeErrorToValidationError(error) {
+  const errorsObject = error.messages.reduce((acc, { path = "", message }) => {
+    if (acc[path]) acc[path].messages.push(message);
+    else acc[path] = { field: path, messages: [message] };
+    return acc;
+  }, {});
+  return new ValidationError(Object.values(errorsObject));
+}
+function validate(pipe, value) {
+  const validity = _valleyed.v.validate(pipe, value);
+  if (validity.valid) return validity.value;
+  throw pipeErrorToValidationError(validity.error);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Cache = Cache; exports.redisConfigPipe = redisConfigPipe; exports.EquippedError = EquippedError; exports.RequestError = RequestError; exports.valleyed_exports = valleyed_exports; exports.pipeErrorToValidationError = pipeErrorToValidationError; exports.validate = validate; exports.Methods = Methods; exports.StatusCodes = StatusCodes; exports.makeMiddleware = makeMiddleware; exports.makeErrorMiddleware = makeErrorMiddleware; exports.Router = Router; exports.authProviders_exports = authProviders_exports; exports.hash_exports = hash_exports; exports.parseJSONValue = parseJSONValue; exports.parseJSONObject = parseJSONObject; exports.getMediaDuration = getMediaDuration; exports.sleep = sleep; exports.retry = retry; exports.random_exports = random_exports; exports.Request = Request; exports.Response = Response; exports.Server = Server; exports.ExpressServer = ExpressServer; exports.FastifyServer = FastifyServer; exports.requireAuthUser = requireAuthUser; exports.requireAuthorizationUser = requireAuthorizationUser; exports.requireApiKeyUser = requireApiKeyUser; exports.requireRefreshTokenUser = requireRefreshTokenUser; exports.BaseApiKeysUtility = BaseApiKeysUtility; exports.BaseTokensUtility = BaseTokensUtility; exports.CacheTokensUtility = CacheTokensUtility; exports.serverPipe = serverPipe; exports.AuthorizationExpired = AuthorizationExpired; exports.BadRequestError = BadRequestError; exports.NotAuthenticatedError = NotAuthenticatedError; exports.NotAuthorizedError = NotAuthorizedError; exports.NotFoundError = NotFoundError; exports.RefreshTokenMisusedError = RefreshTokenMisusedError; exports.ValidationError = ValidationError; exports.RedisCache = RedisCache; exports.TopicPrefix = TopicPrefix; exports.Db = Db; exports.DbChange = DbChange; exports.MongoDbChange = MongoDbChange; exports.QueryKeys = QueryKeys; exports.Conditions = Conditions; exports.queryParamsPipe = queryParamsPipe; exports.queryResultsPipe = queryResultsPipe; exports.wrapQueryParams = wrapQueryParams; exports.mongoDbConfigPipe = mongoDbConfigPipe; exports.MongoDb = MongoDb; exports.EventBus = EventBus; exports.DefaultSubscribeOptions = DefaultSubscribeOptions; exports.rabbitmqConfigPipe = rabbitmqConfigPipe; exports.kafkaConfigPipe = kafkaConfigPipe; exports.KafkaEventBus = KafkaEventBus; exports.RabbitMQEventBus = RabbitMQEventBus; exports.redisJobsConfigPipe = redisJobsConfigPipe; exports.RedisJob = RedisJob; exports.Instance = Instance;
+//# sourceMappingURL=chunk-UBQPLHM4.cjs.map