hide-a-bed 3.0.1 → 4.0.1

package/README.md

@@ -1,8 +1,34 @@
 API 
 -------------
 
+### Setup
+
+Depending on your environment, use import or require
+
+```
+import { get, put, patch, remove, bulkSave, bulkGet, bulkRemove, query } from 'hide-a-bed'
+```
+```
+const { get, put, patch, remove, bulkSave, bulkGet, bulkRemove, query } = require('hide-a-bed')
+```
+
+### Config
+
+Anywhere you see a config, it is an object with the following setup
+
+```
+{ couch: 'https://username:pass@the.couch.url.com:5984' }
+```
+Couch get is weird. We have chosen to return ```undefined``` if the doc is not found. All other things throw. If you want 
+not_found to also throw an exception, add the following to your config:
+
+```
+{ throwOnGetNotFound: true, couch: '...' }
+```
+
 ### Document Operations
 
+
 #### get(config, id)
 Get a single document by ID.
 - `config`: Object with `couch` URL string
@@ -165,4 +191,82 @@ const result = await query(config, view, options)
 // }
 ```
 
+Logging Support
+==============
+
+The library supports flexible logging options that can be configured through the config object:
+
+```javascript
+// Enable console logging (error, warn, info, debug)
+const config = { 
+  couch: 'http://localhost:5984/mydb',
+  useConsoleLogger: true
+}
+
+// Use a custom logger object (winston-style)
+const config = {
+  couch: 'http://localhost:5984/mydb',
+  logger: {
+    error: (msg) => console.error(msg),
+    warn: (msg) => console.warn(msg),
+    info: (msg) => console.info(msg),
+    debug: (msg) => console.debug(msg)
+  }
+}
+
+// Use a simple function logger
+const config = {
+  couch: 'http://localhost:5984/mydb',
+  logger: (level, ...args) => console.log(level, ...args)
+}
+```
+
+The logger will track operations including:
+- Document operations (get, put, patch)
+- Bulk operations
+- View queries
+- Streaming operations
+- Retries and error handling
+
+Each operation logs appropriate information at these levels:
+- error: Fatal/unrecoverable errors
+- warn: Retryable errors, conflicts
+- info: Operation start/completion
+- debug: Detailed operation information
+
+
+Streaming Support
+=================
+
+Want to stream data from couch? You can with queryStream. It looks identical to query, except you add an extra 'onRow' function
+
+Here is a small hapi example of streaming data from couch to the client as ndjson. 
+We do a small transform by only streaming the doc. you can do a lot of things in the onrow function.
+
+```
+import Hapi from '@hapi/hapi';
+import { Readable } from 'stream';
+import { queryStream } from bindConfig(process.env)
+const view = '_design/users/_view/by_name'
+
+const init = async () => {
+  const server = Hapi.server({ port: 3000 })
+  server.route({
+    method: 'GET',
+    path: '/stream',
+    handler: async (request, h) => {
+      const stream = new Readable({ read() {} });
+      const onRow = ({id, key, value, doc}) => stream.push(JSON.stringify(doc) + '\n')
+      const options = { startkey: req.query.startLetter, endkey: req.query.startLetter + '|', include_docs: true}
+      await queryStream(view, options, onRow)
+      stream.push(null) // end stream
+      return h.response(stream).type('application/x-ndjson');
+    }
+  })
+
+  await server.start();
+  console.log(`Server running on ${server.info.uri}`);
+}
+init()
+```
 

package/cjs/impl/bulk.cjs

@@ -35,6 +35,8 @@ __export(bulk_exports, {
 module.exports = __toCommonJS(bulk_exports);
 var import_needle = __toESM(require("needle"), 1);
 var import_bulk = require("../schema/bulk.cjs");
+var import_errors = require("./errors.cjs");
+var import_logger = require("./logger.cjs");
 const opts = {
   json: true,
   headers: {
@@ -42,21 +44,65 @@ const opts = {
   }
 };
 const bulkSave = import_bulk.BulkSave.implement(async (config, docs) => {
-  if (!docs) return { ok: false, error: "noDocs", reason: "no docs provided" };
-  if (!docs.length) return { ok: false, error: "noDocs", reason: "no docs provided" };
+  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 };
-  const resp = await (0, import_needle.default)("post", url, body, opts);
-  if (resp.statusCode !== 201) throw new Error("could not save");
+  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 body = { keys };
-  const resp = await (0, import_needle.default)("post", url, body, opts);
-  if (resp.statusCode !== 200) throw new Error("could not fetch");
+  let resp;
+  try {
+    resp = await (0, import_needle.default)("post", url, body, 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 rows = resp?.body?.rows || [];
   const docs = [];
   rows.forEach((r) => {
@@ -66,9 +112,12 @@ const bulkGet = import_bulk.BulkGet.implement(async (config, ids) => {
     const doc = r.doc;
     docs.push(doc);
   });
+  logger.info(`Successfully retrieved ${docs.length} documents`);
   return docs;
 });
 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 docs = await bulkGet(config, ids);
   docs.forEach((d) => {
     d._deleted = true;

package/cjs/impl/crud.cjs

@@ -34,6 +34,8 @@ __export(crud_exports, {
 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: {
@@ -41,24 +43,72 @@ const opts = {
   }
 };
 const get = import_crud.CouchGet.implement(async (config, id) => {
+  const logger = (0, import_logger.createLogger)(config);
   const url = `${config.couch}/${id}`;
-  const resp = await (0, import_needle.default)("get", url, opts);
-  if (resp.statusCode === 404) return null;
-  const result = resp?.body || {};
-  if (resp.statusCode !== 200) {
-    throw new Error(result.reason || "failed");
+  logger.info(`Getting document with id: ${id}`);
+  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);
+    }
+    if (resp.statusCode === 404) {
+      logger.debug(`Document not found: ${id}`);
+      return null;
+    }
+    const result = resp?.body || {};
+    if (resp.statusCode === 404) {
+      if (config.throwOnGetNotFound) {
+        logger.warn(`Document not found (throwing error): ${id}`);
+        throw new Error(result.reason || "not_found");
+      } else {
+        logger.debug(`Document not found (returning undefined): ${id}`);
+        return void 0;
+      }
+    }
+    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}`);
+    return result;
+  } catch (err) {
+    logger.error("Error during get operation:", err);
+    import_errors.RetryableError.handleNetworkError(err);
   }
-  return result;
 });
 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;
-  const resp = await (0, import_needle.default)("put", url, body, opts);
+  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,63 @@
+"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, {
+  RetryableError: () => RetryableError
+});
+module.exports = __toCommonJS(errors_exports);
+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,61 @@
+"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) {
+    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;
+}

package/cjs/impl/patch.cjs

@@ -18,19 +18,21 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var patch_exports = {};
 __export(patch_exports, {
-  patch: () => patch
+  patch: () => patch,
+  sleep: () => sleep
 });
 module.exports = __toCommonJS(patch_exports);
 var import_crud = require("./crud.cjs");
 var import_patch = require("../schema/patch.cjs");
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const patch = import_patch.CouchPatch.implement(async (config, id, properties) => {
-  const maxRetries = config.retries || 5;
-  const delay = config.delay || 1e3;
+const patch = import_patch.Patch.implement(async (config, id, properties) => {
+  const maxRetries = config.maxRetries || 5;
+  let delay = config.initialDelay || 1e3;
   let attempts = 0;
   while (attempts <= maxRetries) {
     try {
       const doc = await (0, import_crud.get)(config, id);
+      if (!doc) return { ok: false, statusCode: 404, error: "not_found" };
       const updatedDoc = { ...doc, ...properties };
       const result = await (0, import_crud.put)(config, updatedDoc);
       if (result.ok) {
@@ -41,10 +43,13 @@ const patch = import_patch.CouchPatch.implement(async (config, id, properties) =
         throw new Error(`Failed to patch after ${maxRetries} attempts`);
       }
       await sleep(delay);
+      delay *= config.backoffFactor;
     } catch (err) {
+      if (err.message !== "not_found") return { ok: false, statusCode: 404, error: "not_found" };
       attempts++;
       if (attempts > maxRetries) {
-        throw new Error(`Failed to patch after ${maxRetries} attempts: ${err.message}`);
+        const error = `Failed to patch after ${maxRetries} attempts: ${err.message}`;
+        return { ok: false, statusCode: 500, error };
       }
       await sleep(delay);
     }

package/cjs/impl/query.cjs

@@ -35,6 +35,7 @@ module.exports = __toCommonJS(query_exports);
 var import_zod = require("zod");
 var import_needle = __toESM(require("needle"), 1);
 var import_query = require("../schema/query.cjs");
+var import_errors = require("./errors.cjs");
 var import_lodash = __toESM(require("lodash"), 1);
 const { includes } = import_lodash.default;
 const query = import_query.SimpleViewQuery.implement(async (config, view, options) => {
@@ -46,8 +47,17 @@ const query = import_query.SimpleViewQuery.implement(async (config, view, option
     }
   };
   const url = `${config.couch}/${view}?${qs.toString()}`;
-  const results = await (0, import_needle.default)("get", url, opts);
+  let results;
+  try {
+    results = await (0, import_needle.default)("get", url, opts);
+  } catch (err) {
+    import_errors.RetryableError.handleNetworkError(err);
+  }
+  if (!results) throw new import_errors.RetryableError("no response", 503);
   const body = results.body;
+  if (import_errors.RetryableError.isRetryableStatusCode(results.statusCode)) {
+    throw new import_errors.RetryableError(body.error || "retryable error during query", results.statusCode);
+  }
   if (body.error) throw new Error(body.error);
   return body;
 });

package/cjs/impl/retry.cjs

@@ -0,0 +1,54 @@
+"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 retry_exports = {};
+__export(retry_exports, {
+  withRetry: () => withRetry
+});
+module.exports = __toCommonJS(retry_exports);
+var import_errors = require("./errors.cjs");
+var import_patch = require("./patch.cjs");
+function withRetry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    initialDelay = 1e3,
+    // 1 second
+    backoffFactor = 2
+    // exponential backoff multiplier
+  } = options;
+  return async (...args) => {
+    let lastError;
+    let delay = initialDelay;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn(...args);
+      } catch (error) {
+        lastError = error;
+        if (!(error instanceof import_errors.RetryableError)) {
+          throw error;
+        }
+        if (attempt === maxRetries) {
+          throw error;
+        }
+        await (0, import_patch.sleep)(delay);
+        delay *= backoffFactor;
+      }
+    }
+    throw lastError;
+  };
+}

package/cjs/impl/stream.cjs

@@ -33,17 +33,58 @@ __export(stream_exports, {
 module.exports = __toCommonJS(stream_exports);
 var import_needle = __toESM(require("needle"), 1);
 var import_query = require("./query.cjs");
+var import_errors = require("./errors.cjs");
 var import_JSONStream = __toESM(require("JSONStream"), 1);
-const queryStream = (config, view, options) => new Promise((resolve, reject) => {
+const queryStream = (config, view, options, onRow) => new Promise((resolve, reject) => {
   if (!options) options = {};
-  const { onRow, ...rest } = options;
-  const qs = (0, import_query.queryString)(rest, ["key", "startkey", "endkey", "reduce", "group", "group_level", "stale", "limit"]);
+  const qs = (0, import_query.queryString)(options, ["key", "startkey", "endkey", "reduce", "group", "group_level", "stale", "limit"]);
   const url = `${config.couch}/${view}?${qs.toString()}`;
+  const opts = {
+    json: true,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    parse_response: false
+    // Keep as stream
+  };
   const streamer = import_JSONStream.default.parse("rows.*");
   streamer.on("data", onRow);
-  streamer.on("end", (err) => {
-    if (err) return reject(err);
-    resolve(null);
+  streamer.on(
+    "error",
+    /** @param {Error} err */
+    (err) => {
+      reject(new Error(`Stream parsing error: ${err.message}`));
+    }
+  );
+  streamer.on(
+    "done",
+    /** @param {Error|null} err */
+    (err) => {
+      try {
+        import_errors.RetryableError.handleNetworkError(err);
+      } catch (e) {
+        reject(e);
+      }
+    }
+  );
+  streamer.on("end", () => {
+    resolve(void 0);
   });
-  import_needle.default.get(url).pipe(streamer);
+  const req = import_needle.default.get(url, opts);
+  req.on("response", (response) => {
+    if (import_errors.RetryableError.isRetryableStatusCode(response.statusCode)) {
+      reject(new import_errors.RetryableError("retryable error during stream query", response.statusCode));
+      return;
+    }
+  });
+  req.on("error", (err) => {
+    try {
+      import_errors.RetryableError.handleNetworkError(err);
+    } catch (retryErr) {
+      reject(retryErr);
+      return;
+    }
+    reject(err);
+  });
+  req.pipe(streamer);
 });

package/cjs/index.cjs

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
+  bindConfig: () => bindConfig,
   bulkGet: () => import_bulk.bulkGet,
   bulkRemove: () => import_bulk.bulkRemove,
   bulkSave: () => import_bulk.bulkSave,
@@ -26,7 +27,8 @@ __export(index_exports, {
   put: () => import_crud.put,
   query: () => import_query.query,
   queryStream: () => import_stream.queryStream,
-  schema: () => schema
+  schema: () => schema,
+  withRetry: () => import_retry.withRetry
 });
 module.exports = __toCommonJS(index_exports);
 var import_bulk = require("./impl/bulk.cjs");
@@ -34,21 +36,43 @@ var import_crud = require("./impl/crud.cjs");
 var import_patch = require("./impl/patch.cjs");
 var import_query = require("./impl/query.cjs");
 var import_stream = require("./impl/stream.cjs");
+var import_retry = require("./impl/retry.cjs");
 var import_bulk2 = require("./schema/bulk.cjs");
 var import_config = require("./schema/config.cjs");
 var import_query2 = require("./schema/query.cjs");
+var import_stream2 = require("./schema/stream.cjs");
 var import_patch2 = require("./schema/patch.cjs");
 var import_crud2 = require("./schema/crud.cjs");
+var import_bind = require("./schema/bind.cjs");
 const schema = {
   CouchConfig: import_config.CouchConfig,
   SimpleViewQuery: import_query2.SimpleViewQuery,
   SimpleViewQueryResponse: import_query2.SimpleViewQueryResponse,
+  SimpleViewQueryStream: import_stream2.SimpleViewQueryStream,
+  OnRow: import_stream2.OnRow,
   BulkSave: import_bulk2.BulkSave,
   BulkGet: import_bulk2.BulkGet,
   CouchGet: import_crud2.CouchGet,
   CouchPut: import_crud2.CouchPut,
   CouchDoc: import_crud2.CouchDoc,
   CouchDocResponse: import_crud2.CouchDocResponse,
-  PatchConfig: import_patch2.PatchConfig,
   Patch: import_patch2.Patch
 };
+const bindConfig = import_bind.Bind.implement((config) => {
+  const retryOptions = {
+    maxRetries: config.maxRetries ?? 10,
+    initialDelay: config.initialDelay ?? 1e3,
+    backoffFactor: config.backoffFactor ?? 2
+  };
+  return {
+    get: config.bindWithRetry ? (0, import_retry.withRetry)(import_crud.get.bind(null, config), retryOptions) : import_crud.get.bind(null, config),
+    put: config.bindWithRetry ? (0, import_retry.withRetry)(import_crud.put.bind(null, config), retryOptions) : import_crud.put.bind(null, config),
+    patch: import_patch.patch.bind(null, config),
+    // patch not included in retry
+    bulkGet: config.bindWithRetry ? (0, import_retry.withRetry)(import_bulk.bulkGet.bind(null, config), retryOptions) : import_bulk.bulkGet.bind(null, config),
+    bulkSave: config.bindWithRetry ? (0, import_retry.withRetry)(import_bulk.bulkSave.bind(null, config), retryOptions) : import_bulk.bulkSave.bind(null, config),
+    bulkRemove: config.bindWithRetry ? (0, import_retry.withRetry)(import_bulk.bulkRemove.bind(null, config), retryOptions) : import_bulk.bulkRemove.bind(null, config),
+    query: config.bindWithRetry ? (0, import_retry.withRetry)(import_query.query.bind(null, config), retryOptions) : import_query.query.bind(null, config),
+    queryStream: config.bindWithRetry ? (0, import_retry.withRetry)(import_stream.queryStream.bind(null, config), retryOptions) : import_stream.queryStream.bind(null, config)
+  };
+});