@mojaloop/ml-schema-transformer-lib/dist/lib/transforms/extensions.mjs

Shared component for ML schemas translation

var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
  if (typeof require !== "undefined") return require.apply(this, arguments);
  throw Error('Dynamic require of "' + x + '" is not supported');
});

// src/lib/utils/index.ts
import * as ilpPacket from "ilp-packet";

// src/types/index.ts
var logLevelsMap = {
  error: "error",
  warn: "warn",
  info: "info",
  verbose: "verbose",
  debug: "debug",
  silly: "silly",
  audit: "audit",
  trace: "trace",
  perf: "perf"
};
var logLevelValues = Object.values(logLevelsMap);

// src/lib/utils/index.ts
var idGenerator = __require("@mojaloop/central-services-shared").Util.id;
var { CreateFSPIOPErrorFromErrorCode } = __require("@mojaloop/central-services-error-handling");
var setProp = (obj, path, value) => {
  const pathParts = path.split(".");
  let current = obj;
  for (let i = 0; i < pathParts.length - 1; i++) {
    const part = pathParts[i];
    if (!current[part]) {
      current[part] = {};
    }
    current = current[part];
  }
  current[pathParts[pathParts.length - 1]] = value;
};
var getProp = (obj, path) => {
  const pathParts = path.split(".");
  let current = obj;
  for (const part of pathParts) {
    if (typeof current === "object" && current !== null && part in current) {
      current = current[part];
    } else {
      return void 0;
    }
  }
  return current;
};
var hasProp = (obj, path) => {
  const pathParts = path.split(".");
  let current = obj;
  for (const part of pathParts) {
    if (typeof current === "object" && current !== null && part in current) {
      current = current[part];
    } else {
      return false;
    }
  }
  return true;
};
var deepMerge = (target, source) => {
  for (const key in source) {
    if (source[key] instanceof Object && key in target) {
      Object.assign(source[key], deepMerge(target[key], source[key]));
    }
  }
  Object.assign(target, source);
  return target;
};
var unrollExtensions = (extensions) => {
  const unrolled = {};
  for (const { key, value } of extensions) {
    setProp(unrolled, key, value);
  }
  return unrolled;
};
var rollUpUnmappedAsExtensions = (source, mapping) => {
  const extensions = [];
  const mappingObj = mapping = typeof mapping === "string" ? JSON.parse(mapping) : mapping;
  const mappingValues = extractValues(mappingObj).map((value) => String(value)).filter((value) => value.startsWith("body.") || value.startsWith("$context.")).map((value) => value.replace("body.", "")).map((value) => value.replace(/\$context\.[a-zA-Z0-9]+./, ""));
  const sourcePaths = getObjectPaths(source.body);
  for (const path of sourcePaths) {
    if (!mappingValues.includes(path)) {
      const value = getProp(source.body, path);
      extensions.push({ key: path, value });
    }
  }
  return extensions;
};
var extractValues = (obj) => {
  const values = [];
  function recurse(current) {
    if (Array.isArray(current)) {
      current.forEach((item) => recurse(item));
    } else if (typeof current === "object" && current !== null) {
      Object.values(current).forEach((value) => recurse(value));
    } else {
      values.push(current);
    }
  }
  recurse(obj);
  return values;
};
var getObjectPaths = (obj, prefix = "") => {
  let paths = [];
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      const path = prefix ? `${prefix}.${key}` : key;
      if (typeof obj[key] === "object" && obj[key] !== null && !Array.isArray(obj[key])) {
        paths = paths.concat(getObjectPaths(obj[key], path));
      } else {
        paths.push(path);
      }
    }
  }
  return paths;
};
var deduplicateObjectsArray = (arr, uniqueKey) => {
  const seen = /* @__PURE__ */ new Set();
  return arr.reduce((acc, obj) => {
    if (!seen.has(obj[uniqueKey])) {
      seen.add(obj[uniqueKey]);
      acc.push(obj);
    }
    return acc;
  }, []);
};

// src/lib/transforms/extensions.ts
var applyUnrollExtensions = (params) => {
  const { source, target, options, logger } = params;
  let extensionListProperty;
  if (options.applyUnrollExtensions?.extensionListProperty) {
    extensionListProperty = options.applyUnrollExtensions?.extensionListProperty;
  } else if (source.body?.errorInformation) {
    extensionListProperty = "body.errorInformation.extensionList";
  } else {
    extensionListProperty = "body.extensionList";
  }
  const extension = getProp(source, `${extensionListProperty}.extension`);
  if (!options.unrollExtensions || !extension) {
    logger.debug("Skipping unrollExtensions", { source, target, options });
    return target;
  }
  const unrolled = unrollExtensions(extension);
  logger.debug("Unrolled extensions", { source, unrolled });
  target.body = deepMerge(target.body, unrolled);
  return target;
};
var applyRollUpUnmappedAsExtensions = (params) => {
  const { source, target, options: { mapping }, options, logger } = params;
  if (!options.rollUpUnmappedAsExtensions) {
    logger.debug("Skipping rollUpUnmappedAsExtensions", { source, target, mapping, options });
    return target;
  }
  const extensions = rollUpUnmappedAsExtensions(source, mapping);
  logger.debug("Rolled up unmapped properties into extensions", { source, mapping, extensions });
  if (extensions.length === 0) {
    logger.debug("No unmapped properties to roll up", { source, mapping });
    return target;
  }
  let extensionListProperty;
  if (options.applyRollUpUnmappedAsExtensions?.extensionListProperty) {
    extensionListProperty = options.applyRollUpUnmappedAsExtensions?.extensionListProperty;
  } else if (target.body?.errorInformation) {
    extensionListProperty = "body.errorInformation.extensionList";
  } else {
    extensionListProperty = "body.extensionList";
  }
  const extensionProperty = `${extensionListProperty}.extension`;
  if (!hasProp(target, extensionProperty)) {
    setProp(target, extensionProperty, []);
  }
  let allExtensions = getProp(target, extensionProperty);
  allExtensions.push(...extensions);
  allExtensions = deduplicateObjectsArray(allExtensions, "key");
  setProp(target, extensionProperty, allExtensions);
  logger.debug("Rolled up unmapped properties into extensions", { source, target, mapping, extensions });
  return target;
};
export {
  applyRollUpUnmappedAsExtensions,
  applyUnrollExtensions
};
//# sourceMappingURL=extensions.mjs.map