@trap_stevo/filetide/dist/cjs/HUDManagers/TideTokenEnforcementManager.js

Revolutionizing real-time file transfer with seamless, instant communication across any device. Deliver files instantly, regardless of platform, and experience unparalleled speed and control in managing transfers. Elevate your file-sharing capabilities wi

"use strict";

const LogicTide = require("@trap_stevo/logictide");
const Lockline = require("@trap_stevo/lockline");
const axios = require("axios");
const {
  FileTideDebugUtilityManager,
  significantMessageColors,
  noticeMessageColors,
  infoMessageColors,
  infoAccentMessageColors,
  errorMessageColors
} = require("./FileTideDebugUtilityManager.js");
const {
  displayFileTideAuthor,
  displayFileTideTitle,
  displayFileTideLogo
} = require("./FileTideUniversalUtilityManager.js");
class TideTokenEnforcementManager {
  constructor(options = {}) {
    const {
      tideTokenEnforcementCallbackConfigurations = {},
      onDidNotLoadRecentTideTokens
    } = options;
    this.tideTokenEnforcementCallbackConfigurations = tideTokenEnforcementCallbackConfigurations;
    this.tideTokenEnforcementComplianceHandlers = this.generateTideTokenEnforcementHandlers();
    this.lock = new Lockline();
    const lockboxPath = LogicTide.runSync("filetide-root-path") ? `${LogicTide.runSync("filetide-root-path")}/.lockbox` : "./lockbox";
    this.lock.setStorage(Lockline.lockbox(lockboxPath, {
      namespace: "tide-tokens",
      encrypt: true
    }));
    this.lock.registerValidator("tide-token-authorization", async ({
      key
    }) => {
      const fileTideAPIURL = await LogicTide.run("filetide-api-origin-url");
      const response = await axios.get(`${fileTideAPIURL}/tide-token-auth/authorized-tide-token`, {
        params: {
          inputTideToken: key
        }
      });
      return {
        valid: response.data.authorizedTideToken,
        raw: response.data.details,
        reason: response.data.message
      };
    });
    this.lock.setDefaultValidator("tide-token-authorization");
    this.loadedRecentLicenseKeys = this.lock.loadRecentLicenseKeys().catch(error => {
      if (typeof onDidNotLoadRecentTideTokens === "function") {
        onDidNotLoadRecentTideTokens(error);
      }
    });
    this.enforcerOverviewMetrics = {
      "tide-token-authorized": 0,
      "tide-token-blocked": 0,
      "tide-token-missing": 0,
      "tide-token-invalid": 0
    };
  }
  updateTideTokenEnforcementCallbackConfigurations(updatedConfigurations = {}) {
    this.tideTokenEnforcementCallbackConfigurations = {
      ...this.tideTokenEnforcementCallbackConfigurations,
      ...updatedConfigurations
    };
    this.tideTokenEnforcementComplianceHandlers = this.generateTideTokenEnforcementHandlers();
  }
  generateTideTokenEnforcementHandlers() {
    const {
      onLicenseBlocked,
      onMissingLicense,
      onInvalidLicense,
      onSuccess
    } = this.tideTokenEnforcementCallbackConfigurations;
    const url = "https://filetide.com/tider-portal";
    return {
      onLicenseBlocked: enforcedDetails => {
        FileTideDebugUtilityManager.outputGradient(`[FileTide | ${new Date().toLocaleString()}] ~ ❌ TideToken Blocked\n`, errorMessageColors);
        FileTideDebugUtilityManager.outputGradient(`\t→ Visit ~ ${url} to configure / create TideTokens.\n`, infoAccentMessageColors);
        FileTideDebugUtilityManager.outputGradient(`| ${new Date().toLocaleString()} |`, infoAccentMessageColors);
        FileTideDebugUtilityManager.outputGradient(`${"-".repeat(130)}\n`, infoAccentMessageColors);
        this.enforcerOverviewMetrics["tide-token-blocked"] += 1;
        onLicenseBlocked?.(enforcedDetails);
      },
      onMissingKey: enforcedDetails => {
        displayFileTideLogo();
        displayFileTideTitle();
        FileTideDebugUtilityManager.outputGradient(`[FileTide] ~ Welcome!\n`, significantMessageColors);
        FileTideDebugUtilityManager.outputGradient("\t~ No TideToken(s) Detected\n", significantMessageColors);
        FileTideDebugUtilityManager.outputGradient(`\t→ Visit ~ ${url} to create TideTokens.\n`, infoMessageColors);
        FileTideDebugUtilityManager.outputGradient(`| ${new Date().toLocaleString()} |`, infoAccentMessageColors);
        FileTideDebugUtilityManager.outputGradient(`${"-".repeat(130)}\n`, infoAccentMessageColors);
        this.enforcerOverviewMetrics["tide-token-missing"] += 1;
        onMissingLicense?.(enforcedDetails);
      },
      onInvalidKey: enforcedDetails => {
        FileTideDebugUtilityManager.outputGradient(`[FileTide | ${new Date().toLocaleString()}] ~ ❌ TideToken Unauthorized\n`, errorMessageColors);
        FileTideDebugUtilityManager.outputGradient(`\t→ Visit ~ ${url} to configure / create TideTokens.\n`, infoAccentMessageColors);
        FileTideDebugUtilityManager.outputGradient(`| ${new Date().toLocaleString()} |`, infoAccentMessageColors);
        FileTideDebugUtilityManager.outputGradient(`${"-".repeat(130)}\n`, infoAccentMessageColors);
        this.enforcerOverviewMetrics["tide-token-invalid"] += 1;
        onInvalidLicense?.(enforcedDetails);
      },
      onSuccess: enforcedDetails => {
        FileTideDebugUtilityManager.outputGradient(`[FileTide | ${new Date().toLocaleString()}] ~ ✅ TideToken Authorized\n`, significantMessageColors);
        if (this.enforcerOverviewMetrics["tide-token-authorized"] <= 0) {
          FileTideDebugUtilityManager.outputGradient(`\t→ Configure TideTokens at ${url}\n`, noticeMessageColors);
        }
        FileTideDebugUtilityManager.outputGradient(`| ${new Date().toLocaleString()} |`, infoAccentMessageColors);
        FileTideDebugUtilityManager.outputGradient(`${"-".repeat(130)}\n`, infoAccentMessageColors);
        this.enforcerOverviewMetrics["tide-token-authorized"] += 1;
        onSuccess?.(enforcedDetails);
      }
    };
  }
  protect(handler, scope, options = {}) {
    return async (...args) => {
      await this.loadedRecentLicenseKeys;
      const protectedHandler = this.lock.withLicenseProtection(handler, scope, {
        ...(options ?? {}),
        ...this.tideTokenEnforcementComplianceHandlers
      });
      return await protectedHandler(...args);
    };
  }
  getKey(scope = "default") {
    return this.lock.getCurrentLicenseKey(scope);
  }
  async seal(key, meta = {}) {
    return await this.lock.sealKey(key, {
      validators: [{
        name: "tide-token-authorization"
      }],
      meta
    }, {
      assumePreviouslyValid: true,
      fallbackIfOffline: true,
      autoRemoveExpired: true,
      storeInvalid: false
    });
  }
  async validate(key) {
    return await this.lock.validate(key);
  }
  async inspect(key) {
    return await this.lock.inspectKey(key);
  }
}
;
module.exports = new TideTokenEnforcementManager();