equipped 5.2.9 → 5.3.0

package/dist/types/server/openapi.js

@@ -1,190 +0,0 @@
-import { convert } from "@openapi-contrib/json-schema-to-openapi-schema";
-import { capitalize } from "valleyed";
-import { Instance } from "../instance/index.js";
-import { Router } from "./routes.js";
-class OpenApi {
-  constructor(config) {
-    this.config = config;
-    const instance = Instance.get();
-    const { app } = instance.settings;
-    this.#baseOpenapiDoc = {
-      openapi: "3.0.0",
-      info: {
-        title: `${app.name} ${instance.id}`,
-        version: config.openapi.docsVersion ?? ""
-      },
-      servers: 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.openapi.docsPath ?? "/", hide: true });
-    router.get("/index.html")((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 instance = Instance.get();
-    const title = capitalize(`${instance.settings.app.name} ${instance.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.38.0"></script>
-  </body>
-</html>
-`;
-  }
-}
-export {
-  OpenApi
-};

package/dist/types/server/pipes.js

@@ -1,66 +0,0 @@
-import { v } from "valleyed";
-import { EventBus } from "../events/index.js";
-import { BaseRequestAuthMethod } from "./requests-auth-methods/index.js";
-import { Methods } from "./types.js";
-const serverBasePipe = () => v.object({
-  port: v.number(),
-  cors: v.optional(
-    v.object({
-      origin: v.optional(v.or([v.array(v.string()), v.is(true)])),
-      methods: v.optional(v.array(v.in(Object.values(Methods)))),
-      credentials: v.optional(v.boolean())
-    })
-  ),
-  eventBus: v.optional(v.instanceOf(EventBus)),
-  publicPath: v.optional(v.string()),
-  healthPath: v.optional(v.string()),
-  openapi: v.defaults(
-    v.object({
-      docsVersion: v.defaults(v.string(), "1.0.0"),
-      docsBaseUrl: v.defaults(v.array(v.string()), ["/"]),
-      docsPath: v.defaults(v.string(), "/__docs")
-    }),
-    {}
-  ),
-  requests: v.defaults(
-    v.object({
-      log: v.defaults(v.boolean(), true),
-      rateLimit: v.defaults(
-        v.object({
-          enabled: v.defaults(v.boolean(), false),
-          periodInMs: v.defaults(v.number(), 60 * 60 * 1e3),
-          limit: v.defaults(v.number(), 5e3)
-        }),
-        {}
-      ),
-      slowdown: v.defaults(
-        v.object({
-          enabled: v.defaults(v.boolean(), false),
-          periodInMs: v.defaults(v.number(), 10 * 60 * 1e3),
-          delayAfter: v.defaults(v.number(), 2e3),
-          delayInMs: v.defaults(v.number(), 500)
-        }),
-        {}
-      )
-    }),
-    {}
-  ),
-  socketsAuthMethods: v.defaults(v.array(v.instanceOf(BaseRequestAuthMethod)), [])
-});
-const serverConfigPipe = () => v.discriminate((d) => d.type, {
-  fastify: v.merge(
-    serverBasePipe(),
-    v.object({
-      type: v.is("fastify")
-    })
-  ),
-  express: v.merge(
-    serverBasePipe(),
-    v.object({
-      type: v.is("express")
-    })
-  )
-});
-export {
-  serverConfigPipe
-};

package/dist/types/server/requests-auth-methods/apiKeys.js

@@ -1,20 +0,0 @@
-import { BaseRequestAuthMethod } from "./base.js";
-import { NotAuthenticatedError } from "../../errors/index.js";
-class BaseApiKeyRequestAuthMethod extends BaseRequestAuthMethod {
-  headerName;
-  constructor(headerName) {
-    super();
-    this.headerName = headerName;
-  }
-  async parse(headers) {
-    const headerValue = headers[this.headerName];
-    if (!headerValue || typeof headerValue !== "string") throw new NotAuthenticatedError();
-    return this.verify(headerValue);
-  }
-  routeSecuritySchemeName() {
-    return this.headerName;
-  }
-}
-export {
-  BaseApiKeyRequestAuthMethod
-};

package/dist/types/server/requests-auth-methods/base.js

@@ -1,19 +0,0 @@
-import {} from "node:http2";
-import { BadRequestError, RequestError } from "../../errors/index.js";
-class BaseRequestAuthMethod {
-  static async process(methods, headers) {
-    if (methods.length === 0) return null;
-    let error;
-    for (const method of methods) {
-      try {
-        return await method.parse(headers);
-      } catch (err) {
-        error = err;
-      }
-    }
-    throw error instanceof RequestError ? error : new BadRequestError("failed to parse auth user", error);
-  }
-}
-export {
-  BaseRequestAuthMethod
-};

package/dist/types/server/requests-auth-methods/index.js

@@ -1,3 +0,0 @@
-export * from "./apiKeys.js";
-export * from "./base.js";
-export * from "./jwt.js";

package/dist/types/server/requests-auth-methods/jwt.js

@@ -1,77 +0,0 @@
-import cookie from "@fastify/cookie";
-import jwt from "jsonwebtoken";
-import { BaseRequestAuthMethod } from "./base.js";
-import { NotAuthenticatedError, TokenExpired } from "../../errors/index.js";
-class BaseJwtRequestAuthMethod extends BaseRequestAuthMethod {
-  options;
-  constructor(options) {
-    super();
-    this.options = options;
-  }
-  #getKey(userId) {
-    return `${this.options.storagePrefix ?? ""}${userId}`;
-  }
-  async createToken(payload) {
-    const token = jwt.sign(payload, this.options.signingKey, { expiresIn: this.options.storageTTL });
-    await this.store(this.#getKey(payload.id), token, this.options.storageTTL);
-    return token;
-  }
-  async parse(headers) {
-    try {
-      const token = await this.parseHeader(headers);
-      const user = jwt.verify(token, this.options.signingKey);
-      if (!user) throw new NotAuthenticatedError();
-      if (this.options.enforceSingleSession) {
-        const cachedToken = await this.retrieve(this.#getKey(user.id));
-        if (token && token !== cachedToken) throw new TokenExpired();
-      }
-      return user;
-    } catch (err) {
-      if (err instanceof TokenExpired) throw err;
-      if (err instanceof jwt.TokenExpiredError) throw new TokenExpired(void 0, err);
-      else throw new NotAuthenticatedError(void 0, err);
-    }
-  }
-  async retrieveFor(userId) {
-    return this.retrieve(this.#getKey(userId));
-  }
-  async deleteFor(userId) {
-    await this.delete(this.#getKey(userId));
-  }
-}
-class BaseJwtHeaderRequestAuthMethod extends BaseJwtRequestAuthMethod {
-  options;
-  constructor(options) {
-    super(options);
-    this.options = options;
-  }
-  async parseHeader(headers) {
-    const value = headers[this.options.headerName];
-    if (!value || typeof value !== "string") throw new NotAuthenticatedError();
-    return value.startsWith("Bearer ") ? value.slice(7) : value;
-  }
-  routeSecuritySchemeName() {
-    return this.options.headerName;
-  }
-}
-class BaseJwtCookieRequestAuthMethod extends BaseJwtRequestAuthMethod {
-  options;
-  constructor(options) {
-    super(options);
-    this.options = options;
-  }
-  async parseHeader(headers) {
-    const cookies = cookie.parse(headers.cookie || "") ?? {};
-    const value = cookies[this.options.cookieName];
-    if (!value || typeof value !== "string") throw new NotAuthenticatedError();
-    return value;
-  }
-  routeSecuritySchemeName() {
-    return `cookie:${this.options.cookieName}`;
-  }
-}
-export {
-  BaseJwtCookieRequestAuthMethod,
-  BaseJwtHeaderRequestAuthMethod,
-  BaseJwtRequestAuthMethod
-};

package/dist/types/server/requests.js

@@ -1,79 +0,0 @@
-import { parseJSONObject } from "../utilities/index.js";
-class Request {
-  ip;
-  method;
-  path;
-  body;
-  params;
-  query;
-  headers;
-  cookies;
-  authUser = null;
-  constructor({
-    ip,
-    body,
-    cookies,
-    params,
-    query,
-    method,
-    path,
-    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);
-  }
-  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 });
-  }
-}
-class Response {
-  body;
-  headers;
-  cookies;
-  status;
-  contentType;
-  piped;
-  constructor({
-    body,
-    status = 200,
-    headers = {},
-    cookies = {},
-    piped = false,
-    contentType = "application/json"
-  }) {
-    this.body = body;
-    this.status = status;
-    this.contentType = contentType;
-    this.headers = headers;
-    this.cookies = cookies;
-    this.piped = piped;
-    if (!this.piped) {
-      this.headers["Content-Type"] = contentType;
-    }
-  }
-  get cookieValues() {
-    return Object.fromEntries(Object.entries(this.cookies).map(([key, val]) => [key, val]));
-  }
-  set cookieValues(values) {
-    Object.entries(values).forEach(([key, val]) => {
-      if (this.cookies[key]) this.cookies[key].value = val;
-    });
-  }
-}
-export {
-  Request,
-  Response
-};

package/dist/types/server/routes.js

@@ -1,73 +0,0 @@
-import { v } from "valleyed";
-import {
-  Methods
-} from "./types.js";
-function mergeSchemas(...schemas) {
-  const k = {
-    params: "",
-    headers: "",
-    query: "",
-    body: "",
-    cookies: "",
-    response: "",
-    responseHeaders: "",
-    responseCookies: "",
-    defaultStatusCode: "",
-    defaultContentType: ""
-  };
-  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 v.merge(acc, cur);
-  }
-  return Object.fromEntries(
-    Object.keys(k).map((key) => [
-      key,
-      schemas.map((s) => s[key]).reduce(merge, null)
-    ])
-  );
-}
-const groupRoutes = (config, routes) => routes.map((route) => ({
-  ...config,
-  ...route,
-  path: `${config.path}/${route.path}`,
-  groups: [...config.groups ?? [], ...route.groups ?? []],
-  middlewares: [...config.middlewares ?? [], ...route.middlewares ?? []],
-  responseMiddlewares: [...config.responseMiddlewares ?? [], ...route.responseMiddlewares ?? []],
-  schema: mergeSchemas(config.schema ?? {}, route.schema ?? {}),
-  security: [...config.security ?? [], ...route.security ?? []]
-}));
-class Router {
-  #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)));
-  }
-}
-export {
-  Router
-};

package/dist/types/server/sockets.js

@@ -1,125 +0,0 @@
-import { match as Match } from "path-to-regexp";
-import { Instance } from "../instance/index.js";
-import { BaseRequestAuthMethod } from "./requests-auth-methods/index.js";
-import { StatusCodes } from "./types.js";
-var EmitTypes = /* @__PURE__ */ ((EmitTypes2) => {
-  EmitTypes2["created"] = "created";
-  EmitTypes2["updated"] = "updated";
-  EmitTypes2["deleted"] = "deleted";
-  return EmitTypes2;
-})(EmitTypes || {});
-const EmitterEvent = "__listener_emitter";
-const defaultTo = "*";
-class SocketEmitter {
-  constructor(socket, config) {
-    this.config = config;
-    this.socketInstance = socket;
-    this.#setupSocketConnection();
-    Instance.on(
-      "setup",
-      () => {
-        const stream = config.eventBus?.createStream(EmitterEvent, { fanout: true });
-        this.#publish = stream ? stream.publish : async (data) => {
-          socket.to(data.channel).emit(data.channel, data);
-        };
-        stream?.subscribe(async (data) => {
-          socket.to(data.channel).emit(data.channel, data);
-        });
-      },
-      1
-    );
-  }
-  socketInstance;
-  #connectionCallbacks = { onConnect: async () => {
-  }, onDisconnect: async () => {
-  } };
-  #routes = {};
-  #publish = async () => {
-  };
-  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;
-      const user = await BaseRequestAuthMethod.process(this.config.socketsAuthMethods, socket.handshake.headers).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);
-      });
-    });
-  };
-}
-export {
-  SocketEmitter
-};

package/dist/types/server/types.js

@@ -1,33 +0,0 @@
-const Methods = {
-  head: "head",
-  get: "get",
-  post: "post",
-  put: "put",
-  patch: "patch",
-  delete: "delete",
-  options: "options"
-};
-const StatusCodes = {
-  Ok: 200,
-  Found: 302,
-  BadRequest: 400,
-  NotAuthenticated: 401,
-  NotAuthorized: 403,
-  NotFound: 404,
-  ValidationError: 422,
-  TooManyRequests: 429,
-  TokenExpired: 461
-};
-function makeMiddlewareHandler(cb, onSetup) {
-  return { cb, onSetup };
-}
-const makeMiddleware = (...args) => makeMiddlewareHandler(...args);
-const makeResponseMiddleware = (...args) => makeMiddlewareHandler(...args);
-const makeErrorMiddleware = (...args) => makeMiddlewareHandler(...args);
-export {
-  Methods,
-  StatusCodes,
-  makeErrorMiddleware,
-  makeMiddleware,
-  makeResponseMiddleware
-};