@mojaloop/ml-schema-transformer-lib/dist/lib/createTransformer.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/transformer.ts
var Transformer = class {
  mapper;
  constructor(mapper) {
    this.mapper = mapper;
  }
  async transform(source, { mapperOptions } = {}) {
    return this.mapper(source, mapperOptions);
  }
};

// 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 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 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 getFirstFromDelimitedName = (name) => {
  if (!name) return void 0;
  const parts = name.split(";");
  return parts[0]?.trim() || void 0;
};
var getMiddleFromDelimitedName = (name) => {
  if (!name) return void 0;
  const parts = name.split(";");
  return parts[1]?.trim() || void 0;
};
var getLastFromDelimitedName = (name) => {
  if (!name) return void 0;
  const parts = name.split(";");
  return parts[2]?.trim() || void 0;
};
var getDisplayNameFromDelimitedName = (name) => {
  if (!name) return void 0;
  const parts = name.split(";");
  return parts[3]?.trim() || void 0;
};
var makeDelimitedName = (party) => {
  const first = party?.personalInfo?.complexName?.firstName || void 0;
  const second = party?.personalInfo?.complexName?.middleName || void 0;
  const third = party?.personalInfo?.complexName?.lastName || void 0;
  const displayName = party?.name || void 0;
  if (!first && !second && !third && !displayName) return void 0;
  const parts = [first, second, third, displayName];
  return parts.join(";");
};

// src/lib/transforms/index.ts
var CustomTransforms = {
  generateID: (options) => () => (data, state) => {
    return generateID();
  },
  datetimeNow: (options) => () => (data, state) => {
    return (/* @__PURE__ */ new Date()).toISOString();
  },
  isPersonParty: (options) => () => (data, state) => {
    return isPersonPartyIdType(data);
  },
  isNotPersonParty: (options) => () => (data, state) => {
    return !isPersonPartyIdType(data);
  },
  isNotEmpty: (options) => () => (data, state) => {
    return data && !isEmptyObject(data);
  },
  fspiopErrorDescrForCode: (options) => () => (data, state) => {
    return getDescrForErrCode(data);
  },
  ilpPacketToCondition: (options) => () => (data, state) => {
    return getIlpPacketCondition(data);
  },
  toFspiopTransferState: (options) => () => (data, state) => {
    return toFspiopTransferState(data);
  },
  toIsoTransferState: (options) => () => (data, state) => {
    return toIsoTransferState(data);
  },
  toIsoErrorDescription: (options) => () => (data, state) => {
    const dataStr = data;
    return dataStr.length > 105 ? dataStr.substring(0, 105) : dataStr;
  },
  supportedCurrenciesToString: (options) => () => (data, state) => {
    return data && Array.isArray(data) && data.length > 0 ? data[0] : data;
  },
  toArray: (options) => () => (data, state) => {
    if (data) {
      return Array.isArray(data) ? data : [data];
    }
    return void 0;
  },
  getFirstFromDelimitedName: (options) => () => (data, state) => {
    return getFirstFromDelimitedName(data);
  },
  getMiddleFromDelimitedName: (options) => () => (data, state) => {
    return getMiddleFromDelimitedName(data);
  },
  getLastFromDelimitedName: (options) => () => (data, state) => {
    return getLastFromDelimitedName(data);
  },
  getDisplayNameFromDelimitedName: (options) => () => (data, state) => {
    return getDisplayNameFromDelimitedName(data);
  },
  makeDelimitedName: (options) => () => (data, state) => {
    const party = data;
    return makeDelimitedName(party);
  }
};

// src/lib/createTransformer.ts
var mapTransform = __require("map-transform-cjs").default;
var createTransformer = (mapping, options = {}) => {
  const { mapTransformOptions } = options;
  const mergedOptions = { ...mapTransformOptions, transformers: { ...mapTransformOptions?.transformers, ...CustomTransforms } };
  mapping = typeof mapping === "string" ? JSON.parse(mapping) : mapping;
  return new Transformer(mapTransform(mapping, mergedOptions));
};
export {
  createTransformer
};
//# sourceMappingURL=createTransformer.mjs.map