@mojaloop/ml-schema-transformer-lib/dist/lib/utils/index.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/type-guards.ts
var isContextLogger = (logger) => {
  return "info" in logger && "error" in logger && "warn" in logger && "verbose" in logger && "debug" in logger && "silly" in logger && "audit" in logger && "trace" in logger;
};

// 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 fspiopToIsoTransferStateMap = {
  COMMITTED: "COMM",
  RESERVED: "RESV",
  RECEIVED: "RECV",
  ABORTED: "ABOR"
};
var generateID = (idGenType = "ulid" /* ulid */, config = {}) => {
  switch (idGenType) {
    case "ulid" /* ulid */:
    case "uuid" /* uuid */:
      return idGenerator({ ...config, type: idGenType })();
    default:
      return idGenerator({ ...config, type: "ulid" /* ulid */ })();
  }
};
var isPersonPartyIdType = (partyIdType) => partyIdType && !["BUSINESS", "ALIAS", "DEVICE"].includes(partyIdType);
var isEmptyObject = (data) => {
  return typeof data === "object" && data !== null && Object.keys(data).length === 0;
};
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 getDescrForErrCode = (code) => {
  try {
    const errorCode = Number.parseInt(code);
    const errorCreated = CreateFSPIOPErrorFromErrorCode(errorCode);
    return errorCreated?.apiErrorCode?.type?.description;
  } catch (error) {
    return "Unknown error";
  }
};
var getIlpPacketCondition = (inputIlpPacket) => {
  const binaryPacket = Buffer.from(inputIlpPacket, "base64");
  const decoded = ilpPacket.deserializeIlpPrepare(binaryPacket);
  return decoded?.executionCondition?.toString("base64url");
};
var toIsoTransferState = (fspiopState) => {
  if (!fspiopState) return void 0;
  const isoState = fspiopToIsoTransferStateMap[fspiopState];
  if (!isoState) throw new Error(`toIsoTransferState: Unknown FSPIOP transfer state: ${fspiopState}`);
  return isoState;
};
var toFspiopTransferState = (isoState) => {
  if (!isoState) return void 0;
  for (const [key, value] of Object.entries(fspiopToIsoTransferStateMap)) {
    if (value === isoState) return key;
  }
  throw new Error(`toFspiopTransferState: Unknown ISO20022 transfer state: ${isoState}`);
};
var validateConfig = (config) => {
  if (hasProp(config, "logger") && !isContextLogger(config.logger)) {
    throw new Error("Invalid logger provided");
  }
};
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;
  }, []);
};
export {
  deduplicateObjectsArray,
  deepMerge,
  extractValues,
  generateID,
  getDescrForErrCode,
  getIlpPacketCondition,
  getObjectPaths,
  getProp,
  hasProp,
  isEmptyObject,
  isPersonPartyIdType,
  rollUpUnmappedAsExtensions,
  setProp,
  toFspiopTransferState,
  toIsoTransferState,
  unrollExtensions,
  validateConfig
};
//# sourceMappingURL=index.mjs.map