equipped 5.0.7 → 5.0.9

package/dist/esm/chunk-DXTIVHEC.mjs

@@ -0,0 +1,2507 @@
+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
+export * from "valleyed";
+
+// src/validations/valleyed.ts
+var valleyed_exports = {};
+__export(valleyed_exports, {
+  incomingFile: () => incomingFile,
+  incomingFiles: () => incomingFiles,
+  requestLocalStorage: () => requestLocalStorage,
+  responseLocalStorage: () => responseLocalStorage,
+  withRequest: () => withRequest,
+  withResponse: () => withResponse
+});
+import { AsyncLocalStorage } from "async_hooks";
+import { PipeError as PipeError2, v as v10 } from "valleyed";
+
+// src/instance/index.ts
+import { DataClass, v as v9 } from "valleyed";
+
+// 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
+import pino from "pino";
+import { v as v8 } from "valleyed";
+
+// src/cache/base.ts
+var Cache = class {
+};
+
+// src/cache/pipes.ts
+import { v } from "valleyed";
+var redisConfigPipe = v.meta(
+  v.object({
+    host: v.string(),
+    port: v.optional(v.number()),
+    password: v.optional(v.string()),
+    username: v.optional(v.string()),
+    tls: v.optional(v.boolean()),
+    cluster: v.optional(v.boolean())
+  }),
+  { title: "Redis Config", $refId: "RedisConfig" }
+);
+
+// src/cache/types/redis.ts
+import { Cluster, Redis } from "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
+import { Server as SocketServer } from "socket.io";
+import supertest from "supertest";
+import { PipeError, v as v3 } from "valleyed";
+
+// 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 = Instance.get().settings.server?.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
+import { convert } from "@openapi-contrib/json-schema-to-openapi-schema";
+import { capitalize } from "valleyed";
+
+// src/server/routes.ts
+import { v as v2 } from "valleyed";
+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 v2.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: [...config.groups ?? [], ...route.groups ?? []],
+  middlewares: [...config.middlewares ?? [], ...route.middlewares ?? []],
+  schema: mergeSchemas(config.schema ?? {}, route.schema ?? {}),
+  security: [...config.security ?? [], ...route.security ?? []]
+}));
+var Router = class {
+  #config = { path: "" };
+  #routes = [];
+  #children = [];
+  constructor(config = { path: "" }) {
+    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;
+    };
+  }
+  head = this.#wrap(Methods.head);
+  get = this.#wrap(Methods.get);
+  post = this.#wrap(Methods.post);
+  put = this.#wrap(Methods.put);
+  patch = this.#wrap(Methods.patch);
+  delete = this.#wrap(Methods.delete);
+  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)));
+  }
+};
+
+// 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: config.config.openapi.docsVersion ?? ""
+      },
+      servers: config.config.openapi.docsBaseUrl?.map((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(route.groups ?? []);
+    const cleanPath = this.cleanPath(route.path);
+    const operationId = `(${route.method.toUpperCase()}) ${cleanPath}`;
+    await this.#addRouteToOpenApiDoc(cleanPath, route.method.toLowerCase(), def, {
+      operationId,
+      summary: route.title ?? cleanPath,
+      description: route.descriptions?.join("\n\n"),
+      tags: tag ? [tag] : void 0,
+      security: route.security
+    });
+  }
+  async #addRouteToOpenApiDoc(path, method, def, methodObj) {
+    if (def.response.response?.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 convert(this.#visit(resp.schema)) };
+      }
+    }
+    if (def.response.responseHeaders?.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 convert(this.#visit(resp.schema)) };
+      }
+    }
+    if (def.request.body)
+      methodObj.requestBody = {
+        required: true,
+        content: {
+          "application/json": { schema: await convert(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 convert(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: 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 (this.#baseOpenapiDoc.components?.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 = parsed.at(-1)?.name ?? "";
+    const description = parsed.map((g) => g.description?.trim() ?? "").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 = capitalize(`${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
+});
+import axios from "axios";
+import jwt from "jsonwebtoken";
+import jwksClient from "jwks-rsa";
+var signinWithGoogle = async (idToken) => {
+  const authUrl = `https://oauth2.googleapis.com/tokeninfo?id_token=${idToken}`;
+  const { data } = await axios.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 = jwt.decode(idToken, { complete: true });
+    if (!json?.header) throw new Error("");
+    const { kid, alg } = json.header;
+    const publicKey = await jwksClient({ 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 = jwt.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 axios.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
+});
+import * as bcrypt from "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 (data?.constructor?.name !== "String") return data;
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+};
+function parseJSONObject(data) {
+  return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, parseJSONValue(value)]));
+}
+
+// src/utilities/media.ts
+import { parseBuffer } from "music-metadata";
+var getMediaDuration = async (buffer) => {
+  try {
+    const meta = await parseBuffer(buffer);
+    return meta.format.duration ?? 0;
+  } catch {
+    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
+});
+import crypto from "crypto";
+function string(length = 20) {
+  return crypto.randomBytes(length).toString("hex").slice(0, length);
+}
+function number(min = 0, max = 2 ** 48 - 1) {
+  return crypto.randomInt(min, max);
+}
+
+// src/server/requests.ts
+var Request = class {
+  ip;
+  method;
+  path;
+  body;
+  params;
+  query;
+  headers;
+  context;
+  cookies;
+  users = {
+    access: {},
+    refresh: {},
+    apiKey: {}
+  };
+  authUser;
+  constructor({
+    ip,
+    body,
+    cookies,
+    params,
+    query,
+    method,
+    path,
+    context,
+    headers,
+    files
+  }) {
+    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 });
+  }
+};
+var Response = class {
+  body;
+  headers;
+  status;
+  contentType;
+  piped;
+  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
+import { match as Match } from "path-to-regexp";
+var EmitterEvent = "__listener_emitter";
+var defaultTo = "*";
+var SocketEmitter = class {
+  socketInstance;
+  #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);
+        };
+        eventBus?.createSubscriber(
+          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 : [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) => Match(key)(channel);
+    const matchedChannel = 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 = Instance.get().settings.server?.requestsAuth.tokens;
+      if (socket.handshake.auth.authorization && tokensUtil)
+        user = await tokensUtil.verifyAccessToken(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 = 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, data.query ?? {});
+        const newChannel = `${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: v3.meta(v3.array(v3.object({ message: v3.string(), field: v3.optional(v3.string()) })), {
+    $refId: `Errors.${key}Response`,
+    description: `${key} Response`
+  })
+}));
+var Server = class {
+  constructor(server, config, implementations) {
+    this.config = config;
+    this.implementations = implementations;
+    this.server = server;
+    this.#openapi = new OpenApi(this.config);
+    const socketInstance = new SocketServer(server, { cors: this.cors });
+    this.socket = new SocketEmitter(socketInstance, config.eventBus);
+    this.addRouter(this.#openapi.router());
+  }
+  #queue = [];
+  #routesByKey = /* @__PURE__ */ new Map();
+  #openapi;
+  socket;
+  server;
+  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) => m.onSetup?.(route));
+        onError?.onSetup?.(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 (onError?.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 = schema?.defaultStatusCode ?? StatusCodes.Ok;
+    const defaultContentType = schema?.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 = schema[def.key] ?? v3.any();
+      if (def.skip) return;
+      if (def.type === "request") {
+        requestPipe[def.key] = pipe;
+        jsonSchema.request[def.key] = v3.schema(pipe);
+      }
+      if (def.type === "response") {
+        const pipeRecords = errorsSchemas.concat({ status: defaultStatusCode, contentType, pipe });
+        responsePipe[def.key] = v3.any().pipe((input) => {
+          const p = pipeRecords.find((r) => r.status === status)?.pipe;
+          if (!p) throw PipeError.root(`schema not defined for status code: ${status}`, input);
+          return v3.assert(p, input);
+        });
+        jsonSchema.response[def.key] = pipeRecords.map((record) => ({
+          status: record.status,
+          contentType: record.contentType,
+          schema: v3.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,
+        () => v3.validate(v3.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,
+        () => v3.validate(v3.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 supertest(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;
+  }
+};
+
+// src/server/impls/express.ts
+import http from "http";
+import cookie from "cookie-parser";
+import cors from "cors";
+import express from "express";
+import fileUpload from "express-fileupload";
+import { rateLimit } from "express-rate-limit";
+import helmet from "helmet";
+import { pinoHttp } from "pino-http";
+var ExpressServer = class extends Server {
+  #expressApp;
+  constructor(config) {
+    const app = express();
+    super(http.createServer(app), config, {
+      parseRequest: async (req) => {
+        const allHeaders = Object.fromEntries(Object.entries(req.headers).map(([key, val]) => [key, 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(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: req.body ?? {},
+          cookies: req.cookies ?? {},
+          params: req.params ?? {},
+          query: 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) => {
+        this.#expressApp[method]?.(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({ logger: config.log }));
+    app.use(express.json());
+    app.use(express.text());
+    app.use(cookie());
+    app.use(
+      helmet({
+        crossOriginResourcePolicy: { policy: "cross-origin" },
+        contentSecurityPolicy: false
+      })
+    );
+    app.use(cors(this.cors));
+    app.use(express.urlencoded({ extended: false }));
+    if (config.config.publicPath) app.use(express.static(config.config.publicPath));
+    app.use(
+      fileUpload({
+        limits: { fileSize: config.config.requests.maxFileUploadSizeInMb * 1024 * 1024 },
+        useTempFiles: false
+      })
+    );
+    if (config.config.requests.rateLimit.enabled)
+      app.use(
+        rateLimit({
+          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
+import fastifyCookie from "@fastify/cookie";
+import fastifyCors from "@fastify/cors";
+import fastifyFormBody from "@fastify/formbody";
+import fastifyHelmet from "@fastify/helmet";
+import fastifyMultipart from "@fastify/multipart";
+import fastifyRateLimit from "@fastify/rate-limit";
+import fastifyStatic from "@fastify/static";
+import Fastify from "fastify";
+import qs from "qs";
+var FastifyServer = class extends Server {
+  constructor(config) {
+    const app = Fastify({
+      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: [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, val ?? null]));
+        const headers = {
+          ...allHeaders,
+          Authorization: req.headers["authorization"]?.toString(),
+          RefreshToken: req.headers["x-refresh-token"]?.toString(),
+          ApiKey: req.headers["x-api-key"]?.toString(),
+          ContentType: req.headers["content-type"]?.toString(),
+          Referer: req.headers["referer"]?.toString(),
+          UserAgent: req.headers["user-agent"]?.toString()
+        };
+        const { body, files } = excludeBufferKeys(req.body ?? {});
+        return new Request({
+          ip: req.ip,
+          body,
+          cookies: req.cookies ?? {},
+          params: req.params ?? {},
+          query: 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(fastifyStatic, { root: config.config.publicPath });
+    app.register(fastifyCookie, {});
+    app.register(fastifyCors, this.cors);
+    app.register(fastifyFormBody, { parser: (str) => qs.parse(str) });
+    app.register(fastifyHelmet, { crossOriginResourcePolicy: { policy: "cross-origin" }, contentSecurityPolicy: false });
+    app.register(fastifyMultipart, {
+      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(fastifyRateLimit, {
+        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(body ?? {});
+  const isFile = (val) => Array.isArray(val) ? isFile(val.at(0)) : Buffer.isBuffer(val?.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 Instance.get().settings.server?.requestsAuth.tokens?.verifyRefreshToken(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
+import { v as v4 } from "valleyed";
+
+// src/server/requests-auth/apiKeys.ts
+var BaseApiKeysUtility = class {
+};
+
+// src/server/requests-auth/tokens.ts
+import jwt2 from "jsonwebtoken";
+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;
+  options;
+  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 = jwt2.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 = jwt2.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 = jwt2.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 jwt2.TokenExpiredError) throw new AuthorizationExpired(void 0, err);
+      else throw new NotAuthenticatedError(void 0, err);
+    }
+  }
+  async verifyRefreshToken(token) {
+    try {
+      const user = jwt2.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 = v4.object({
+  type: v4.in(["fastify", "express"]),
+  port: v4.number(),
+  publicPath: v4.optional(v4.string()),
+  healthPath: v4.optional(v4.string()),
+  openapi: v4.defaults(
+    v4.object({
+      docsVersion: v4.defaults(v4.string(), "1.0.0"),
+      docsBaseUrl: v4.defaults(v4.array(v4.string()), ["/"]),
+      docsPath: v4.defaults(v4.string(), "/__docs")
+    }),
+    {}
+  ),
+  requests: v4.defaults(
+    v4.object({
+      log: v4.defaults(v4.boolean(), true),
+      paginationDefaultLimit: v4.defaults(v4.number(), 100),
+      maxFileUploadSizeInMb: v4.defaults(v4.number(), 500),
+      rateLimit: v4.defaults(
+        v4.object({
+          enabled: v4.defaults(v4.boolean(), false),
+          periodInMs: v4.defaults(v4.number(), 60 * 60 * 1e3),
+          limit: v4.defaults(v4.number(), 5e3)
+        }),
+        {}
+      ),
+      slowdown: v4.defaults(
+        v4.object({
+          enabled: v4.defaults(v4.boolean(), false),
+          periodInMs: v4.defaults(v4.number(), 10 * 60 * 1e3),
+          delayAfter: v4.defaults(v4.number(), 2e3),
+          delayInMs: v4.defaults(v4.number(), 500)
+        }),
+        {}
+      )
+    }),
+    {}
+  ),
+  requestsAuth: v4.defaults(
+    v4.object({
+      tokens: v4.optional(v4.instanceOf(BaseTokensUtility)),
+      apiKey: v4.optional(v4.instanceOf(BaseApiKeysUtility))
+    }),
+    {}
+  )
+});
+
+// src/errors/types/authorizationExpired.ts
+var AuthorizationExpired = class extends RequestError {
+  statusCode = StatusCodes.AuthorizationExpired;
+  constructor(message = "Access token expired", cause) {
+    super(message, [{ message }], cause);
+  }
+};
+
+// src/errors/types/badRequestError.ts
+var BadRequestError = class extends RequestError {
+  statusCode = StatusCodes.BadRequest;
+  constructor(message, cause) {
+    super(message, [{ message }], cause);
+  }
+};
+
+// src/errors/types/notAuthenticatedError.ts
+var NotAuthenticatedError = class extends RequestError {
+  statusCode = StatusCodes.NotAuthenticated;
+  constructor(message = "Not authenticated", cause) {
+    super(message, [{ message }], cause);
+  }
+};
+
+// src/errors/types/notAuthorizedError.ts
+var NotAuthorizedError = class extends RequestError {
+  statusCode = StatusCodes.NotAuthorized;
+  constructor(message = "Not authorized", cause) {
+    super(message, [{ message }], cause);
+  }
+};
+
+// src/errors/types/notFoundError.ts
+var NotFoundError = class extends RequestError {
+  statusCode = StatusCodes.NotFound;
+  constructor(message = "Not found", cause) {
+    super(message, [{ message }], cause);
+  }
+};
+
+// src/errors/types/refreshTokenMisusedError.ts
+var RefreshTokenMisusedError = class extends RequestError {
+  statusCode = StatusCodes.NotAuthenticated;
+  constructor(message = "Refresh token misused", cause) {
+    super(message, [{ message }], cause);
+  }
+};
+
+// src/errors/types/validationError.ts
+var ValidationError = class extends RequestError {
+  statusCode = StatusCodes.ValidationError;
+  constructor(errors, cause) {
+    super(
+      "Unprocessable Entity",
+      errors.flatMap(({ field, messages }) => messages.map((message) => ({ message, field }))),
+      cause
+    );
+  }
+};
+
+// src/cache/types/redis.ts
+var RedisCache = class extends Cache {
+  client;
+  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 Cluster([node], {
+      ...extraConfig,
+      redisOptions: common,
+      lazyConnect: true
+    }) : new 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
+import axios2 from "axios";
+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.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 topics.data[key]?.topics?.includes?.(key) ?? false;
+    }).catch((err) => {
+      throw new EquippedError(`Failed to configure watcher`, { key }, err);
+    });
+  }
+};
+
+// src/dbs/mongo/changes.ts
+import { ObjectId } from "mongodb";
+import { differ } from "valleyed";
+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(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(data.before ?? "null");
+        let after = JSON.parse(data.after ?? "null");
+        if (before) before = hydrate(before);
+        if (after) after = hydrate(after);
+        if (before?.__id === TestId || after?.__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: differ.from(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 ObjectId(id);
+  } catch {
+    return id;
+  }
+};
+
+// src/dbs/mongo/index.ts
+import { MongoClient as MongoClient2, ObjectId as ObjectId3 } from "mongodb";
+
+// src/dbs/mongo/api.ts
+import { ObjectId as ObjectId2 } from "mongodb";
+
+// src/dbs/pipes.ts
+import { v as v5 } from "valleyed";
+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 = v5.catch(v5.defaults(v5.in(["and" /* and */, "or" /* or */]), "and" /* and */), "and" /* and */);
+var queryWhere = v5.object({
+  field: v5.string(),
+  value: v5.any(),
+  condition: v5.catch(v5.defaults(v5.in(Object.values(Conditions)), "eq" /* eq */), "eq" /* eq */)
+});
+var queryWhereBlock = v5.object({
+  condition: queryKeys,
+  value: v5.array(queryWhere)
+});
+var queryWhereClause = v5.defaults(v5.array(v5.or([queryWhere, queryWhereBlock])), []);
+function queryParamsPipe() {
+  const pagLimit = Instance.get().settings.server?.requests.paginationDefaultLimit ?? 100;
+  return v5.meta(
+    v5.object({
+      all: v5.defaults(v5.boolean(), false),
+      limit: v5.catch(v5.defaults(v5.number().pipe(v5.lte(pagLimit)), pagLimit), pagLimit),
+      page: v5.catch(v5.defaults(v5.number().pipe(v5.gte(1)), 1), 1),
+      search: v5.defaults(
+        v5.nullish(
+          v5.object({
+            value: v5.string(),
+            fields: v5.array(v5.string())
+          })
+        ),
+        null
+      ),
+      sort: v5.defaults(
+        v5.array(
+          v5.object({
+            field: v5.string(),
+            desc: v5.defaults(v5.boolean(), false)
+          })
+        ),
+        []
+      ),
+      whereType: queryKeys,
+      where: queryWhereClause
+    }).pipe((p) => ({ ...p, auth: [], authType: "and" /* and */ })),
+    { title: "Query Params", $refId: "QueryParams" }
+  );
+}
+function queryResultsPipe(model) {
+  return v5.object({
+    pages: v5.object({
+      current: v5.number(),
+      start: v5.number(),
+      last: v5.number(),
+      previous: v5.nullable(v5.number()),
+      next: v5.nullable(v5.number())
+    }),
+    docs: v5.object({
+      limit: v5.number(),
+      total: v5.number(),
+      count: v5.number()
+    }),
+    results: v5.array(model)
+  });
+}
+function wrapQueryParams(params) {
+  return v5.assert(queryParamsPipe(), params);
+}
+var mongoDbConfigPipe = v5.meta(
+  v5.object({
+    uri: v5.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 = 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" : 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,
+      ...config.options?.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 && !config.options?.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 result.at(0) ?? null;
+    },
+    findById: async (id, options = {}) => {
+      const result = await table.findOne({ [idKey]: id }, options);
+      return result;
+    },
+    insertMany: async (values, options = {}) => {
+      const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+      const payload = values.map((value, i) => prepInsertValue(value, options.makeId?.(i) ?? new ObjectId2().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 = options.getTime?.() ?? /* @__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 = options.getTime?.() ?? /* @__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 = options.getTime?.() ?? /* @__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, options.makeId?.() ?? new ObjectId2().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: options?.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 = options.getTime?.() ?? /* @__PURE__ */ new Date();
+      operations.forEach((operation, i) => {
+        switch (operation.op) {
+          case "insert":
+            bulk.insert(prepInsertValue(operation.value, operation.makeId?.(i) ?? new ObjectId2().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,
+                operation.makeId?.(i) ?? new ObjectId2().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 MongoClient2(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 (existing.options?.changeStreamPreAndPostImages?.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 ObjectId3();
+  }
+  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
+import { v as v6 } from "valleyed";
+var rabbitmqConfigPipe = v6.meta(
+  v6.object({
+    uri: v6.string(),
+    eventColumnName: v6.string()
+  }),
+  { title: "Rabbitmq Config", $refId: "RabbitmqConfig" }
+);
+var kafkaConfigPipe = v6.meta(
+  v6.object({
+    brokers: v6.array(v6.string()),
+    ssl: v6.optional(v6.boolean()),
+    sasl: v6.optional(
+      v6.object({
+        mechanism: v6.is("plain"),
+        username: v6.string(),
+        password: v6.string()
+      })
+    ),
+    confluent: v6.optional(v6.boolean()),
+    clientId: v6.optional(v6.string())
+  }),
+  { title: "Kafka Config", $refId: "KafkaConfig" }
+);
+
+// src/events/types/kafka.ts
+import Confluent from "@confluentinc/kafka-javascript";
+import Kafka from "kafkajs";
+var KafkaEventBus = class extends EventBus {
+  #client;
+  #confluent;
+  #admin;
+  constructor(config) {
+    super();
+    const { confluent = false, ...kafkaSettings } = config;
+    this.#confluent = confluent;
+    this.#client = confluent ? new Confluent.KafkaJS.Kafka({
+      kafkaJS: { ...kafkaSettings, logLevel: Confluent.KafkaJS.logLevel.NOTHING }
+    }) : new Kafka.Kafka({ ...kafkaSettings, logLevel: Kafka.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 {
+        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
+import { connect } from "amqp-connection-manager";
+var RabbitMQEventBus = class extends EventBus {
+  #client;
+  #columnName;
+  constructor(config) {
+    super();
+    this.#columnName = config.eventColumnName;
+    this.#client = connect([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 {
+                channel.nack(msg);
+              }
+            });
+          },
+          { noAck: false }
+        );
+      });
+    };
+    Instance.on("start", subscribe, 2);
+  }
+};
+
+// src/jobs/pipes.ts
+import { v as v7 } from "valleyed";
+var redisJobsConfigPipe = v7.meta(
+  v7.object({
+    redisConfig: redisConfigPipe,
+    queueName: v7.string()
+  }),
+  { title: "Redis Jobs Config", $refId: "RedisJobsConfig" }
+);
+
+// src/jobs/types/redis.ts
+import Bull from "bull";
+var RedisJob = class _RedisJob {
+  #queue;
+  #callbacks = {};
+  #crons = [];
+  constructor(config) {
+    const redisCache = new RedisCache(config.redisConfig, {
+      maxRetriesPerRequest: null,
+      enableReadyCheck: false
+    });
+    this.#queue = new Bull(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 this.#callbacks.onDelayed?.(job.data)),
+          this.#queue.process("CronJob" /* CronJob */, async (job) => await this.#callbacks.onCron?.(job.data.type)),
+          this.#queue.process("RepeatableJob" /* RepeatableJob */, async (job) => await this.#callbacks.onRepeatable?.(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 job.opts?.repeat?.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 = () => v8.object({
+  app: v8.object({
+    id: v8.string(),
+    name: v8.string()
+  }),
+  log: v8.defaults(
+    v8.object({
+      level: v8.defaults(v8.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
+    }),
+    {}
+  ),
+  dbs: v8.optional(
+    v8.object({
+      types: v8.record(
+        v8.string(),
+        v8.discriminate((e) => e?.type, {
+          mongo: v8.merge(mongoDbConfigPipe, v8.object({ type: v8.is("mongo") }))
+        })
+      ),
+      changes: v8.optional(
+        v8.object({
+          debeziumUrl: v8.string(),
+          kafkaConfig: kafkaConfigPipe
+        })
+      )
+    })
+  ),
+  eventBus: v8.optional(
+    v8.discriminate((e) => e?.type, {
+      kafka: v8.merge(kafkaConfigPipe, v8.object({ type: v8.is("kafka") })),
+      rabbitmq: v8.merge(rabbitmqConfigPipe, v8.object({ type: v8.is("rabbitmq") }))
+    })
+  ),
+  cache: v8.discriminate((e) => e?.type, {
+    redis: v8.merge(redisConfigPipe, v8.object({ type: v8.is("redis") }))
+  }),
+  jobs: v8.optional(v8.merge(redisJobsConfigPipe, v8.object({ type: v8.is("redis") }))),
+  server: v8.optional(
+    v8.object({
+      type: v8.in(["fastify", "express"]),
+      port: v8.number(),
+      publicPath: v8.optional(v8.string()),
+      healthPath: v8.optional(v8.string()),
+      openapi: v8.defaults(
+        v8.object({
+          docsVersion: v8.defaults(v8.string(), "1.0.0"),
+          docsBaseUrl: v8.defaults(v8.array(v8.string()), ["/"]),
+          docsPath: v8.defaults(v8.string(), "/__docs")
+        }),
+        {}
+      ),
+      requests: v8.defaults(
+        v8.object({
+          log: v8.defaults(v8.boolean(), true),
+          paginationDefaultLimit: v8.defaults(v8.number(), 100),
+          maxFileUploadSizeInMb: v8.defaults(v8.number(), 500),
+          rateLimit: v8.defaults(
+            v8.object({
+              enabled: v8.defaults(v8.boolean(), false),
+              periodInMs: v8.defaults(v8.number(), 60 * 60 * 1e3),
+              limit: v8.defaults(v8.number(), 5e3)
+            }),
+            {}
+          ),
+          slowdown: v8.defaults(
+            v8.object({
+              enabled: v8.defaults(v8.boolean(), false),
+              periodInMs: v8.defaults(v8.number(), 10 * 60 * 1e3),
+              delayAfter: v8.defaults(v8.number(), 2e3),
+              delayInMs: v8.defaults(v8.number(), 500)
+            }),
+            {}
+          )
+        }),
+        {}
+      ),
+      requestsAuth: v8.defaults(
+        v8.object({
+          tokens: v8.optional(v8.instanceOf(BaseTokensUtility)),
+          apiKey: v8.optional(v8.instanceOf(BaseApiKeysUtility))
+        }),
+        {}
+      )
+    })
+  ),
+  utils: v8.defaults(
+    v8.object({
+      hashSaltRounds: v8.defaults(v8.number(), 10)
+    }),
+    {}
+  )
+});
+function mapSettingsToInstance(settings) {
+  const log = pino({
+    level: settings.log.level,
+    serializers: {
+      err: pino.stdSerializers.err,
+      error: pino.stdSerializers.err,
+      req: pino.stdSerializers.req,
+      res: pino.stdSerializers.res
+    }
+  });
+  const cache = new RedisCache(settings.cache);
+  const jobs = settings.jobs ? new RedisJob(settings.jobs) : void 0;
+  const eventBus = settings.eventBus?.type === "kafka" ? new KafkaEventBus(deleteKeys(settings.eventBus, ["type"])) : settings.eventBus?.type === "rabbitmq" ? new RabbitMQEventBus(deleteKeys(settings.eventBus, ["type"])) : void 0;
+  const serverConfig = {
+    app: settings.app,
+    log,
+    eventBus
+  };
+  const server = settings.server?.type === "express" ? new ExpressServer({ ...serverConfig, config: settings.server }) : settings.server?.type === "fastify" ? new FastifyServer({ ...serverConfig, config: settings.server }) : void 0;
+  const changesConfig = settings.dbs?.changes ? {
+    debeziumUrl: settings.dbs.changes.debeziumUrl,
+    eventBus: new KafkaEventBus(settings.dbs.changes.kafkaConfig)
+  } : void 0;
+  const dbs = Object.fromEntries(
+    Object.entries(settings.dbs?.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 DataClass {
+  static #instance;
+  static #hooks = {};
+  envs;
+  settings;
+  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(_Instance.#hooks["setup"] ?? []);
+      await runHooks(_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 = v9.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 = v9.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(_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) => v10.array(
+  v10.file(err).pipe((input) => {
+    const err2 = `is larger than allowed limit of ${Instance.get().settings.server?.requests.maxFileUploadSizeInMb}mb`;
+    const valid = input ? !input.isTruncated : true;
+    if (valid) return input;
+    throw PipeError2.root(err2, input);
+  })
+);
+var incomingFile = (err) => v10.pipe(
+  (input) => v10.assert(
+    filePipe(err).pipe(v10.min(1, "no file provided")).pipe((files) => files[0]),
+    input
+  ),
+  { schema: () => ({ type: "string", format: "binary" }) }
+);
+var incomingFiles = (err) => v10.pipe((input) => v10.assert(filePipe(err), input), {
+  schema: () => ({ type: "string", format: "binary" })
+});
+var requestLocalStorage = new AsyncLocalStorage();
+var responseLocalStorage = new AsyncLocalStorage();
+var withRequest = (fn) => v10.pipe((input) => {
+  const req = requestLocalStorage.getStore();
+  if (!req) throw PipeError2.root("Request not found in context", input);
+  return v10.assert(fn(req), input);
+});
+var withResponse = (fn) => v10.pipe((input) => {
+  const res = responseLocalStorage.getStore();
+  if (!res) throw PipeError2.root("Response not found in context", input);
+  return v10.assert(fn(res), input);
+});
+
+// src/validations/index.ts
+import { v as v11 } from "valleyed";
+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 = v11.validate(pipe, value);
+  if (validity.valid) return validity.value;
+  throw pipeErrorToValidationError(validity.error);
+}
+
+export {
+  Cache,
+  redisConfigPipe,
+  EquippedError,
+  RequestError,
+  valleyed_exports,
+  pipeErrorToValidationError,
+  validate,
+  Methods,
+  StatusCodes,
+  makeMiddleware,
+  makeErrorMiddleware,
+  Router,
+  authProviders_exports,
+  hash_exports,
+  parseJSONValue,
+  parseJSONObject,
+  getMediaDuration,
+  sleep,
+  retry,
+  random_exports,
+  Request,
+  Response,
+  Server,
+  ExpressServer,
+  FastifyServer,
+  requireAuthUser,
+  requireAuthorizationUser,
+  requireApiKeyUser,
+  requireRefreshTokenUser,
+  BaseApiKeysUtility,
+  BaseTokensUtility,
+  CacheTokensUtility,
+  serverPipe,
+  AuthorizationExpired,
+  BadRequestError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  RefreshTokenMisusedError,
+  ValidationError,
+  RedisCache,
+  TopicPrefix,
+  Db,
+  DbChange,
+  MongoDbChange,
+  QueryKeys,
+  Conditions,
+  queryParamsPipe,
+  queryResultsPipe,
+  wrapQueryParams,
+  mongoDbConfigPipe,
+  MongoDb,
+  EventBus,
+  DefaultSubscribeOptions,
+  rabbitmqConfigPipe,
+  kafkaConfigPipe,
+  KafkaEventBus,
+  RabbitMQEventBus,
+  redisJobsConfigPipe,
+  RedisJob,
+  Instance
+};
+//# sourceMappingURL=chunk-DXTIVHEC.mjs.map