@commercetools/processors 0.0.0

package/dist/index.mjs

@@ -0,0 +1,430 @@
+// src/field-filtering/defaultFilteringRules.ts
+var defaultJsonRedactionText = "[REDACTED]";
+var defaultUrlRedactionText = "REDACTED";
+var defaultFilteringRules = {
+  jsonRedactionText: defaultJsonRedactionText,
+  urlRedactionText: defaultUrlRedactionText
+};
+
+// src/field-filtering/urlHelpers.ts
+import qs from "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 qs.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);
+export {
+  FieldFilteringHandler,
+  defaultFilteringRules,
+  defaultJsonRedactionText,
+  defaultUrlRedactionText,
+  generateQueryString,
+  isFieldFilteringManager,
+  isValidUrl,
+  normaliseUrl,
+  transformPropertyName,
+  transformToolOutput
+};

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@commercetools/processors",
+  "version": "0.0.0",
+  "mcpName": "io.github.commercetools/processors",
+  "homepage": "https://github.com/commercetools/processors",
+  "description": "A collection of output processors for commercetools MCP server",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "preinstall": "npx only-allow pnpm",
+    "prebuild": "pnpm run clean",
+    "dev:build": "tsup --env.NODE_ENV dev",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "lint": "eslint \"./**/*.ts*\"",
+    "prettier": "prettier './**/*.{js,ts,md,html,css}' --write",
+    "prettier-check": "prettier './**/*.{js,ts,md,html,css}' --check",
+    "test": "jest",
+    "validate": "pnpm run lint --fix && pnpm run prettier && pnpm run test"
+  },
+  "packageManager": "pnpm@9.11.0",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "dotenv": "17.2.1",
+    "qs": "6.14.0"
+  },
+  "keywords": [
+    "mcp",
+    "modelcontextprotocol",
+    "commercetools",
+    "field-filtering",
+    "transformations",
+    "transform",
+    "tools"
+  ],
+  "author": "commercetools GmbH <info@commercetools.com> (https://commercetools.com)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/commercetools/commerce-mcp.git",
+    "directory": "processors"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/compat": "^1.3.2",
+    "@types/express": "^5.0.3",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.17.2",
+    "@types/qs": "^6.14.0",
+    "@typescript-eslint/eslint-plugin": "^8.24.1",
+    "concurrently": "^9.2.0",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jest": "^28.11.0",
+    "eslint-plugin-prettier": "^5.2.3",
+    "globals": "^15.15.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.5.1",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.8.3"
+  }
+}