hide-a-bed 5.0.0 → 5.0.3

package/README.md

@@ -1,5 +1,22 @@
-API 
--------------
+### API Quick Reference
+
+🍭 denotes a *Sugar* api - helps makes some tasks sweet and easy, but may hide some complexities you might want to deal with. 
+
+| Document Operations | Bulk Operations | View Operations | Changes Feed |
+|-------------------|-----------------|-----------------|-----------------|
+| [`get()`](#get) | [`bulkGet()`](#bulkget) | [`query()`](#query) | [`changes()`](#changes) |
+| [`put()`](#put) | [`bulkSave()`](#bulksave) | [`queryStream()`](#querystream) | [`watchDocs()`](#watchDocs) 🍭 |
+| [`patch()`](#patch) 🍭 | [`bulkRemove()`](#bulkremove) |  | |
+| [`patchDangerously()`](#patchdangerously) 🍭 | [`bulkGetDictionary()`](#bulkgetdictionary) 🍭 | | |
+| [`getAtRev()`](#getatrev) 🍭 | [`bulkSaveTransaction()`](#bulksavetransaction) 🍭 | | |
+| [`createLock()`](#createLock) 🍭 | | | |
+| [`removeLock()`](#removeLock) 🍭 | | | |
+
+And some utility apis
+
+ - [`createQuery()`](#createquery) 🍭
+ - [`withRetry()`](#withretry)
+ 
 
 ### Setup
 
@@ -26,24 +43,6 @@ const db = bindConfig(process.env)
 const doc = db.get('doc-123')
 ```
 
-### API Quick Reference
-
-| Document Operations | Bulk Operations | View Operations |
-|-------------------|-----------------|-----------------|
-| [`get()`](#get) | [`bulkGet()`](#bulkget) | [`query()`](#query) |
-| [`put()`](#put) | [`bulkSave()`](#bulksave) | [`queryStream()`](#querystream) |
-| [`patch()`](#patch) | [`bulkRemove()`](#bulkremove) | [`createQuery()`](#createquery) |
-| [`patchDangerously()`](#patchdangerously) | [`bulkGetDictionary()`](#bulkgetdictionary) | |
-| [`getAtRev()`](#getatrev) | [`bulkSaveTransaction()`](#bulksavetransaction) | |
-
-
-Some *Sugar* API helpers
-
- - [`createLock()`](#createLock)
- - [`removeLock()`](#removeLock)
- - [`changes()`](#changes)
- - [`watchDocs()`](#watchDocs)
-
 ### Document Operations
 
 #### get
@@ -284,7 +283,7 @@ const results = await bulkRemove(config, ids)
 
 #### bulkGetDictionary
 
-Adds some convenience to bulkGet. Found and notFound documents are separated. Both properties are records of id to result. This makes it easy to deal with the results.
+Adds some convenience to bulkGet. Organizes found and notFound documents into properties that are {id:result}. This makes it easy to deal with the results.
 
 **Parameters:**
 - `config`: Object with `couch` URL string
@@ -480,79 +479,9 @@ const init = async () => {
 }
 init()
 ```
-Advanced Config Options
-=======================
-
-The config object supports the following properties:
-
-| Property | Type | Default | Description |
-|----------|------|---------|-------------|
-| couch | string | required | The URL of the CouchDB database |
-| throwOnGetNotFound | boolean | false | If true, throws an error when get() returns 404. If false, returns undefined |
-| bindWithRetry | boolean | true | When using bindConfig(), adds retry logic to bound methods |
-| maxRetries | number | 3 | Maximum number of retry attempts for retryable operations |
-| initialDelay | number | 1000 | Initial delay in milliseconds before first retry |
-| backoffFactor | number | 2 | Multiplier for exponential backoff between retries |
-| useConsoleLogger | boolean | false | If true, enables console logging when no logger is provided |
-| logger | object/function | undefined | Custom logging interface (winston-style object or function) |
-
-Example configuration with all options:
-```javascript
-const config = {
-  couch: 'http://localhost:5984/mydb',
-  throwOnGetNotFound: true,
-  bindWithRetry: true,
-  maxRetries: 5,
-  initialDelay: 2000,
-  backoffFactor: 1.5,
-  useConsoleLogger: true,
-  logger: (level, ...args) => console.log(level, ...args)
-}
-```
 
-
-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
+Want to consume this in the browser? I'd recomment https://www.npmjs.com/package/ndjson-readablestream 
+here is a react component that consumes it https://github.com/Azure-Samples/azure-search-openai-demo/pull/532/files#diff-506debba46b93087dc46a916384e56392808bcc02a99d9291557f3e674d4ad6c
 
 #### changes()
 
@@ -659,3 +588,77 @@ Watch specific documents for changes in real-time.
  - Triggering actions when particular documents change
  - Maintaining cached copies of frequently accessed documents
 
+Advanced Config Options
+=======================
+
+The config object supports the following properties:
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| couch | string | required | The URL of the CouchDB database |
+| throwOnGetNotFound | boolean | false | If true, throws an error when get() returns 404. If false, returns undefined |
+| bindWithRetry | boolean | true | When using bindConfig(), adds retry logic to bound methods |
+| maxRetries | number | 3 | Maximum number of retry attempts for retryable operations |
+| initialDelay | number | 1000 | Initial delay in milliseconds before first retry |
+| backoffFactor | number | 2 | Multiplier for exponential backoff between retries |
+| useConsoleLogger | boolean | false | If true, enables console logging when no logger is provided |
+| logger | object/function | undefined | Custom logging interface (winston-style object or function) |
+
+Example configuration with all options:
+```javascript
+const config = {
+  couch: 'http://localhost:5984/mydb',
+  throwOnGetNotFound: true,
+  bindWithRetry: true,
+  maxRetries: 5,
+  initialDelay: 2000,
+  backoffFactor: 1.5,
+  useConsoleLogger: true,
+  logger: (level, ...args) => console.log(level, ...args)
+}
+```
+
+
+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
+

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 = structuredClone(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;
+});