@edirect/tokenization 0.0.9 → 11.0.25

package/dist/index.mjs

@@ -1,406 +0,0 @@
-// 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
-import { LRUCache } from "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 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
-import { LRUCache as LRUCache2 } from "lru-cache";
-var ConfigurationService = class {
-  constructor(baseUrl) {
-    this.baseUrl = baseUrl;
-    if (!this.baseUrl) {
-      throw new Error("Configuration Service BaseUrl is required");
-    }
-    this.cache = new LRUCache2({
-      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;
-    }
-    const resp = await fetch(
-      `${this.baseUrl}/api/v1/${tenant}/${config}/config`,
-      {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${auth}`
-        }
-      }
-    );
-    if (resp.status === 404) {
-      return void 0;
-    }
-    if (resp.status !== 200) {
-      throw new Error("Failed to get configuration");
-    }
-    const data = await resp.json();
-    this.cache.set(`${tenant}/${config}`, data);
-    return data;
-  }
-  async create(auth, tenant, config) {
-    const resp = await fetch(
-      `${this.baseUrl}/api/v1/${tenant}/${config.key}/config`,
-      {
-        method: "POST",
-        body: JSON.stringify(config),
-        headers: {
-          Authorization: `Bearer ${auth}`,
-          "Content-Type": "application/json"
-        }
-      }
-    );
-    if (resp.status !== 200) {
-      throw new Error("Failed to create configuration");
-    }
-    return config;
-  }
-  async update(auth, tenant, config) {
-    const respo = await fetch(
-      `${this.baseUrl}/api/v1/${tenant}/${config.key}/config`,
-      {
-        method: "PUT",
-        body: JSON.stringify(config),
-        headers: {
-          Authorization: `Bearer ${auth}`,
-          "Content-Type": "application/json"
-        }
-      }
-    );
-    if (respo.status !== 200) {
-      throw new Error("Failed to update configuration");
-    }
-    return config;
-  }
-  async delete(auth, tenant, config) {
-    const resp = await fetch(
-      `${this.baseUrl}/api/v1/${tenant}/${config}/config`,
-      {
-        method: "DELETE",
-        headers: {
-          Authorization: `Bearer ${auth}`
-        }
-      }
-    );
-    if (resp.status !== 204) {
-      throw new Error("Failed to delete configuration");
-    }
-  }
-};
-
-// src/core/services/tokenization.ts
-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) {
-    const resp = await fetch(
-      `${this.baseUrl}/api/v1/${tenant}/${config}/token/tokenize`,
-      {
-        method: "POST",
-        body: JSON.stringify(payload),
-        headers: {
-          "Authorization": `Bearer ${auth}`,
-          "Content-Type": "application/json"
-        }
-      }
-    );
-    if (resp.status !== 200) {
-      throw new Error("Failed to tokenize payload");
-    }
-    const data = await resp.json();
-    return data;
-  }
-  async detokenize(auth, tenant, config, payload) {
-    const resp = await fetch(
-      `${this.baseUrl}/api/v1/${tenant}/${config}/token/detokenize`,
-      {
-        method: "POST",
-        body: JSON.stringify(payload),
-        headers: {
-          "Authorization": `Bearer ${auth}`,
-          "Content-Type": "application/json"
-        }
-      }
-    );
-    if (resp.status !== 200) {
-      throw new Error("Failed to detokenize payload");
-    }
-    const data = await resp.json();
-    return data;
-  }
-};
-
-// 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]
-    };
-  }
-};
-export {
-  Tokenization
-};