hide-a-bed 5.0.2 → 5.0.4

package/cjs/impl/bulk.cjs

@@ -0,0 +1,267 @@
+"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);
+var bulk_exports = {};
+__export(bulk_exports, {
+  bulkGet: () => bulkGet,
+  bulkGetDictionary: () => bulkGetDictionary,
+  bulkRemove: () => bulkRemove,
+  bulkSave: () => bulkSave,
+  bulkSaveTransaction: () => bulkSaveTransaction
+});
+module.exports = __toCommonJS(bulk_exports);
+var import_needle = __toESM(require("needle"), 1);
+var import_bulk = require("../schema/bulk.cjs");
+var import_retry = require("./retry.cjs");
+var import_crud = require("./crud.cjs");
+var import_errors = require("./errors.cjs");
+var import_transactionErrors = require("./transactionErrors.cjs");
+var import_logger = require("./logger.cjs");
+var import_crud2 = require("../schema/crud.cjs");
+var import_trackedEmitter = require("./trackedEmitter.cjs");
+const opts = {
+  json: true,
+  headers: {
+    "Content-Type": "application/json"
+  }
+};
+const bulkSave = import_bulk.BulkSave.implement(async (config, docs) => {
+  const logger = (0, import_logger.createLogger)(config);
+  if (!docs) {
+    logger.warn("bulkSave called with no docs");
+    return { ok: false, error: "noDocs", reason: "no docs provided" };
+  }
+  if (!docs.length) {
+    logger.warn("bulkSave called with empty docs array");
+    return { ok: false, error: "noDocs", reason: "no docs provided" };
+  }
+  logger.info(`Starting bulk save of ${docs.length} documents`);
+  const url = `${config.couch}/_bulk_docs`;
+  const body = { docs };
+  let resp;
+  try {
+    resp = await (0, import_needle.default)("post", url, body, opts);
+  } catch (err) {
+    logger.error("Network error during bulk save:", err);
+    import_errors.RetryableError.handleNetworkError(err);
+  }
+  if (!resp) {
+    logger.error("No response received from bulk save request");
+    throw new import_errors.RetryableError("no response", 503);
+  }
+  if (import_errors.RetryableError.isRetryableStatusCode(resp.statusCode)) {
+    logger.warn(`Retryable status code received: ${resp.statusCode}`);
+    throw new import_errors.RetryableError("retryable error during bulk save", resp.statusCode);
+  }
+  if (resp.statusCode !== 201) {
+    logger.error(`Unexpected status code: ${resp.statusCode}`);
+    throw new Error("could not save");
+  }
+  const results = resp?.body || [];
+  return results;
+});
+const bulkGet = import_bulk.BulkGet.implement(async (config, ids) => {
+  const logger = (0, import_logger.createLogger)(config);
+  const keys = ids;
+  logger.info(`Starting bulk get for ${keys.length} documents`);
+  const url = `${config.couch}/_all_docs?include_docs=true`;
+  const payload = { keys };
+  let resp;
+  try {
+    resp = await (0, import_needle.default)("post", url, payload, opts);
+  } catch (err) {
+    logger.error("Network error during bulk get:", err);
+    import_errors.RetryableError.handleNetworkError(err);
+  }
+  if (!resp) {
+    logger.error("No response received from bulk get request");
+    throw new import_errors.RetryableError("no response", 503);
+  }
+  if (import_errors.RetryableError.isRetryableStatusCode(resp.statusCode)) {
+    logger.warn(`Retryable status code received: ${resp.statusCode}`);
+    throw new import_errors.RetryableError("retryable error during bulk get", resp.statusCode);
+  }
+  if (resp.statusCode !== 200) {
+    logger.error(`Unexpected status code: ${resp.statusCode}`);
+    throw new Error("could not fetch");
+  }
+  const body = resp.body;
+  return body;
+});
+const bulkRemove = import_bulk.BulkRemove.implement(async (config, ids) => {
+  const logger = (0, import_logger.createLogger)(config);
+  logger.info(`Starting bulk remove for ${ids.length} documents`);
+  const resp = await bulkGet(config, ids);
+  const toRemove = [];
+  resp.rows.forEach((row) => {
+    if (!row.doc) return;
+    try {
+      const d = import_crud2.CouchDoc.parse(row.doc);
+      d._deleted = true;
+      toRemove.push(d);
+    } catch (e) {
+      logger.warn(`Invalid document structure in bulk remove: ${row.id}`, e);
+    }
+  });
+  return bulkSave(config, toRemove);
+});
+const bulkGetDictionary = import_bulk.BulkGetDictionary.implement(async (config, ids) => {
+  const resp = await bulkGet(config, ids);
+  const results = { found: {}, notFound: {} };
+  resp.rows.forEach(
+    /** @param { import('../schema/query.mjs').ViewRowSchema } row */
+    (row) => {
+      if (!row.key) return;
+      if (row.error) {
+        results.notFound[row.key] = row;
+        return;
+      }
+      try {
+        const doc = import_crud2.CouchDoc.parse(row.doc);
+        results.found[doc._id] = doc;
+      } catch (e) {
+        results.notFound[row.key] = row;
+      }
+    }
+  );
+  return results;
+});
+const bulkSaveTransaction = import_bulk.BulkSaveTransaction.implement(async (config, transactionId, docs) => {
+  const emitter = (0, import_trackedEmitter.setupEmitter)(config);
+  const logger = (0, import_logger.createLogger)(config);
+  const retryOptions = {
+    maxRetries: config.maxRetries ?? 10,
+    initialDelay: config.initialDelay ?? 1e3,
+    backoffFactor: config.backoffFactor ?? 2
+  };
+  const _put = config.bindWithRetry ? (0, import_retry.withRetry)(import_crud.put.bind(null, config), retryOptions) : import_crud.put.bind(null, config);
+  logger.info(`Starting bulk save transaction ${transactionId} for ${docs.length} documents`);
+  const txnDoc = {
+    _id: `txn:${transactionId}`,
+    _rev: null,
+    type: "transaction",
+    status: "pending",
+    changes: docs,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  let txnresp = await _put(txnDoc);
+  logger.debug("Transaction document created:", txnDoc, txnresp);
+  await emitter.emit("transaction-created", { txnresp, txnDoc });
+  if (txnresp.error) {
+    throw new import_transactionErrors.TransactionSetupError("Failed to create transaction document", {
+      error: txnresp.error,
+      response: txnresp.body
+    });
+  }
+  const existingDocs = await bulkGetDictionary(config, docs.map((d) => d._id));
+  logger.debug("Fetched current revisions of documents:", existingDocs);
+  await emitter.emit("transaction-revs-fetched", existingDocs);
+  const revErrors = [];
+  docs.forEach((d) => {
+    if (existingDocs.found[d._id] && existingDocs.found[d._id]._rev !== d._rev) revErrors.push(d._id);
+    if (existingDocs.notFound[d._id] && d._rev) revErrors.push(d._id);
+  });
+  if (revErrors.length > 0) {
+    throw new import_transactionErrors.TransactionVersionConflictError(revErrors);
+  }
+  logger.debug("Checked document revisions:", existingDocs);
+  await emitter.emit("transaction-revs-checked", existingDocs);
+  const providedDocsById = {};
+  docs.forEach((d) => {
+    if (!d._id) return;
+    providedDocsById[d._id] = d;
+  });
+  const newDocsToRollback = [];
+  const potentialExistingDocsToRollack = [];
+  const failedDocs = [];
+  try {
+    logger.info("Transaction started:", txnDoc);
+    await emitter.emit("transaction-started", txnDoc);
+    const results = await bulkSave(config, docs);
+    logger.info("Transaction updates applied:", results);
+    await emitter.emit("transaction-updates-applied", results);
+    results.forEach((r) => {
+      if (!r.id) return;
+      if (!r.error) {
+        if (existingDocs.notFound[r.id]) newDocsToRollback.push(r);
+        if (existingDocs.found[r.id]) potentialExistingDocsToRollack.push(r);
+      } else {
+        failedDocs.push(r);
+      }
+    });
+    if (failedDocs.length > 0) {
+      throw new import_transactionErrors.TransactionBulkOperationError(failedDocs);
+    }
+    txnDoc.status = "completed";
+    txnDoc._rev = txnresp.rev;
+    txnresp = await _put(txnDoc);
+    logger.info("Transaction completed:", txnDoc);
+    await emitter.emit("transaction-completed", { txnresp, txnDoc });
+    if (txnresp.statusCode !== 201) {
+      logger.error("Failed to update transaction status to completed");
+    }
+    return results;
+  } catch (error) {
+    logger.error("Transaction failed, attempting rollback:", error);
+    const toRollback = [];
+    potentialExistingDocsToRollack.forEach((row) => {
+      if (!row.id || !row.rev) return;
+      const doc = existingDocs.found[row.id];
+      doc._rev = row.rev;
+      toRollback.push(doc);
+    });
+    newDocsToRollback.forEach((d) => {
+      if (!d.id || !d.rev) return;
+      const before = JSON.parse(JSON.stringify(providedDocsById[d.id]));
+      before._rev = d.rev;
+      before._deleted = true;
+      toRollback.push(before);
+    });
+    const bulkRollbackResult = await bulkSave(config, toRollback);
+    let status = "rolled_back";
+    bulkRollbackResult.forEach((r) => {
+      if (r.error) status = "rollback_failed";
+    });
+    logger.warn("Transaction rolled back:", { bulkRollbackResult, status });
+    await emitter.emit("transaction-rolled-back", { bulkRollbackResult, status });
+    txnDoc.status = status;
+    txnDoc._rev = txnresp.rev;
+    txnresp = await _put(txnDoc);
+    logger.warn("Transaction rollback status updated:", txnDoc);
+    await emitter.emit("transaction-rolled-back-status", { txnresp, txnDoc });
+    if (txnresp.statusCode !== 201) {
+      logger.error("Failed to update transaction status to rolled_back");
+    }
+    throw new import_transactionErrors.TransactionRollbackError(
+      "Transaction failed and rollback was unsuccessful",
+      /** @type {Error} */
+      error,
+      bulkRollbackResult
+    );
+  }
+});

package/cjs/impl/changes.cjs

@@ -0,0 +1,67 @@
+"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);
+var changes_exports = {};
+__export(changes_exports, {
+  changes: () => changes
+});
+module.exports = __toCommonJS(changes_exports);
+var import_needle = __toESM(require("needle"), 1);
+var import_events = require("events");
+var import_changes = require("../schema/changes.cjs");
+var import_changes_stream = __toESM(require("changes-stream"), 1);
+const changes = import_changes.Changes.implement(async (config, onChange, options = {}) => {
+  const emitter = new import_events.EventEmitter();
+  options.db = config.couch;
+  if (options.since && options.since === "now") {
+    const opts = {
+      json: true,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    };
+    const resp = await (0, import_needle.default)("get", config.couch, opts);
+    options.since = resp.body.update_seq;
+  }
+  const changes2 = (0, import_changes_stream.default)(options);
+  changes2.on("readable", () => {
+    const change = changes2.read();
+    if (change.results && Array.isArray(change.results)) {
+      change.results.forEach((c) => emitter.emit("change", c));
+    } else emitter.emit("change", change);
+  });
+  emitter.on("change", onChange);
+  return {
+    on: (event, listener) => emitter.on(event, listener),
+    removeListener: (event, listener) => emitter.removeListener(event, listener),
+    stop: () => {
+      changes2.destroy();
+      emitter.removeAllListeners();
+    }
+  };
+});

package/cjs/impl/crud.cjs

@@ -0,0 +1,121 @@
+"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);
+var crud_exports = {};
+__export(crud_exports, {
+  get: () => get,
+  getAtRev: () => getAtRev,
+  put: () => put
+});
+module.exports = __toCommonJS(crud_exports);
+var import_needle = __toESM(require("needle"), 1);
+var import_crud = require("../schema/crud.cjs");
+var import_errors = require("./errors.cjs");
+var import_logger = require("./logger.cjs");
+const opts = {
+  json: true,
+  headers: {
+    "Content-Type": "application/json"
+  }
+};
+const _getWithOptions = import_crud.CouchGetWithOptions.implement(async (config, id, getOpts) => {
+  const logger = (0, import_logger.createLogger)(config);
+  const rev = getOpts?.rev;
+  const path = rev ? `${id}?rev=${rev}` : id;
+  const url = `${config.couch}/${path}`;
+  logger.info(`Getting document with id: ${id}, rev ${rev || "latest"}`);
+  try {
+    const resp = await (0, import_needle.default)("get", url, opts);
+    if (!resp) {
+      logger.error("No response received from get request");
+      throw new import_errors.RetryableError("no response", 503);
+    }
+    const result = resp?.body || {};
+    if (resp.statusCode === 404) {
+      if (config.throwOnGetNotFound) {
+        logger.warn(`Document not found (throwing error): ${id}, rev ${rev || "latest"}`);
+        throw new import_errors.NotFoundError(id, result.reason || "not_found");
+      } else {
+        logger.debug(`Document not found (returning undefined): ${id}, rev ${rev || "latest"}`);
+        return null;
+      }
+    }
+    if (import_errors.RetryableError.isRetryableStatusCode(resp.statusCode)) {
+      logger.warn(`Retryable status code received: ${resp.statusCode}`);
+      throw new import_errors.RetryableError(result.reason || "retryable error", resp.statusCode);
+    }
+    if (resp.statusCode !== 200) {
+      logger.error(`Unexpected status code: ${resp.statusCode}`);
+      throw new Error(result.reason || "failed");
+    }
+    logger.info(`Successfully retrieved document: ${id}, rev ${rev || "latest"}`);
+    return result;
+  } catch (err) {
+    logger.error("Error during get operation:", err);
+    import_errors.RetryableError.handleNetworkError(err);
+  }
+});
+const get = import_crud.CouchGet.implement(async (config, id) => {
+  const getOptions = {};
+  return _getWithOptions(config, id, getOptions);
+});
+const getAtRev = import_crud.CouchGetAtRev.implement(async (config, id, rev) => {
+  const getOptions = { rev };
+  return _getWithOptions(config, id, getOptions);
+});
+const put = import_crud.CouchPut.implement(async (config, doc) => {
+  const logger = (0, import_logger.createLogger)(config);
+  const url = `${config.couch}/${doc._id}`;
+  const body = doc;
+  logger.info(`Putting document with id: ${doc._id}`);
+  let resp;
+  try {
+    resp = await (0, import_needle.default)("put", url, body, opts);
+  } catch (err) {
+    logger.error("Error during put operation:", err);
+    import_errors.RetryableError.handleNetworkError(err);
+  }
+  if (!resp) {
+    logger.error("No response received from put request");
+    throw new import_errors.RetryableError("no response", 503);
+  }
+  const result = resp?.body || {};
+  result.statusCode = resp.statusCode;
+  if (resp.statusCode === 409) {
+    logger.warn(`Conflict detected for document: ${doc._id}`);
+    result.ok = false;
+    result.error = "conflict";
+    return result;
+  }
+  if (import_errors.RetryableError.isRetryableStatusCode(resp.statusCode)) {
+    logger.warn(`Retryable status code received: ${resp.statusCode}`);
+    throw new import_errors.RetryableError(result.reason || "retryable error", resp.statusCode);
+  }
+  logger.info(`Successfully saved document: ${doc._id}`);
+  return result;
+});

package/cjs/impl/errors.cjs

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  NotFoundError: () => NotFoundError,
+  RetryableError: () => RetryableError
+});
+module.exports = __toCommonJS(errors_exports);
+class NotFoundError extends Error {
+  /**
+   * @param {string} docId - The ID of the document that wasn't found
+   * @param {string} [message] - Optional error message
+   */
+  constructor(docId, message = "Document not found") {
+    super(message);
+    this.name = "NotFoundError";
+    this.docId = docId;
+  }
+}
+class RetryableError extends Error {
+  /**
+   * @param {string} message - The error message
+   * @param {number|undefined} statusCode - The HTTP status code
+   */
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "RetryableError";
+    this.statusCode = statusCode;
+  }
+  /**
+   * @param {number|undefined} statusCode - The HTTP status code to check
+   * @returns {boolean} Whether the status code is retryable
+   */
+  static isRetryableStatusCode(statusCode) {
+    if (statusCode === void 0) return false;
+    return [408, 429, 500, 502, 503, 504].includes(statusCode);
+  }
+  /**
+   * @param {NetworkError | unknown} err - The network error to handle
+   * @throws {RetryableError} If the error is retryable
+   * @throws {Error} If the error is not retryable
+   */
+  static handleNetworkError(err) {
+    const networkErrors = {
+      ECONNREFUSED: 503,
+      ECONNRESET: 503,
+      ETIMEDOUT: 503,
+      ENETUNREACH: 503,
+      ENOTFOUND: 503,
+      EPIPE: 503,
+      EHOSTUNREACH: 503,
+      ESOCKETTIMEDOUT: 503
+    };
+    if (typeof err === "object" && err !== null && "code" in err && typeof err.code === "string" && networkErrors[err.code]) {
+      throw new RetryableError(`Network error: ${err.code}`, networkErrors[err.code]);
+    }
+    throw err;
+  }
+}

package/cjs/impl/logger.cjs

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+__export(logger_exports, {
+  createLogger: () => createLogger
+});
+module.exports = __toCommonJS(logger_exports);
+function createLogger(config) {
+  if (config._normalizedLogger) {
+    return config._normalizedLogger;
+  }
+  if (!config.logger) {
+    if (config.useConsoleLogger) {
+      config._normalizedLogger = {
+        error: (...args) => console.error(...args),
+        warn: (...args) => console.warn(...args),
+        info: (...args) => console.info(...args),
+        debug: (...args) => console.debug(...args)
+      };
+    } else {
+      config._normalizedLogger = {
+        error: () => {
+        },
+        warn: () => {
+        },
+        info: () => {
+        },
+        debug: () => {
+        }
+      };
+    }
+    return config._normalizedLogger;
+  }
+  if (typeof config.logger === "function") {
+    config._normalizedLogger = {
+      error: (...args) => config.logger("error", ...args),
+      warn: (...args) => config.logger("warn", ...args),
+      info: (...args) => config.logger("info", ...args),
+      debug: (...args) => config.logger("debug", ...args)
+    };
+    return config._normalizedLogger;
+  }
+  config._normalizedLogger = {
+    error: config.logger.error || (() => {
+    }),
+    warn: config.logger.warn || (() => {
+    }),
+    info: config.logger.info || (() => {
+    }),
+    debug: config.logger.debug || (() => {
+    })
+  };
+  return config._normalizedLogger;
+}