@mojaloop/ml-schema-transformer-lib/dist/lib/utils/index.js

Shared component for ML schemas translation

"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/lib/utils/index.ts
var utils_exports = {};
__export(utils_exports, {
  deduplicateObjectsArray: () => deduplicateObjectsArray,
  deepMerge: () => deepMerge,
  extractValues: () => extractValues,
  generateID: () => generateID,
  getDescrForErrCode: () => getDescrForErrCode,
  getIlpPacketCondition: () => getIlpPacketCondition,
  getObjectPaths: () => getObjectPaths,
  getProp: () => getProp,
  hasProp: () => hasProp,
  isEmptyObject: () => isEmptyObject,
  isPersonPartyIdType: () => isPersonPartyIdType,
  rollUpUnmappedAsExtensions: () => rollUpUnmappedAsExtensions,
  setProp: () => setProp,
  toFspiopTransferState: () => toFspiopTransferState,
  toIsoTransferState: () => toIsoTransferState,
  unrollExtensions: () => unrollExtensions,
  validateConfig: () => validateConfig
});
module.exports = __toCommonJS(utils_exports);
var ilpPacket = __toESM(require("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;
  }, []);
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  deduplicateObjectsArray,
  deepMerge,
  extractValues,
  generateID,
  getDescrForErrCode,
  getIlpPacketCondition,
  getObjectPaths,
  getProp,
  hasProp,
  isEmptyObject,
  isPersonPartyIdType,
  rollUpUnmappedAsExtensions,
  setProp,
  toFspiopTransferState,
  toIsoTransferState,
  unrollExtensions,
  validateConfig
});
//# sourceMappingURL=index.js.map