@commercetools/processors 0.0.0

package/dist/index.js

@@ -0,0 +1,476 @@
+"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 index_exports = {};
+__export(index_exports, {
+  FieldFilteringHandler: () => FieldFilteringHandler,
+  defaultFilteringRules: () => defaultFilteringRules,
+  defaultJsonRedactionText: () => defaultJsonRedactionText,
+  defaultUrlRedactionText: () => defaultUrlRedactionText,
+  generateQueryString: () => generateQueryString,
+  isFieldFilteringManager: () => isFieldFilteringManager,
+  isValidUrl: () => isValidUrl,
+  normaliseUrl: () => normaliseUrl,
+  transformPropertyName: () => transformPropertyName,
+  transformToolOutput: () => transformToolOutput
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/field-filtering/defaultFilteringRules.ts
+var defaultJsonRedactionText = "[REDACTED]";
+var defaultUrlRedactionText = "REDACTED";
+var defaultFilteringRules = {
+  jsonRedactionText: defaultJsonRedactionText,
+  urlRedactionText: defaultUrlRedactionText
+};
+
+// src/field-filtering/urlHelpers.ts
+var import_qs = __toESM(require("qs"));
+var normaliseUrl = (url) => {
+  const protocolSplit = url.split("//");
+  let normalisedUrl = "";
+  if (protocolSplit[0] && (protocolSplit[0] === "http:" || protocolSplit[0] === "https:" || protocolSplit[0] === "ws:" || protocolSplit[0] === "wss:")) {
+    normalisedUrl = `${protocolSplit[0]}//`;
+    protocolSplit.splice(0, 1);
+  }
+  let query = "";
+  const querySplit = protocolSplit.join("//").split("?");
+  if (querySplit.length > 1) {
+    query = `?${querySplit.slice(1, querySplit.length).join("?")}`;
+  }
+  const pathSplit = querySplit[0].split("/");
+  for (let n = 0; n < pathSplit.length; n++) {
+    if (pathSplit[n]) {
+      normalisedUrl += `${pathSplit[n]}/`;
+    }
+  }
+  normalisedUrl = normalisedUrl.substring(0, normalisedUrl.length - 1);
+  return normalisedUrl + query;
+};
+var toQueryObject = (key, value) => {
+  const obj = {};
+  obj[key] = value;
+  return obj;
+};
+var toQueryString = (obj) => {
+  return import_qs.default.stringify(obj, {
+    arrayFormat: "indices",
+    encodeValuesOnly: true,
+    format: "RFC3986"
+  });
+};
+var generateQueryString = (query) => {
+  let queryString = "?";
+  Object.keys(query).forEach((key) => {
+    const value = query[key];
+    if (value !== void 0 && typeof value !== "function") {
+      if (value === null) {
+        queryString += `${key}=null&`;
+      } else {
+        queryString += `${toQueryString(toQueryObject(key, value))}&`;
+      }
+    }
+  });
+  queryString = queryString.substring(0, queryString.length - 1);
+  return queryString;
+};
+var isValidUrl = (urlLike) => {
+  let url;
+  try {
+    url = new URL(urlLike);
+  } catch (_) {
+    return false;
+  }
+  return true;
+};
+
+// src/field-filtering/FieldFilteringHandler.ts
+var FieldFilteringHandler = class {
+  filterPaths;
+  redactPaths;
+  filterProperties;
+  redactProperties;
+  whitelistPaths;
+  filterIncludes;
+  redactIncludes;
+  jsonRedactionText;
+  urlRedactionText;
+  hasFilteringRules = true;
+  constructor(config) {
+    this.filterPaths = config.paths?.filter((path) => path.type === "filter") ?? [];
+    this.redactPaths = config.paths?.filter((path) => path.type === "redact") ?? [];
+    this.filterProperties = config.properties?.filter((path) => path.type === "filter") ?? [];
+    this.redactProperties = config.properties?.filter((path) => path.type === "redact") ?? [];
+    this.whitelistPaths = config.whitelistPaths ?? [];
+    this.filterIncludes = config.includes?.filter((path) => path.type === "filter") ?? [];
+    this.redactIncludes = config.includes?.filter((path) => path.type === "redact") ?? [];
+    this.jsonRedactionText = config.jsonRedactionText ?? defaultJsonRedactionText;
+    this.urlRedactionText = config.urlRedactionText ?? defaultUrlRedactionText;
+    if (config.paths?.length === 0 && config.properties?.length === 0 && config.includes?.length === 0) {
+      this.hasFilteringRules = false;
+    }
+  }
+  filterFields(data, currentPath) {
+    if (this.hasFilteringRules === false) {
+      return data;
+    }
+    if (this.filterConditionMet(currentPath ?? "", "redact")) {
+      return this.jsonRedactionText;
+    }
+    if (typeof data === "string") {
+      if (isValidUrl(data)) {
+        return this.filterUrlFields(data);
+      }
+      return data;
+    }
+    if (typeof data === "object") {
+      if (Array.isArray(data)) {
+        return data.map(
+          (datum) => this.filterFields(datum, currentPath)
+        );
+      } else if (data) {
+        Object.keys(data).forEach((key) => {
+          const newPath = currentPath ? `${currentPath}.${key}` : key;
+          if (this.filterConditionMet(newPath, "filter")) {
+            delete data[key];
+          } else {
+            data[key] = this.filterFields(
+              data[key],
+              newPath
+            );
+          }
+        });
+        return data;
+      }
+    }
+    return data;
+  }
+  filterConditionMet(path, type) {
+    let ruleIsSatisfied = this.testFilterRules(path, this.whitelistPaths);
+    if (ruleIsSatisfied) {
+      return false;
+    }
+    ruleIsSatisfied = this.testFilterRules(path, this[`${type}Paths`]);
+    if (ruleIsSatisfied) {
+      return true;
+    }
+    const properties = path.split(".");
+    const propertyName = properties[properties.length - 1];
+    ruleIsSatisfied = this.testFilterRules(
+      propertyName,
+      this[`${type}Properties`]
+    );
+    if (ruleIsSatisfied) {
+      return true;
+    }
+    const includes = this[`${type}Includes`];
+    for (let n = 0; n < includes.length; n++) {
+      if (propertyName.includes(includes[n].value) || !includes[n].caseSensitive && propertyName.toLowerCase().includes(includes[n].value.toLowerCase())) {
+        n = includes.length;
+        ruleIsSatisfied = true;
+      }
+    }
+    return ruleIsSatisfied;
+  }
+  // checks regardless of "filter" | "redact"
+  testFilterRules(path, rules) {
+    let ruleIsSatisfied = false;
+    for (let n = 0; n < rules.length; n++) {
+      if (path === rules[n].value || !rules[n].caseSensitive && path.toLowerCase() === rules[n].value.toLowerCase()) {
+        n = rules.length;
+        ruleIsSatisfied = true;
+      }
+    }
+    return ruleIsSatisfied;
+  }
+  filterUrlFields(inputUrl) {
+    if (this.hasFilteringRules === false) {
+      return inputUrl;
+    }
+    const url = new URL(inputUrl);
+    const urlParams = new URLSearchParams(url.search);
+    const keysToDelete = [];
+    for (const [key, _] of urlParams.entries()) {
+      if (this.filterConditionMet(this.urlQueryKeyToObjectPath(key), "filter")) {
+        keysToDelete.push(key);
+      } else if (this.filterConditionMet(this.urlQueryKeyToObjectPath(key), "redact")) {
+        urlParams.set(key, this.urlRedactionText);
+      }
+    }
+    keysToDelete.forEach((key) => urlParams.delete(key));
+    url.search = urlParams.toString();
+    return url.toString();
+  }
+  // assumes keys of string only
+  urlQueryKeyToObjectPath(urlQueryKey) {
+    const urlQueryKeyOpenBracketSplit = urlQueryKey.split("[");
+    if (urlQueryKeyOpenBracketSplit.length === 1) {
+      return urlQueryKey;
+    } else {
+      let objectPath = urlQueryKeyOpenBracketSplit.splice(0, 1)[0];
+      urlQueryKeyOpenBracketSplit.forEach((openBracketSplitValue, n) => {
+        const closeBracketSplit = openBracketSplitValue.split("]");
+        if (closeBracketSplit.length !== 2) {
+          console.warn(
+            `Object in URL params in incorrect format: [${urlQueryKeyOpenBracketSplit[n]}`
+          );
+        }
+        if (!closeBracketSplit[0].match(/^-?\d+$/)) {
+          objectPath += `.${closeBracketSplit[0]}`;
+        }
+      });
+      return objectPath;
+    }
+  }
+};
+
+// src/field-filtering/index.ts
+var isFieldFilteringManager = (config) => {
+  return Boolean(
+    config?.filterFields && config?.filterUrlFields
+  );
+};
+
+// src/transform/transformPropertyName.ts
+var isUpperCase = (str) => str !== str.toLowerCase();
+var transformPropertyName = (propertyName) => {
+  if (!propertyName) {
+    return "";
+  }
+  propertyName = propertyName.replaceAll(/[_-]+/g, " ").trim();
+  let newPropertyName = propertyName.charAt(0).toLocaleUpperCase();
+  for (let n = 1; n < propertyName.length; n++) {
+    const char = propertyName.charAt(n);
+    if (!isUpperCase(char)) {
+      if (propertyName.charAt(n - 1) === " ") {
+        if (char !== " ") {
+          newPropertyName += char.toUpperCase();
+        }
+      } else {
+        newPropertyName += char;
+      }
+    } else {
+      if (propertyName.charAt(n - 1) !== " ") {
+        newPropertyName += " ";
+      }
+      newPropertyName += char;
+      const i = 1;
+      let nextChar = propertyName.charAt(n + i);
+      if (isUpperCase(nextChar)) {
+        do {
+          nextChar = propertyName.charAt(n + i);
+          if (isUpperCase(nextChar)) {
+            newPropertyName += nextChar;
+            n += 1;
+          }
+        } while (nextChar !== nextChar.toLowerCase());
+      }
+    }
+  }
+  return newPropertyName;
+};
+
+// src/transform/transformToolOutput.ts
+var emptyObjectTransformValue = "no properties";
+var emptyArrayTransformValue = "none";
+var generateTabs = (tabCount) => {
+  let tabs = "";
+  for (let n = 0; n < tabCount; n++) {
+    tabs += "	";
+  }
+  return tabs;
+};
+var transformToolOutput = (args) => {
+  const { data, title, format } = args;
+  if (isPropertyTypeToBeIgnored(data)) {
+    return title ? `${transformTitle(title)}
+${emptyObjectTransformValue}` : emptyObjectTransformValue;
+  }
+  if (format === "json") {
+    if (title) {
+      return JSON.stringify({
+        [transformTitle(title)]: data
+      });
+    }
+    return JSON.stringify(data);
+  }
+  let transformedDataAggregate = "";
+  if (title) {
+    transformedDataAggregate = `${transformTitle(title)}
+`;
+  }
+  const transformedData = transformData({ data, tabCount: -1 });
+  return transformedDataAggregate += transformedData ?? emptyObjectTransformValue;
+};
+var transformTitle = (title) => `${transformPropertyName(title).toUpperCase()}`;
+var transformData = (args) => {
+  const { data, tabCount } = args;
+  if (isPropertyTypeToBeIgnored(data)) {
+    return null;
+  }
+  switch (typeof data) {
+    case "string": {
+      if (data === "") {
+        return '""';
+      }
+      return data;
+    }
+    case "number":
+    case "bigint": {
+      return data.toString();
+    }
+    case "boolean": {
+      return data ? "Yes" : "No";
+    }
+    case "object": {
+      if (data === null) {
+        return "null";
+      }
+      if (Array.isArray(data)) {
+        return handleArrayTransformation({ array: data, tabCount });
+      }
+      return handleObjectTransformation({
+        data,
+        tabCount
+      });
+    }
+    default:
+      return null;
+  }
+};
+var handleArrayTransformation = (args) => {
+  const { array, tabCount } = args;
+  if (array.length === 0) {
+    return emptyArrayTransformValue;
+  }
+  if (isArrayWithoutObjectsOrArrays(array)) {
+    const simpleTransformedArray = array.reduce(
+      (previousValue, currentValue) => {
+        const transformedCurrentValue = transformData({
+          data: currentValue,
+          tabCount
+        });
+        if (transformedCurrentValue === null) {
+          return previousValue;
+        }
+        if (previousValue) {
+          return `${previousValue}, ${transformedCurrentValue}`;
+        } else {
+          return transformedCurrentValue;
+        }
+      },
+      ""
+    );
+    return simpleTransformedArray === "" ? emptyArrayTransformValue : simpleTransformedArray;
+  }
+  let transformedData = "";
+  let unignoredArrayPropertyIndex = 0;
+  array.forEach((value) => {
+    if (!isPropertyTypeToBeIgnored(value)) {
+      transformedData += transformObjectOrArrayContent({
+        key: unignoredArrayPropertyIndex.toString(),
+        value,
+        tabCount
+      });
+      transformedData += "\n";
+      unignoredArrayPropertyIndex += 1;
+    }
+  });
+  if (transformedData === "") {
+    return emptyArrayTransformValue;
+  }
+  return transformedData.substring(0, transformedData.length - 1);
+};
+var handleObjectTransformation = (args) => {
+  const { data, tabCount } = args;
+  let transformedData = "";
+  Object.keys(data).forEach((key) => {
+    if (!isPropertyTypeToBeIgnored(data[key])) {
+      transformedData += transformObjectOrArrayContent({
+        key,
+        value: data[key],
+        tabCount: tabCount + 1
+      });
+      transformedData += "\n";
+    }
+  });
+  if (transformedData === "") {
+    return emptyObjectTransformValue;
+  }
+  return transformedData.substring(0, transformedData.length - 1);
+};
+var transformObjectOrArrayContent = (args) => {
+  const { key, value, tabCount } = args;
+  const transformedValue = transformData({
+    data: value,
+    // increase base indentation in arrays so child indices render under the parent label.
+    // Objects handle their own +1 indentation internally in handleObjectTransformation.
+    tabCount: Array.isArray(value) ? tabCount + 1 : tabCount
+  });
+  if (transformedValue === null) {
+    return "";
+  }
+  let transformedDataAggregate = `${generateTabs(tabCount)}${transformPropertyName(key)}:`;
+  if (typeof value !== "object" || transformedValue === "null" || transformedValue === emptyArrayTransformValue || transformedValue === emptyObjectTransformValue || Array.isArray(value) && isArrayWithoutObjectsOrArrays(value)) {
+    transformedDataAggregate += " ";
+  } else {
+    transformedDataAggregate += `
+`;
+  }
+  return transformedDataAggregate += transformedValue;
+};
+var isArrayWithoutObjectsOrArrays = (array) => {
+  if (array.length === 0) {
+    return true;
+  }
+  let hasObjectOrArrayBeenFound = false;
+  for (let n = 0; n < array.length; n++) {
+    if (isObject(array[n]) || Array.isArray(array[n])) {
+      hasObjectOrArrayBeenFound = true;
+      n = array.length;
+    }
+  }
+  return !hasObjectOrArrayBeenFound;
+};
+var isPropertyTypeToBeIgnored = (data) => typeof data === "undefined" || typeof data === "function";
+var isObject = (data) => typeof data === "object" && data !== null && !Array.isArray(data);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FieldFilteringHandler,
+  defaultFilteringRules,
+  defaultJsonRedactionText,
+  defaultUrlRedactionText,
+  generateQueryString,
+  isFieldFilteringManager,
+  isValidUrl,
+  normaliseUrl,
+  transformPropertyName,
+  transformToolOutput
+});