equipped 5.2.8 → 5.3.0-alpha.0

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
-};

package/dist/types/utilities/authProviders.js

@@ -1,52 +0,0 @@
-import axios from "axios";
-import jwt from "jsonwebtoken";
-import jwksClient from "jwks-rsa";
-import { EquippedError } from "../errors/index.js";
-const 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;
-};
-const signinWithApple = async (idToken) => {
-  try {
-    const APPLE_BASE = "https://appleid.apple.com";
-    const json = jwt.decode(idToken, { complete: true });
-    if (!json?.header) throw new EquippedError("Missing JWT header", { idToken, json });
-    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);
-  }
-};
-const 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 EquippedError("Incomplete scope for access token", { accessToken, fields, data });
-  data.email_verified = "true";
-  return data;
-};
-export {
-  signinWithApple,
-  signinWithFacebook,
-  signinWithGoogle
-};

package/dist/types/utilities/hash.js

@@ -1,16 +0,0 @@
-import * as bcrypt from "bcryptjs";
-import { Instance } from "../instance/index.js";
-const hash = async (password) => {
-  password = password.trim();
-  if (!password) return "";
-  return await bcrypt.hash(password, Instance.get().settings.utils.hashSaltRounds);
-};
-const compare = async (plainPassword, hashed) => {
-  plainPassword = plainPassword.trim();
-  if (!plainPassword && plainPassword === hashed) return true;
-  return await bcrypt.compare(plainPassword, hashed);
-};
-export {
-  compare,
-  hash
-};

package/dist/types/utilities/json.js

@@ -1,15 +0,0 @@
-const 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)]));
-}
-export {
-  parseJSONObject,
-  parseJSONValue
-};

package/dist/types/utilities/media.js

@@ -1,12 +0,0 @@
-import { parseBuffer } from "music-metadata";
-const getMediaDuration = async (buffer) => {
-  try {
-    const meta = await parseBuffer(buffer);
-    return meta.format.duration ?? 0;
-  } catch {
-    return 0;
-  }
-};
-export {
-  getMediaDuration
-};

package/dist/types/utilities/random.js

@@ -1,11 +0,0 @@
-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);
-}
-export {
-  number,
-  string
-};

package/dist/types/utilities/retry.js

@@ -1,13 +0,0 @@
-import { EquippedError } from "../errors/index.js";
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const 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);
-};
-export {
-  retry,
-  sleep
-};

package/dist/types/validations/valleyed.js

@@ -1,42 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { PipeError, v } from "valleyed";
-import { Instance } from "../instance/index.js";
-const filePipe = (err) => v.array(
-  v.file(err).pipe((input) => {
-    const err2 = `is larger than allowed limit of ${Instance.get().settings.utils.maxFileUploadSizeInMb}mb`;
-    const valid = input ? !input.isTruncated : true;
-    if (valid) return input;
-    throw PipeError.root(err2, input);
-  })
-);
-const incomingFile = (err) => v.define(
-  v.compile(
-    filePipe(err).pipe(v.min(1, "no file provided")).pipe((files) => files[0])
-  ),
-  { schema: () => ({ type: "string", format: "binary" }) }
-);
-const incomingFiles = (err) => v.define(v.compile(filePipe(err)), {
-  schema: () => ({ type: "string", format: "binary" })
-});
-const requestLocalStorage = new AsyncLocalStorage();
-const responseLocalStorage = new AsyncLocalStorage();
-const withRequest = (fn) => v.define((input) => {
-  const req = requestLocalStorage.getStore();
-  if (!req) throw new Error("Request not found in context");
-  const validated = v.validate(fn(req), input);
-  return validated.valid ? validated.value : validated.error;
-});
-const withResponse = (fn) => v.define((input) => {
-  const res = responseLocalStorage.getStore();
-  if (!res) throw new Error("Response not found in context");
-  const validated = v.validate(fn(res), input);
-  return validated.valid ? validated.value : validated.error;
-});
-export {
-  incomingFile,
-  incomingFiles,
-  requestLocalStorage,
-  responseLocalStorage,
-  withRequest,
-  withResponse
-};