@edirect/tokenization 0.0.10 → 11.0.25

package/dist/index.js

@@ -1,443 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  Tokenization: () => Tokenization
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/core/traverser/index.ts
-var traverse = (obj, callback, path = []) => {
-  if (Array.isArray(obj)) {
-    obj.forEach((value, index) => {
-      traverse(value, callback, [...path, `${index}`]);
-    });
-  } else if (obj !== null && typeof obj === "object") {
-    Object.keys(obj).forEach((key) => {
-      traverse(obj[key], callback, [...path, key]);
-    });
-  } else {
-    callback(obj, path);
-  }
-};
-
-// src/core/utils/object.ts
-var get = (obj, path) => {
-  let currentObj = obj;
-  for (let i = 0; i < path.length; i++) {
-    const key = path[i];
-    if (currentObj[key] !== void 0) {
-      currentObj = currentObj[key];
-    } else {
-      return void 0;
-    }
-  }
-  return currentObj;
-};
-var set = (obj, path, value) => {
-  let currentObj = obj;
-  for (let i = 0; i < path.length; i++) {
-    const key = path[i];
-    if (i === path.length - 1) {
-      currentObj[key] = value;
-    } else {
-      if (!currentObj[key] || typeof currentObj[key] !== "object") {
-        currentObj[key] = isNaN(Number(path[i + 1])) ? {} : [];
-      }
-      currentObj = currentObj[key];
-    }
-  }
-};
-
-// src/core/evaluator/basic.ts
-var BasicEvaluator = class {
-  Evaluate(path, ...properties) {
-    const pathSegments = path.split(".");
-    const propertiesSegments = properties;
-    let i = 0, j = 0;
-    while (i < pathSegments.length && j < propertiesSegments.length) {
-      if (pathSegments[i] === "**") {
-        if (i === pathSegments.length - 1) {
-          return true;
-        }
-        i++;
-        while (j < propertiesSegments.length && propertiesSegments[j] !== pathSegments[i]) {
-          j++;
-        }
-      } else if (pathSegments[i] === "*" || pathSegments[i] === propertiesSegments[j]) {
-        i++;
-        j++;
-      } else {
-        return false;
-      }
-    }
-    return i === pathSegments.length && j === propertiesSegments.length;
-  }
-};
-
-// src/core/evaluator/index.ts
-var TokenEvaluator = class {
-  evaluator;
-  constructor(evaluator) {
-    this.evaluator = evaluator || new BasicEvaluator();
-  }
-  shouldTokenizeField(config, path) {
-    if (!config) {
-      return false;
-    }
-    if (config.fields.length === 0) {
-      return config.defaultClassification > 0;
-    }
-    const ret = config.fields.map((field) => {
-      if (!field.classification) {
-        return false;
-      }
-      return this.evaluator.Evaluate(field.path, ...path);
-    });
-    return ret.some((r) => r) || config.defaultClassification > 0;
-  }
-};
-
-// src/core/app.ts
-var import_lru_cache = require("lru-cache");
-var TokenizationApp = class {
-  cache;
-  tokenizationService;
-  configurationService;
-  evaluator;
-  constructor(tokenizationService, configurationService, evaluator) {
-    this.tokenizationService = tokenizationService;
-    this.configurationService = configurationService;
-    this.evaluator = new TokenEvaluator(evaluator);
-    this.cache = new import_lru_cache.LRUCache({
-      max: 5e3,
-      ttl: 1e3 * 60 * 1,
-      // 1 minute
-      allowStale: false,
-      updateAgeOnGet: false,
-      updateAgeOnHas: false
-    });
-  }
-  async tokenize(auth, tenant, configKey, payload) {
-    const config = await this.configurationService.get(auth, tenant, configKey);
-    if (!config) return payload;
-    if ((!config.fields || config.fields.length === 0) && config.defaultClassification === 0)
-      return payload;
-    const respPayload = payload;
-    const processedPayload = await this.processRequest(config, payload);
-    if (Object.keys(processedPayload.notFound).length > 0) {
-      const tokenPayload = await this.tokenizationService.tokenize(
-        auth,
-        tenant,
-        configKey,
-        processedPayload.notFound
-      );
-      for (const key in tokenPayload) {
-        const path = key.split(".");
-        const token = tokenPayload[key];
-        const original = get(respPayload, path);
-        set(respPayload, path, token);
-        if (typeof token === "string") {
-          this.cache.set(token, original);
-          this.cache.set(original.toString(), token);
-        }
-      }
-    }
-    if (Object.keys(processedPayload.found).length > 0) {
-      for (const key in processedPayload.found) {
-        set(respPayload, key.split("."), processedPayload.found[key]);
-      }
-    }
-    return respPayload;
-  }
-  async detokenize(auth, tenant, configKey, payload) {
-    const config = await this.configurationService.get(auth, tenant, configKey);
-    if (!config) return payload;
-    if ((!config.fields || config.fields.length === 0) && config.defaultClassification === 0)
-      return payload;
-    const respPayload = payload;
-    const processedPayload = this.processRequest(config, payload);
-    if (Object.keys(processedPayload.notFound).length > 0) {
-      const tokenPayload = await this.tokenizationService.detokenize(
-        auth,
-        tenant,
-        configKey,
-        processedPayload.notFound
-      );
-      for (const key in tokenPayload) {
-        const path = key.split(".");
-        const token = get(respPayload, path);
-        const original = tokenPayload[key];
-        if (typeof original === "string") {
-          this.cache.set(token, original);
-          this.cache.set(original.toString(), token);
-        }
-        set(respPayload, key.split("."), original);
-      }
-    }
-    if (Object.keys(processedPayload.found).length > 0) {
-      for (const key in processedPayload.found) {
-        set(respPayload, key.split("."), processedPayload.found[key]);
-      }
-    }
-    return respPayload;
-  }
-  processRequest(config, payload) {
-    if (config.fields.length === 0) {
-      return {
-        found: payload,
-        notFound: {}
-      };
-    }
-    const req = {
-      found: {},
-      notFound: {}
-    };
-    traverse(payload, (value, path) => {
-      if (!value) return;
-      if (this.evaluator.shouldTokenizeField(config, path)) {
-        const fromCache = this.cache.get(value.toString());
-        if (fromCache) {
-          req.found[path.join(".")] = fromCache;
-        } else {
-          req.notFound[path.join(".")] = value;
-        }
-      }
-    });
-    return req;
-  }
-};
-
-// src/core/services/configuration.ts
-var import_lru_cache2 = require("lru-cache");
-var import_axios = __toESM(require("axios"));
-var ConfigurationService = class {
-  constructor(baseUrl) {
-    this.baseUrl = baseUrl;
-    if (!this.baseUrl) {
-      throw new Error("Configuration Service BaseUrl is required");
-    }
-    this.cache = new import_lru_cache2.LRUCache({
-      max: 100,
-      ttl: 1e3 * 60 * 5,
-      // 5 minutes
-      allowStale: false,
-      updateAgeOnGet: false,
-      updateAgeOnHas: false
-    });
-  }
-  cache;
-  async get(auth, tenant, config) {
-    const cached = this.cache.get(`${tenant}/${config}`);
-    if (cached) {
-      return cached;
-    }
-    try {
-      const resp = await import_axios.default.get(
-        `${this.baseUrl}/api/v1/${tenant}/${config}/config`,
-        {
-          headers: {
-            Authorization: `Bearer ${auth}`
-          }
-        }
-      );
-      const data = resp.data;
-      this.cache.set(`${tenant}/${config}`, data);
-      return data;
-    } catch (error) {
-      if (import_axios.default.isAxiosError(error) && error.response?.status === 404) {
-        return void 0;
-      }
-      throw new Error("Failed to get configuration");
-    }
-  }
-  async create(auth, tenant, config) {
-    try {
-      await import_axios.default.post(
-        `${this.baseUrl}/api/v1/${tenant}/${config.key}/config`,
-        config,
-        {
-          headers: {
-            Authorization: `Bearer ${auth}`,
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      return config;
-    } catch (error) {
-      throw new Error("Failed to create configuration");
-    }
-  }
-  async update(auth, tenant, config) {
-    try {
-      await import_axios.default.put(
-        `${this.baseUrl}/api/v1/${tenant}/${config.key}/config`,
-        config,
-        {
-          headers: {
-            Authorization: `Bearer ${auth}`,
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      return config;
-    } catch (error) {
-      throw new Error("Failed to update configuration");
-    }
-  }
-  async delete(auth, tenant, config) {
-    try {
-      await import_axios.default.delete(
-        `${this.baseUrl}/api/v1/${tenant}/${config}/config`,
-        {
-          headers: {
-            Authorization: `Bearer ${auth}`
-          }
-        }
-      );
-    } catch (error) {
-      throw new Error("Failed to delete configuration");
-    }
-  }
-};
-
-// src/core/services/tokenization.ts
-var import_axios2 = __toESM(require("axios"));
-var TokenizationService = class {
-  constructor(baseUrl) {
-    this.baseUrl = baseUrl;
-    if (!this.baseUrl) {
-      throw new Error("Tokenization Service BaseUrl is required");
-    }
-  }
-  async tokenize(auth, tenant, config, payload) {
-    try {
-      const resp = await import_axios2.default.post(
-        `${this.baseUrl}/api/v1/${tenant}/${config}/token/tokenize`,
-        payload,
-        {
-          headers: {
-            "Authorization": `Bearer ${auth}`,
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      return resp.data;
-    } catch (error) {
-      throw new Error("Failed to tokenize payload");
-    }
-  }
-  async detokenize(auth, tenant, config, payload) {
-    try {
-      const resp = await import_axios2.default.post(
-        `${this.baseUrl}/api/v1/${tenant}/${config}/token/detokenize`,
-        payload,
-        {
-          headers: {
-            "Authorization": `Bearer ${auth}`,
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      return resp.data;
-    } catch (error) {
-      throw new Error("Failed to detokenize payload");
-    }
-  }
-};
-
-// src/index.ts
-var Tokenization = class {
-  app;
-  /**
-   * The constructor of the TokenizationClient class.
-   * @param url The URL of the tokenization server.
-   */
-  constructor(baseUrlOrApp) {
-    if (baseUrlOrApp && typeof baseUrlOrApp !== "string") {
-      this.app = baseUrlOrApp;
-      return;
-    }
-    const tokenizationService = new TokenizationService(baseUrlOrApp);
-    const configurationService = new ConfigurationService(
-      baseUrlOrApp
-    );
-    this.app = new TokenizationApp(tokenizationService, configurationService);
-    return;
-  }
-  /**
-   * Tokenizes the given payload.
-   * @param tenant The tenant to tokenize the payload for.
-   * @param payload The payload to tokenize.
-   * @returns The tokenized payload.
-   */
-  tokenize(auth, tenant, config, payload) {
-    return this.app.tokenize(auth, tenant, config, payload);
-  }
-  /**
-   * Detokenizes the given payload.
-   * @param tenant The tenant to detokenize the payload for.
-   * @param payload The payload to detokenize.
-   * @returns The detokenized payload.
-   */
-  detokenize(auth, tenant, config, payload) {
-    return this.app.detokenize(auth, tenant, config, payload);
-  }
-  static parseToken(token) {
-    const parts = token.split(":");
-    if (parts.length !== 4) {
-      return {
-        isToken: false,
-        tenant: "",
-        type: "",
-        hash: ""
-      };
-    }
-    if (parts[0] !== "token") {
-      return {
-        isToken: false,
-        tenant: "",
-        type: "",
-        hash: ""
-      };
-    }
-    return {
-      isToken: true,
-      tenant: parts[1],
-      type: parts[2],
-      hash: parts[3]
-    };
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Tokenization
-});