@lokalise/node-core 12.5.0 → 13.0.0

package/dist/index.js

@@ -1,78 +1,894 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiTransactionObservabilityManager = exports.waitAndRetry = exports.AuthFailedError = exports.EntityGoneError = exports.EntityNotFoundError = exports.AccessDeniedError = exports.RequestValidationError = exports.resolveGlobalErrorLogObject = exports.globalLogger = exports.executeSettleAllAndHandleGlobalErrors = exports.executeAndHandleGlobalErrors = exports.executeAsyncAndHandleGlobalErrors = exports.resolveMonorepoLogger = exports.resolveLogger = exports.resolveMonorepoLoggerConfiguration = exports.resolveLoggerConfiguration = exports.HashEncoding = exports.HashAlgorithm = exports.generateHash = exports.hasMessage = exports.isObject = exports.isStandardizedError = exports.isError = exports.deepClone = exports.convertDateFieldsToIsoString = exports.isEmptyObject = exports.copyWithoutEmpty = exports.copyWithoutUndefined = exports.pickWithoutUndefined = exports.pick = exports.groupByUnique = exports.groupByPath = exports.groupBy = exports.removeNullish = exports.removeFalsy = exports.callChunked = exports.chunk = exports.EncryptionUtility = exports.isFailure = exports.isSuccess = exports.failure = exports.success = exports.createRangeValidator = exports.ensureClosingSlashTransformer = exports.ConfigScope = exports.isEntityGoneError = exports.isInternalError = exports.InternalError = exports.isPublicNonRecoverableError = exports.PublicNonRecoverableError = void 0;
-exports.FsReadableProvider = exports.generateChecksumForBufferOrString = exports.generateChecksumForObject = exports.generateChecksumForReadable = void 0;
-var PublicNonRecoverableError_1 = require("./src/errors/PublicNonRecoverableError");
-Object.defineProperty(exports, "PublicNonRecoverableError", { enumerable: true, get: function () { return PublicNonRecoverableError_1.PublicNonRecoverableError; } });
-Object.defineProperty(exports, "isPublicNonRecoverableError", { enumerable: true, get: function () { return PublicNonRecoverableError_1.isPublicNonRecoverableError; } });
-var InternalError_1 = require("./src/errors/InternalError");
-Object.defineProperty(exports, "InternalError", { enumerable: true, get: function () { return InternalError_1.InternalError; } });
-Object.defineProperty(exports, "isInternalError", { enumerable: true, get: function () { return InternalError_1.isInternalError; } });
-var errorTypeGuards_1 = require("./src/errors/errorTypeGuards");
-Object.defineProperty(exports, "isEntityGoneError", { enumerable: true, get: function () { return errorTypeGuards_1.isEntityGoneError; } });
-var ConfigScope_1 = require("./src/config/ConfigScope");
-Object.defineProperty(exports, "ConfigScope", { enumerable: true, get: function () { return ConfigScope_1.ConfigScope; } });
-var configTransformers_1 = require("./src/config/configTransformers");
-Object.defineProperty(exports, "ensureClosingSlashTransformer", { enumerable: true, get: function () { return configTransformers_1.ensureClosingSlashTransformer; } });
-var configValidators_1 = require("./src/config/configValidators");
-Object.defineProperty(exports, "createRangeValidator", { enumerable: true, get: function () { return configValidators_1.createRangeValidator; } });
-var either_1 = require("./src/errors/either");
-Object.defineProperty(exports, "success", { enumerable: true, get: function () { return either_1.success; } });
-Object.defineProperty(exports, "failure", { enumerable: true, get: function () { return either_1.failure; } });
-Object.defineProperty(exports, "isSuccess", { enumerable: true, get: function () { return either_1.isSuccess; } });
-Object.defineProperty(exports, "isFailure", { enumerable: true, get: function () { return either_1.isFailure; } });
-var encryptionUtility_1 = require("./src/utils/encryptionUtility");
-Object.defineProperty(exports, "EncryptionUtility", { enumerable: true, get: function () { return encryptionUtility_1.EncryptionUtility; } });
-var arrayUtils_1 = require("./src/utils/arrayUtils");
-Object.defineProperty(exports, "chunk", { enumerable: true, get: function () { return arrayUtils_1.chunk; } });
-Object.defineProperty(exports, "callChunked", { enumerable: true, get: function () { return arrayUtils_1.callChunked; } });
-Object.defineProperty(exports, "removeFalsy", { enumerable: true, get: function () { return arrayUtils_1.removeFalsy; } });
-Object.defineProperty(exports, "removeNullish", { enumerable: true, get: function () { return arrayUtils_1.removeNullish; } });
-var objectUtils_1 = require("./src/utils/objectUtils");
-Object.defineProperty(exports, "groupBy", { enumerable: true, get: function () { return objectUtils_1.groupBy; } });
-Object.defineProperty(exports, "groupByPath", { enumerable: true, get: function () { return objectUtils_1.groupByPath; } });
-Object.defineProperty(exports, "groupByUnique", { enumerable: true, get: function () { return objectUtils_1.groupByUnique; } });
-Object.defineProperty(exports, "pick", { enumerable: true, get: function () { return objectUtils_1.pick; } });
-Object.defineProperty(exports, "pickWithoutUndefined", { enumerable: true, get: function () { return objectUtils_1.pickWithoutUndefined; } });
-Object.defineProperty(exports, "copyWithoutUndefined", { enumerable: true, get: function () { return objectUtils_1.copyWithoutUndefined; } });
-Object.defineProperty(exports, "copyWithoutEmpty", { enumerable: true, get: function () { return objectUtils_1.copyWithoutEmpty; } });
-Object.defineProperty(exports, "isEmptyObject", { enumerable: true, get: function () { return objectUtils_1.isEmptyObject; } });
-Object.defineProperty(exports, "convertDateFieldsToIsoString", { enumerable: true, get: function () { return objectUtils_1.convertDateFieldsToIsoString; } });
-Object.defineProperty(exports, "deepClone", { enumerable: true, get: function () { return objectUtils_1.deepClone; } });
-var typeUtils_1 = require("./src/utils/typeUtils");
-Object.defineProperty(exports, "isError", { enumerable: true, get: function () { return typeUtils_1.isError; } });
-Object.defineProperty(exports, "isStandardizedError", { enumerable: true, get: function () { return typeUtils_1.isStandardizedError; } });
-Object.defineProperty(exports, "isObject", { enumerable: true, get: function () { return typeUtils_1.isObject; } });
-Object.defineProperty(exports, "hasMessage", { enumerable: true, get: function () { return typeUtils_1.hasMessage; } });
-var hashUtils_1 = require("./src/utils/hashUtils");
-Object.defineProperty(exports, "generateHash", { enumerable: true, get: function () { return hashUtils_1.generateHash; } });
-Object.defineProperty(exports, "HashAlgorithm", { enumerable: true, get: function () { return hashUtils_1.HashAlgorithm; } });
-Object.defineProperty(exports, "HashEncoding", { enumerable: true, get: function () { return hashUtils_1.HashEncoding; } });
-var loggerConfigResolver_1 = require("./src/logging/loggerConfigResolver");
-Object.defineProperty(exports, "resolveLoggerConfiguration", { enumerable: true, get: function () { return loggerConfigResolver_1.resolveLoggerConfiguration; } });
-Object.defineProperty(exports, "resolveMonorepoLoggerConfiguration", { enumerable: true, get: function () { return loggerConfigResolver_1.resolveMonorepoLoggerConfiguration; } });
-Object.defineProperty(exports, "resolveLogger", { enumerable: true, get: function () { return loggerConfigResolver_1.resolveLogger; } });
-Object.defineProperty(exports, "resolveMonorepoLogger", { enumerable: true, get: function () { return loggerConfigResolver_1.resolveMonorepoLogger; } });
-var globalErrorHandler_1 = require("./src/errors/globalErrorHandler");
-Object.defineProperty(exports, "executeAsyncAndHandleGlobalErrors", { enumerable: true, get: function () { return globalErrorHandler_1.executeAsyncAndHandleGlobalErrors; } });
-Object.defineProperty(exports, "executeAndHandleGlobalErrors", { enumerable: true, get: function () { return globalErrorHandler_1.executeAndHandleGlobalErrors; } });
-Object.defineProperty(exports, "executeSettleAllAndHandleGlobalErrors", { enumerable: true, get: function () { return globalErrorHandler_1.executeSettleAllAndHandleGlobalErrors; } });
-Object.defineProperty(exports, "globalLogger", { enumerable: true, get: function () { return globalErrorHandler_1.globalLogger; } });
-Object.defineProperty(exports, "resolveGlobalErrorLogObject", { enumerable: true, get: function () { return globalErrorHandler_1.resolveGlobalErrorLogObject; } });
-var publicErrors_1 = require("./src/errors/publicErrors");
-Object.defineProperty(exports, "RequestValidationError", { enumerable: true, get: function () { return publicErrors_1.RequestValidationError; } });
-Object.defineProperty(exports, "AccessDeniedError", { enumerable: true, get: function () { return publicErrors_1.AccessDeniedError; } });
-Object.defineProperty(exports, "EntityNotFoundError", { enumerable: true, get: function () { return publicErrors_1.EntityNotFoundError; } });
-Object.defineProperty(exports, "EntityGoneError", { enumerable: true, get: function () { return publicErrors_1.EntityGoneError; } });
-Object.defineProperty(exports, "AuthFailedError", { enumerable: true, get: function () { return publicErrors_1.AuthFailedError; } });
-var waitUtils_1 = require("./src/utils/waitUtils");
-Object.defineProperty(exports, "waitAndRetry", { enumerable: true, get: function () { return waitUtils_1.waitAndRetry; } });
-var MultiTransactionObservabilityManager_1 = require("./src/observability/MultiTransactionObservabilityManager");
-Object.defineProperty(exports, "MultiTransactionObservabilityManager", { enumerable: true, get: function () { return MultiTransactionObservabilityManager_1.MultiTransactionObservabilityManager; } });
-var checksumUtils_1 = require("./src/utils/checksumUtils");
-Object.defineProperty(exports, "generateChecksumForReadable", { enumerable: true, get: function () { return checksumUtils_1.generateChecksumForReadable; } });
-Object.defineProperty(exports, "generateChecksumForObject", { enumerable: true, get: function () { return checksumUtils_1.generateChecksumForObject; } });
-Object.defineProperty(exports, "generateChecksumForBufferOrString", { enumerable: true, get: function () { return checksumUtils_1.generateChecksumForBufferOrString; } });
-var streamUtils_1 = require("./src/utils/streamUtils");
-Object.defineProperty(exports, "FsReadableProvider", { enumerable: true, get: function () { return streamUtils_1.FsReadableProvider; } });
+// src/utils/typeUtils.ts
+function hasMessage(maybe) {
+  return isObject(maybe) && typeof maybe.message === "string";
+}
+function isObject(maybeObject) {
+  return typeof maybeObject === "object" && maybeObject !== null;
+}
+function isStandardizedError(error) {
+  return isObject(error) && typeof error.code === "string" && typeof error.message === "string";
+}
+function isError(maybeError) {
+  return maybeError instanceof Error || Object.prototype.toString.call(maybeError) === "[object Error]";
+}
+
+// src/errors/PublicNonRecoverableError.ts
+var PUBLIC_NON_RECOVERABLE_ERROR_SYMBOL_KEY = "PUBLIC_NON_RECOVERABLE_ERROR_KEY";
+var publicNonRecoverableErrorSymbol = Symbol.for(PUBLIC_NON_RECOVERABLE_ERROR_SYMBOL_KEY);
+var PublicNonRecoverableError = class extends Error {
+  [publicNonRecoverableErrorSymbol] = true;
+  details;
+  errorCode;
+  httpStatusCode;
+  constructor(params) {
+    super(params.message, {
+      cause: params.cause
+    });
+    this.name = this.constructor.name;
+    this.details = params.details;
+    this.errorCode = params.errorCode;
+    this.httpStatusCode = params.httpStatusCode ?? 500;
+  }
+};
+function isPublicNonRecoverableError(error) {
+  return isError(error) && // biome-ignore lint/suspicious/noExplicitAny: checking for existence of prop outside or Error interface
+  (error[Symbol.for(PUBLIC_NON_RECOVERABLE_ERROR_SYMBOL_KEY)] === true || error.name === "PublicNonRecoverableError");
+}
+
+// src/errors/InternalError.ts
+var INTERNAL_ERROR_SYMBOL_KEY = "INTERNAL_ERROR_KEY";
+var internalErrorSymbol = Symbol.for(INTERNAL_ERROR_SYMBOL_KEY);
+var InternalError = class extends Error {
+  [internalErrorSymbol] = true;
+  details;
+  errorCode;
+  constructor(params) {
+    super(params.message, {
+      cause: params.cause
+    });
+    this.name = this.constructor.name;
+    this.details = params.details;
+    this.errorCode = params.errorCode;
+  }
+};
+function isInternalError(error) {
+  return isError(error) && // biome-ignore lint/suspicious/noExplicitAny: checking for existence of prop outside or Error interface
+  (error[Symbol.for(INTERNAL_ERROR_SYMBOL_KEY)] === true || error.name === "InternalError");
+}
+
+// src/errors/errorTypeGuards.ts
+function isEntityGoneError(entity) {
+  return isPublicNonRecoverableError(entity) && entity.httpStatusCode === 410;
+}
+
+// src/config/ConfigScope.ts
+var ConfigScope = class {
+  env;
+  constructor(envOverride) {
+    this.env = envOverride ?? { ...process.env };
+  }
+  updateEnv() {
+    this.env = { ...process.env };
+  }
+  getMandatoryInteger(param) {
+    const rawValue = this.env[param];
+    if (!rawValue) {
+      throw new InternalError({
+        message: `Missing mandatory configuration parameter: ${param}`,
+        errorCode: "CONFIGURATION_ERROR"
+      });
+    }
+    return validateNumber(
+      Number.parseInt(rawValue),
+      `Configuration parameter ${param}\` must be a number, but was ${rawValue}`
+    );
+  }
+  getMandatory(param) {
+    const result = this.env[param];
+    if (!result) {
+      throw new InternalError({
+        message: `Missing mandatory configuration parameter: ${param}`,
+        errorCode: "CONFIGURATION_ERROR"
+      });
+    }
+    return result;
+  }
+  getMandatoryOneOf(param, supportedValues) {
+    const result = this.getMandatory(param);
+    return validateOneOf(
+      result,
+      supportedValues,
+      `Unsupported ${param}: ${result}. Supported values: ${supportedValues.toString()}`
+    );
+  }
+  getMandatoryValidatedInteger(param, validator) {
+    const value = this.getMandatoryInteger(param);
+    if (!validator(value)) {
+      throw new InternalError({
+        message: `Value ${value} is invalid for parameter ${param}`,
+        errorCode: "CONFIGURATION_ERROR"
+      });
+    }
+    return value;
+  }
+  getOptionalNullable(param, defaultValue) {
+    return this.env[param] || defaultValue;
+  }
+  getOptional(param, defaultValue) {
+    return this.env[param] || defaultValue;
+  }
+  getOptionalInteger(param, defaultValue) {
+    const rawValue = this.env[param];
+    if (!rawValue) {
+      return defaultValue;
+    }
+    return validateNumber(
+      Number.parseInt(rawValue),
+      `Configuration parameter ${param}\` must be a number, but was ${rawValue}`
+    );
+  }
+  getOptionalNullableInteger(param, defaultValue) {
+    const rawValue = this.env[param];
+    if (!rawValue) {
+      return defaultValue;
+    }
+    return validateNumber(
+      Number.parseInt(rawValue),
+      `Configuration parameter ${param}\` must be a number, but was ${rawValue}`
+    );
+  }
+  getOptionalOneOf(param, defaultValue, supportedValues) {
+    const result = this.getOptional(param, defaultValue);
+    return validateOneOf(
+      result,
+      supportedValues,
+      `Unsupported ${param}: ${result}. Supported values: ${supportedValues.toString()}`
+    );
+  }
+  getOptionalValidated(param, defaultValue, validator) {
+    const value = this.env[param] || defaultValue;
+    if (!validator(value)) {
+      throw new InternalError({
+        message: `Value ${value} is invalid for parameter ${param}`,
+        errorCode: "CONFIGURATION_ERROR"
+      });
+    }
+    return value;
+  }
+  getOptionalValidatedInteger(param, defaultValue, validator) {
+    const value = this.getOptionalInteger(param, defaultValue);
+    if (!validator(value)) {
+      throw new InternalError({
+        message: `Value ${value} is invalid for parameter ${param}`,
+        errorCode: "CONFIGURATION_ERROR"
+      });
+    }
+    return value;
+  }
+  getOptionalTransformed(param, defaultValue, transformer) {
+    const value = this.env[param] || defaultValue;
+    return transformer(value);
+  }
+  getOptionalNullableTransformed(param, defaultValue, transformer) {
+    const value = this.env[param] || defaultValue;
+    return transformer(value);
+  }
+  getMandatoryTransformed(param, transformer) {
+    const value = this.getMandatory(param);
+    return transformer(value);
+  }
+  getOptionalBoolean(param, defaultValue) {
+    const rawValue = this.env[param]?.toLowerCase();
+    if (rawValue === void 0 || rawValue === "") {
+      return defaultValue;
+    }
+    validateOneOf(rawValue, ["true", "false"]);
+    return rawValue === "true";
+  }
+  getMandatoryJsonObject(param, schema) {
+    const rawValue = this.getMandatory(param);
+    return this.validateSchema(
+      JSON.parse(rawValue),
+      schema,
+      `Configuration parameter ${param} must be a valid JSON meeting the given schema, but was ${rawValue}`
+    );
+  }
+  getOptionalNullableJsonObject(param, schema, defaultValue) {
+    const rawValue = this.getOptionalNullable(param, void 0);
+    if (!rawValue) {
+      return defaultValue;
+    }
+    return this.validateSchema(
+      JSON.parse(rawValue),
+      schema,
+      `Configuration parameter ${param} must be a valid JSON meeting the given schema, but was ${rawValue}`
+    );
+  }
+  getOptionalJsonObject(param, schema, defaultValue) {
+    return this.getOptionalNullableJsonObject(param, schema, defaultValue);
+  }
+  isProduction() {
+    return this.env.NODE_ENV === "production";
+  }
+  isDevelopment() {
+    return this.env.NODE_ENV !== "production";
+  }
+  isTest() {
+    return this.env.NODE_ENV === "test";
+  }
+  validateSchema(value, schema, errorMessage) {
+    const parsedValue = schema.safeParse(value);
+    if (!parsedValue.success) {
+      throw new InternalError({
+        message: errorMessage,
+        errorCode: "CONFIGURATION_ERROR",
+        details: parsedValue.error
+      });
+    }
+    return parsedValue.data;
+  }
+};
+function validateOneOf(validatedEntity, expectedOneOfEntities, errorText) {
+  if (!expectedOneOfEntities.includes(validatedEntity)) {
+    throw new InternalError({
+      message: errorText || // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Validated entity ${validatedEntity} is not one of: ${expectedOneOfEntities.toString()}`,
+      errorCode: "CONFIGURATION_ERROR"
+    });
+  }
+  return validatedEntity;
+}
+function validateNumber(validatedObject, errorText) {
+  if (!Number.isFinite(validatedObject)) {
+    throw new InternalError({
+      message: errorText,
+      errorCode: "CONFIGURATION_ERROR"
+    });
+  }
+  return validatedObject;
+}
+
+// src/config/configTransformers.ts
+var ensureClosingSlashTransformer = (value) => {
+  if (!value) {
+    return "";
+  }
+  const lastChar = value.at(-1);
+  if (lastChar !== "/") {
+    return `${value}/`;
+  }
+  return value;
+};
+
+// src/config/configValidators.ts
+var createRangeValidator = (greaterOrEqualThan, lessOrEqualThan) => {
+  return (value) => {
+    return value >= greaterOrEqualThan && value <= lessOrEqualThan;
+  };
+};
+
+// src/errors/either.ts
+var isFailure = (e) => {
+  return e.error !== void 0;
+};
+var isSuccess = (e) => {
+  return e.result !== void 0;
+};
+var failure = (error) => ({ error });
+var success = (result) => ({ result });
+
+// src/utils/encryptionUtility.ts
+import * as crypto from "node:crypto";
+var algorithm = "aes-256-gcm";
+var ivLength = 16;
+var tagLength = 16;
+var defaultEncoding = "hex";
+var defaultSaltLength = 64;
+var defaultPbkdf2Iterations = 1e5;
+var EncryptionUtility = class {
+  secret;
+  saltLength;
+  encryptedPosition;
+  tagPosition;
+  pbkdf2Iterations;
+  encoding;
+  constructor(secret, options) {
+    this.secret = secret;
+    this.encoding = options?.encoding ?? defaultEncoding;
+    this.pbkdf2Iterations = options?.pbkdf2Iterations ?? defaultPbkdf2Iterations;
+    this.saltLength = options?.saltLength ?? defaultSaltLength;
+    this.tagPosition = this.saltLength + ivLength;
+    this.encryptedPosition = this.tagPosition + tagLength;
+  }
+  getKey(salt) {
+    return crypto.pbkdf2Sync(this.secret, salt, this.pbkdf2Iterations, 32, "sha512");
+  }
+  encrypt(value) {
+    const iv = crypto.randomBytes(ivLength);
+    const salt = crypto.randomBytes(this.saltLength);
+    const key = this.getKey(salt);
+    const cipher = crypto.createCipheriv(algorithm, key, iv);
+    const encrypted = Buffer.concat([cipher.update(String(value), "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([salt, iv, tag, encrypted]).toString(this.encoding);
+  }
+  decrypt(value) {
+    const stringValue = Buffer.from(String(value), this.encoding);
+    const salt = stringValue.subarray(0, this.saltLength);
+    const iv = stringValue.subarray(this.saltLength, this.tagPosition);
+    const tag = stringValue.subarray(this.tagPosition, this.encryptedPosition);
+    const encrypted = stringValue.subarray(this.encryptedPosition);
+    const key = this.getKey(salt);
+    const decipher = crypto.createDecipheriv(algorithm, key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([
+      decipher.update(encrypted),
+      Buffer.from(decipher.final("utf8"))
+    ]).toString("utf8");
+  }
+};
+
+// src/utils/arrayUtils.ts
+function chunk(array, chunkSize) {
+  const length = array.length;
+  if (!length || chunkSize < 1) {
+    return [];
+  }
+  let index = 0;
+  let resIndex = 0;
+  const result = new Array(Math.ceil(length / chunkSize));
+  while (index < length) {
+    result[resIndex++] = array.slice(index, index += chunkSize);
+  }
+  return result;
+}
+async function callChunked(chunkSize, array, processFn) {
+  for (let i = 0; i < array.length; i += chunkSize) {
+    const arrayChunk = array.slice(i, i + chunkSize);
+    await processFn(arrayChunk);
+  }
+}
+function removeNullish(array) {
+  return array.filter((e) => e !== void 0 && e !== null);
+}
+function removeFalsy(array) {
+  return array.filter((e) => e);
+}
+function removeDuplicates(array) {
+  return [...new Set(array)];
+}
+
+// src/utils/objectUtils.ts
+import dotProp from "dot-prop";
+function copyWithoutUndefined(originalValue) {
+  return Object.keys(originalValue).reduce(
+    (acc, key) => {
+      if (originalValue[key] !== void 0) {
+        acc[key] = originalValue[key];
+      }
+      return acc;
+    },
+    {}
+  );
+}
+function copyWithoutEmpty(originalValue) {
+  return Object.keys(originalValue).reduce(
+    (acc, key) => {
+      if (originalValue[key] !== void 0 && originalValue[key] !== null && // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+      (typeof originalValue[key] !== "string" || originalValue[key].trim().length > 0)) {
+        acc[key] = originalValue[key];
+      }
+      return acc;
+    },
+    {}
+  );
+}
+function pick(source, propNames) {
+  const result = {};
+  let idx = 0;
+  while (idx < propNames.length) {
+    if (propNames[idx] in source) {
+      result[propNames[idx]] = source[propNames[idx]];
+    }
+    idx += 1;
+  }
+  return result;
+}
+function pickWithoutUndefined(source, propNames) {
+  const result = {};
+  let idx = 0;
+  while (idx < propNames.length) {
+    if (propNames[idx] in source && source[propNames[idx]] !== void 0) {
+      result[propNames[idx]] = source[propNames[idx]];
+    }
+    idx += 1;
+  }
+  return result;
+}
+function isEmptyObject(params) {
+  for (const key in params) {
+    if (Object.hasOwn(params, key) && params[key] !== void 0) {
+      return false;
+    }
+  }
+  return true;
+}
+function groupBy(array, selector) {
+  return array.reduce(
+    (acc, item) => {
+      const key = item[selector];
+      if (key === void 0 || key === null) {
+        return acc;
+      }
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(item);
+      return acc;
+    },
+    {}
+  );
+}
+function groupByPath(array, selector) {
+  return array.reduce(
+    (acc, item) => {
+      const key = dotProp.get(item, selector);
+      if (key === void 0 || key === null) {
+        return acc;
+      }
+      const strKeyPath = key;
+      if (!acc[strKeyPath]) {
+        acc[strKeyPath] = [];
+      }
+      acc[strKeyPath].push(item);
+      return acc;
+    },
+    {}
+  );
+}
+function groupByUnique(array, selector) {
+  return array.reduce(
+    (acc, item) => {
+      const key = item[selector];
+      if (key === void 0 || key === null) {
+        return acc;
+      }
+      if (acc[key] !== void 0) {
+        throw new InternalError({
+          message: `Duplicated item for selector ${selector.toString()} with value ${key.toString()}`,
+          errorCode: "DUPLICATED_ITEM",
+          details: { selector, value: key }
+        });
+      }
+      acc[key] = item;
+      return acc;
+    },
+    {}
+  );
+}
+function convertDateFieldsToIsoString(object) {
+  if (Array.isArray(object)) {
+    return object.map(convertDateFieldsToIsoStringAux);
+  }
+  return Object.entries(object).reduce(
+    (result, [key, value]) => {
+      result[key] = convertDateFieldsToIsoStringAux(value);
+      return result;
+    },
+    {}
+  );
+}
+function convertDateFieldsToIsoStringAux(item) {
+  if (item instanceof Date) {
+    return item.toISOString();
+  }
+  if (item && typeof item === "object") {
+    return convertDateFieldsToIsoString(item);
+  }
+  return item;
+}
+function deepClone(object) {
+  if (object === void 0 || object === null) {
+    return object;
+  }
+  return structuredClone(object);
+}
+
+// src/utils/hashUtils.ts
+import { createHash } from "node:crypto";
+var HashEncoding = /* @__PURE__ */ ((HashEncoding2) => {
+  HashEncoding2["HEX"] = "hex";
+  HashEncoding2["BASE64"] = "base64";
+  return HashEncoding2;
+})(HashEncoding || {});
+var HashAlgorithm = /* @__PURE__ */ ((HashAlgorithm2) => {
+  HashAlgorithm2["SHA256"] = "sha256";
+  HashAlgorithm2["SHA512"] = "sha512";
+  return HashAlgorithm2;
+})(HashAlgorithm || {});
+function generateHash(algorithm2, data, encoding = "hex" /* HEX */) {
+  return createHash(algorithm2).update(data).digest(encoding);
+}
+
+// src/logging/loggerConfigResolver.ts
+import { levels, pino } from "pino";
+import pretty from "pino-pretty";
+function resolveMonorepoLogger(appConfig) {
+  if (appConfig.nodeEnv !== "development") {
+    return resolveLogger(appConfig);
+  }
+  const configuration = resolveMonorepoLoggerConfiguration(appConfig);
+  return pino(configuration);
+}
+function resolveMonorepoLoggerConfiguration(appConfig) {
+  if (appConfig.nodeEnv !== "development") {
+    return resolveLoggerConfiguration(appConfig);
+  }
+  return {
+    level: appConfig.logLevel,
+    formatters: {
+      level: (label) => {
+        return { level: label };
+      }
+    },
+    redact: appConfig.redact,
+    transport: {
+      target: "pino/file",
+      options: {
+        destination: appConfig.targetFile ?? "./service.log",
+        mkdir: true,
+        append: appConfig.append ?? false
+      }
+    }
+  };
+}
+function resolveLogger(appConfig) {
+  if (appConfig.nodeEnv !== "production") {
+    return resolveLoggerConfiguration(appConfig);
+  }
+  const configuration = resolveLoggerConfiguration(appConfig);
+  return pino(configuration);
+}
+function resolveLoggerConfiguration(appConfig) {
+  if (appConfig.nodeEnv !== "production") {
+    return pino(
+      pretty({
+        sync: true,
+        minimumLevel: appConfig.logLevel,
+        colorize: true,
+        translateTime: "SYS:standard",
+        ignore: "hostname,pid"
+      })
+    );
+  }
+  return {
+    level: appConfig.logLevel,
+    formatters: {
+      level: (_label, numericLevel) => {
+        const level = levels.labels[numericLevel] || "unknown";
+        return { level };
+      }
+    },
+    redact: appConfig.redact
+  };
+}
+
+// src/errors/globalErrorHandler.ts
+import { types } from "node:util";
+import { levels as levels2, pino as pino2, stdSerializers } from "pino";
+var globalLogger = pino2({
+  formatters: {
+    level: (_label, numericLevel) => {
+      const level = levels2.labels[numericLevel] || "unknown";
+      return { level };
+    }
+  }
+});
+function resolveGlobalErrorLogObject(err, correlationId) {
+  if (types.isNativeError(err)) {
+    return {
+      message: err.message,
+      error: stdSerializers.err(err),
+      "x-request-id": correlationId
+    };
+  }
+  if (hasMessage(err)) {
+    return {
+      message: err.message,
+      "x-request-id": correlationId
+    };
+  }
+  return {
+    message: "Unknown error",
+    "x-request-id": correlationId
+  };
+}
+function executeAndHandleGlobalErrors(operation) {
+  try {
+    const result = operation();
+    return result;
+  } catch (err) {
+    const logObject = resolveGlobalErrorLogObject(err);
+    globalLogger.error(logObject, logObject.message);
+    process.exit(1);
+  }
+}
+async function executeAsyncAndHandleGlobalErrors(operation, stopOnError = true) {
+  try {
+    const result = await operation();
+    return result;
+  } catch (err) {
+    const logObject = resolveGlobalErrorLogObject(err);
+    globalLogger.error(logObject, logObject.message);
+    if (stopOnError) {
+      process.exit(1);
+    }
+  }
+}
+async function executeSettleAllAndHandleGlobalErrors(promises, stopOnError = true) {
+  const result = await Promise.allSettled(promises);
+  let errorsHappened;
+  for (const entry of result) {
+    if (entry.status === "rejected") {
+      const logObject = resolveGlobalErrorLogObject(entry.reason);
+      globalLogger.error(logObject, logObject.message);
+      errorsHappened = true;
+    }
+  }
+  if (stopOnError && errorsHappened) {
+    process.exit(1);
+  }
+  return result;
+}
+
+// src/errors/publicErrors.ts
+import { constants as httpConstants } from "node:http2";
+var RequestValidationError = class extends PublicNonRecoverableError {
+  constructor(errors) {
+    super({
+      message: "Invalid params",
+      errorCode: "VALIDATION_ERROR",
+      httpStatusCode: httpConstants.HTTP_STATUS_BAD_REQUEST,
+      details: {
+        error: errors
+      }
+    });
+  }
+};
+var AccessDeniedError = class extends PublicNonRecoverableError {
+  constructor(params) {
+    super({
+      message: params.message,
+      errorCode: "ACCESS_DENIED",
+      httpStatusCode: httpConstants.HTTP_STATUS_FORBIDDEN,
+      details: params.details,
+      cause: params.cause
+    });
+  }
+};
+var EntityNotFoundError = class extends PublicNonRecoverableError {
+  constructor(params) {
+    super({
+      message: params.message,
+      errorCode: "ENTITY_NOT_FOUND",
+      httpStatusCode: httpConstants.HTTP_STATUS_NOT_FOUND,
+      details: params.details,
+      cause: params.cause
+    });
+  }
+};
+var EntityGoneError = class extends PublicNonRecoverableError {
+  constructor(params) {
+    super({
+      message: params.message,
+      errorCode: "ENTITY_GONE",
+      httpStatusCode: 410,
+      details: params.details
+    });
+  }
+};
+var AuthFailedError = class extends PublicNonRecoverableError {
+  constructor(params = {}) {
+    super({
+      message: params.message ?? "Authentication failed",
+      errorCode: "AUTH_FAILED",
+      httpStatusCode: httpConstants.HTTP_STATUS_UNAUTHORIZED,
+      details: params.details,
+      cause: params.cause
+    });
+  }
+};
+
+// src/utils/waitUtils.ts
+var waitAndRetry = async (predicateFn, sleepTime = 20, maxRetryCount = 15) => {
+  return new Promise((resolve, reject) => {
+    let retryCount = 0;
+    function performCheck() {
+      if (maxRetryCount !== 0 && retryCount > maxRetryCount) {
+        resolve(predicateFn());
+      }
+      Promise.resolve().then(() => {
+        return predicateFn();
+      }).then((result) => {
+        if (result) {
+          resolve(result);
+        } else {
+          retryCount++;
+          setTimeout(performCheck, sleepTime);
+        }
+      }).catch((err) => {
+        reject(err);
+      });
+    }
+    performCheck();
+  });
+};
+
+// src/observability/MultiTransactionObservabilityManager.ts
+var MultiTransactionObservabilityManager = class {
+  managers;
+  constructor(managers) {
+    this.managers = managers;
+  }
+  start(transactionName, uniqueTransactionKey) {
+    for (const manager of this.managers) {
+      manager.start(transactionName, uniqueTransactionKey);
+    }
+  }
+  startWithGroup(transactionName, uniqueTransactionKey, transactionGroup) {
+    for (const manager of this.managers) {
+      manager.startWithGroup(transactionName, uniqueTransactionKey, transactionGroup);
+    }
+  }
+  stop(uniqueTransactionKey, wasSuccessful) {
+    for (const manager of this.managers) {
+      manager.stop(uniqueTransactionKey, wasSuccessful);
+    }
+  }
+};
+
+// src/utils/checksumUtils.ts
+import { createHash as createHash2 } from "node:crypto";
+var HASH_ALGORITHM = "md5";
+function generateChecksumForBufferOrString(data) {
+  return createHash2(HASH_ALGORITHM).update(data).digest("hex");
+}
+function generateChecksumForObject(object) {
+  const objectAsString = JSON.stringify(object);
+  return generateChecksumForBufferOrString(objectAsString);
+}
+function generateChecksumForReadable(readable) {
+  return new Promise((resolve, reject) => {
+    const hashCreator = createHash2(HASH_ALGORITHM);
+    readable.on("data", (data) => {
+      if (Buffer.isBuffer(data)) {
+        hashCreator.update(data);
+      } else {
+        hashCreator.update(Buffer.from(data));
+      }
+    });
+    readable.on("end", () => {
+      const hash = hashCreator.digest("hex");
+      resolve(hash);
+    });
+    readable.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+// src/utils/streamUtils.ts
+import { F_OK } from "node:constants";
+import { access, createReadStream, createWriteStream } from "node:fs";
+import { stat, unlink } from "node:fs/promises";
+import { pipeline } from "node:stream";
+var FsReadableProvider = class _FsReadableProvider {
+  storageFile;
+  constructor(options) {
+    this.storageFile = options.storageFile;
+  }
+  fileExists() {
+    return new Promise((resolve) => {
+      access(this.storageFile, F_OK, (err) => {
+        return resolve(!err);
+      });
+    });
+  }
+  async getContentLength() {
+    if (!await this.fileExists()) {
+      throw new Error(`File ${this.storageFile} was already deleted.`);
+    }
+    const stats = await stat(this.storageFile);
+    return stats.size;
+  }
+  async createStream() {
+    if (!await this.fileExists()) {
+      throw new Error(`File ${this.storageFile} was already deleted.`);
+    }
+    return createReadStream(this.storageFile);
+  }
+  async destroy() {
+    if (!await this.fileExists()) {
+      return;
+    }
+    return unlink(this.storageFile);
+  }
+  async persist(sourceReadable) {
+    const writable = createWriteStream(this.storageFile);
+    return new Promise((resolve, reject) => {
+      pipeline(sourceReadable, writable, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  static async persistReadableToFs(options) {
+    const provider = new _FsReadableProvider({
+      storageFile: options.targetFile
+    });
+    await provider.persist(options.sourceReadable);
+    return provider;
+  }
+};
+export {
+  AccessDeniedError,
+  AuthFailedError,
+  ConfigScope,
+  EncryptionUtility,
+  EntityGoneError,
+  EntityNotFoundError,
+  FsReadableProvider,
+  HashAlgorithm,
+  HashEncoding,
+  InternalError,
+  MultiTransactionObservabilityManager,
+  PublicNonRecoverableError,
+  RequestValidationError,
+  callChunked,
+  chunk,
+  convertDateFieldsToIsoString,
+  copyWithoutEmpty,
+  copyWithoutUndefined,
+  createRangeValidator,
+  deepClone,
+  ensureClosingSlashTransformer,
+  executeAndHandleGlobalErrors,
+  executeAsyncAndHandleGlobalErrors,
+  executeSettleAllAndHandleGlobalErrors,
+  failure,
+  generateChecksumForBufferOrString,
+  generateChecksumForObject,
+  generateChecksumForReadable,
+  generateHash,
+  globalLogger,
+  groupBy,
+  groupByPath,
+  groupByUnique,
+  hasMessage,
+  isEmptyObject,
+  isEntityGoneError,
+  isError,
+  isFailure,
+  isInternalError,
+  isObject,
+  isPublicNonRecoverableError,
+  isStandardizedError,
+  isSuccess,
+  pick,
+  pickWithoutUndefined,
+  removeDuplicates,
+  removeFalsy,
+  removeNullish,
+  resolveGlobalErrorLogObject,
+  resolveLogger,
+  resolveLoggerConfiguration,
+  resolveMonorepoLogger,
+  resolveMonorepoLoggerConfiguration,
+  success,
+  waitAndRetry
+};
 //# sourceMappingURL=index.js.map