@lokalise/node-core 12.5.1 → 13.0.0

package/dist/index.cjs

@@ -0,0 +1,985 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessDeniedError: () => AccessDeniedError,
+  AuthFailedError: () => AuthFailedError,
+  ConfigScope: () => ConfigScope,
+  EncryptionUtility: () => EncryptionUtility,
+  EntityGoneError: () => EntityGoneError,
+  EntityNotFoundError: () => EntityNotFoundError,
+  FsReadableProvider: () => FsReadableProvider,
+  HashAlgorithm: () => HashAlgorithm,
+  HashEncoding: () => HashEncoding,
+  InternalError: () => InternalError,
+  MultiTransactionObservabilityManager: () => MultiTransactionObservabilityManager,
+  PublicNonRecoverableError: () => PublicNonRecoverableError,
+  RequestValidationError: () => RequestValidationError,
+  callChunked: () => callChunked,
+  chunk: () => chunk,
+  convertDateFieldsToIsoString: () => convertDateFieldsToIsoString,
+  copyWithoutEmpty: () => copyWithoutEmpty,
+  copyWithoutUndefined: () => copyWithoutUndefined,
+  createRangeValidator: () => createRangeValidator,
+  deepClone: () => deepClone,
+  ensureClosingSlashTransformer: () => ensureClosingSlashTransformer,
+  executeAndHandleGlobalErrors: () => executeAndHandleGlobalErrors,
+  executeAsyncAndHandleGlobalErrors: () => executeAsyncAndHandleGlobalErrors,
+  executeSettleAllAndHandleGlobalErrors: () => executeSettleAllAndHandleGlobalErrors,
+  failure: () => failure,
+  generateChecksumForBufferOrString: () => generateChecksumForBufferOrString,
+  generateChecksumForObject: () => generateChecksumForObject,
+  generateChecksumForReadable: () => generateChecksumForReadable,
+  generateHash: () => generateHash,
+  globalLogger: () => globalLogger,
+  groupBy: () => groupBy,
+  groupByPath: () => groupByPath,
+  groupByUnique: () => groupByUnique,
+  hasMessage: () => hasMessage,
+  isEmptyObject: () => isEmptyObject,
+  isEntityGoneError: () => isEntityGoneError,
+  isError: () => isError,
+  isFailure: () => isFailure,
+  isInternalError: () => isInternalError,
+  isObject: () => isObject,
+  isPublicNonRecoverableError: () => isPublicNonRecoverableError,
+  isStandardizedError: () => isStandardizedError,
+  isSuccess: () => isSuccess,
+  pick: () => pick,
+  pickWithoutUndefined: () => pickWithoutUndefined,
+  removeDuplicates: () => removeDuplicates,
+  removeFalsy: () => removeFalsy,
+  removeNullish: () => removeNullish,
+  resolveGlobalErrorLogObject: () => resolveGlobalErrorLogObject,
+  resolveLogger: () => resolveLogger,
+  resolveLoggerConfiguration: () => resolveLoggerConfiguration,
+  resolveMonorepoLogger: () => resolveMonorepoLogger,
+  resolveMonorepoLoggerConfiguration: () => resolveMonorepoLoggerConfiguration,
+  success: () => success,
+  waitAndRetry: () => waitAndRetry
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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
+var crypto = __toESM(require("crypto"), 1);
+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
+var import_dot_prop = __toESM(require("dot-prop"), 1);
+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 = import_dot_prop.default.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
+var import_node_crypto = require("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 (0, import_node_crypto.createHash)(algorithm2).update(data).digest(encoding);
+}
+
+// src/logging/loggerConfigResolver.ts
+var import_pino = require("pino");
+var import_pino_pretty = __toESM(require("pino-pretty"), 1);
+function resolveMonorepoLogger(appConfig) {
+  if (appConfig.nodeEnv !== "development") {
+    return resolveLogger(appConfig);
+  }
+  const configuration = resolveMonorepoLoggerConfiguration(appConfig);
+  return (0, import_pino.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 (0, import_pino.pino)(configuration);
+}
+function resolveLoggerConfiguration(appConfig) {
+  if (appConfig.nodeEnv !== "production") {
+    return (0, import_pino.pino)(
+      (0, import_pino_pretty.default)({
+        sync: true,
+        minimumLevel: appConfig.logLevel,
+        colorize: true,
+        translateTime: "SYS:standard",
+        ignore: "hostname,pid"
+      })
+    );
+  }
+  return {
+    level: appConfig.logLevel,
+    formatters: {
+      level: (_label, numericLevel) => {
+        const level = import_pino.levels.labels[numericLevel] || "unknown";
+        return { level };
+      }
+    },
+    redact: appConfig.redact
+  };
+}
+
+// src/errors/globalErrorHandler.ts
+var import_node_util = require("util");
+var import_pino2 = require("pino");
+var globalLogger = (0, import_pino2.pino)({
+  formatters: {
+    level: (_label, numericLevel) => {
+      const level = import_pino2.levels.labels[numericLevel] || "unknown";
+      return { level };
+    }
+  }
+});
+function resolveGlobalErrorLogObject(err, correlationId) {
+  if (import_node_util.types.isNativeError(err)) {
+    return {
+      message: err.message,
+      error: import_pino2.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
+var import_node_http2 = require("http2");
+var RequestValidationError = class extends PublicNonRecoverableError {
+  constructor(errors) {
+    super({
+      message: "Invalid params",
+      errorCode: "VALIDATION_ERROR",
+      httpStatusCode: import_node_http2.constants.HTTP_STATUS_BAD_REQUEST,
+      details: {
+        error: errors
+      }
+    });
+  }
+};
+var AccessDeniedError = class extends PublicNonRecoverableError {
+  constructor(params) {
+    super({
+      message: params.message,
+      errorCode: "ACCESS_DENIED",
+      httpStatusCode: import_node_http2.constants.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: import_node_http2.constants.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: import_node_http2.constants.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
+var import_node_crypto2 = require("crypto");
+var HASH_ALGORITHM = "md5";
+function generateChecksumForBufferOrString(data) {
+  return (0, import_node_crypto2.createHash)(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 = (0, import_node_crypto2.createHash)(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
+var import_node_constants = require("constants");
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_stream = require("stream");
+var FsReadableProvider = class _FsReadableProvider {
+  storageFile;
+  constructor(options) {
+    this.storageFile = options.storageFile;
+  }
+  fileExists() {
+    return new Promise((resolve) => {
+      (0, import_node_fs.access)(this.storageFile, import_node_constants.F_OK, (err) => {
+        return resolve(!err);
+      });
+    });
+  }
+  async getContentLength() {
+    if (!await this.fileExists()) {
+      throw new Error(`File ${this.storageFile} was already deleted.`);
+    }
+    const stats = await (0, import_promises.stat)(this.storageFile);
+    return stats.size;
+  }
+  async createStream() {
+    if (!await this.fileExists()) {
+      throw new Error(`File ${this.storageFile} was already deleted.`);
+    }
+    return (0, import_node_fs.createReadStream)(this.storageFile);
+  }
+  async destroy() {
+    if (!await this.fileExists()) {
+      return;
+    }
+    return (0, import_promises.unlink)(this.storageFile);
+  }
+  async persist(sourceReadable) {
+    const writable = (0, import_node_fs.createWriteStream)(this.storageFile);
+    return new Promise((resolve, reject) => {
+      (0, import_node_stream.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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs.map