@trap_stevo/veripath/dist/cjs/VeriPath.js

The pinnacle of real-time encrypted routing and session-bound communication through a precision-crafted middleware system. Empowering developers to secure every route with dynamic request decryption, intelligent session validation, and seamless encrypted

"use strict";

const {
  VeriAuth
} = require("@trap_stevo/veriauth");
const express = require("express");
const {
  createDecryptRequest,
  createEncryptResponse
} = require("./HUDManagers/SecurityManager.js");
const {
  veriVaultManager
} = require("./HUDManagers/VeriVaultManager.js");
class VeriPath {
  constructor(options = {}) {
    this.routerInstance = express.Router();
    this.options = options;
    const {
      restoreSessionsPaths = true,
      persistSessionKey = false,
      persistSessionID = false,
      mutator = "vlk",
      vaultSGN = "vlx",
      linkSGN = "vli",
      sessionIDExtractor = null,
      veriAuthConfigurations = {},
      enablePairing = false,
      pairingGuard = null,
      pairingPath = "/device/pair"
    } = options;
    veriVaultManager.configure({
      persistSessionKey,
      persistSessionID,
      mutator,
      vaultSGN,
      linkSGN
    });
    if (restoreSessionsPaths) {
      veriVaultManager.restorePaths();
    }
    if (sessionIDExtractor) {
      veriVaultManager.setCustomSessionIDExtractor(sessionIDExtractor);
    }
    if (enablePairing) {
      this.enablePairingRoute(pairingPath, pairingGuard, veriAuthConfigurations);
    }
    const encrypt = createEncryptResponse(options);
    const decrypt = createDecryptRequest(options);
    for (const method of ["get", "post", "put", "patch", "delete", "options", "head"]) {
      this[method] = (path, ...handlers) => {
        const pairingRoute = path === pairingPath;
        const stack = pairingRoute ? handlers : [decrypt, encrypt, ...handlers];
        return this.routerInstance[method](path, ...stack);
      };
    }
  }
  enablePairingRoute(path = "/veriauth/pair", verifierMiddleware = null, veriAuthConfigurations = {}) {
    const auth = new VeriAuth({
      onKey: async (sessionID, keyBuffer, req) => {
        if (verifierMiddleware && !req.user) {
          throw new Error("Unauthenticated");
        }
        await veriVaultManager.setKey(sessionID, keyBuffer);
      },
      containsKey: async sessionID => {
        return await veriVaultManager.containsKey(sessionID);
      },
      acceptAlreadyPaired: true,
      allowAuthOverwrite: false,
      ...(veriAuthConfigurations || {})
    });
    const handlers = verifierMiddleware ? [verifierMiddleware, auth.middleware()] : [auth.middleware()];
    this.routerInstance.post(path, ...handlers);
  }
  router() {
    return this.routerInstance;
  }
}
;
module.exports = {
  VeriPath
};