hide-a-bed 5.0.2 → 5.0.4

package/cjs/impl/sugar/watch.cjs

@@ -0,0 +1,159 @@
+"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 watch_exports = {};
+__export(watch_exports, {
+  watchDocs: () => watchDocs
+});
+module.exports = __toCommonJS(watch_exports);
+var import_needle = __toESM(require("needle"), 1);
+var import_events = require("events");
+var import_errors = require("../errors.cjs");
+var import_logger = require("../logger.cjs");
+var import_patch = require("../patch.cjs");
+var import_watch = require("../../schema/sugar/watch.cjs");
+const watchDocs = import_watch.WatchDocs.implement((config, docIds, onChange, options = {}) => {
+  const logger = (0, import_logger.createLogger)(config);
+  const emitter = new import_events.EventEmitter();
+  let lastSeq = "now";
+  let stopping = false;
+  let retryCount = 0;
+  let currentRequest = null;
+  const maxRetries = options.maxRetries || 10;
+  const initialDelay = options.initialDelay || 1e3;
+  const maxDelay = options.maxDelay || 3e4;
+  const _docIds = Array.isArray(docIds) ? docIds : [docIds];
+  if (_docIds.length === 0) throw new Error("docIds must be a non-empty array");
+  if (_docIds.length > 100) throw new Error("docIds must be an array of 100 or fewer elements");
+  const connect = async () => {
+    if (stopping) return;
+    const feed = "continuous";
+    const includeDocs = options.include_docs ?? false;
+    const ids = _docIds.join('","');
+    const url = `${config.couch}/_changes?feed=${feed}&since=${lastSeq}&include_docs=${includeDocs}&filter=_doc_ids&doc_ids=["${ids}"]`;
+    const opts = {
+      headers: { "Content-Type": "application/json" },
+      parse_response: false
+    };
+    let buffer = "";
+    currentRequest = import_needle.default.get(url, opts);
+    currentRequest.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const change = JSON.parse(line);
+            if (!change.id) return null;
+            logger.debug(`Change detected, watching [${_docIds}]`, change);
+            lastSeq = change.seq || change.last_seq;
+            emitter.emit("change", change);
+          } catch (err) {
+            logger.error("Error parsing change:", err, "Line:", line);
+          }
+        }
+      }
+    });
+    currentRequest.on("response", (response) => {
+      logger.debug(`Received response with status code, watching [${_docIds}]: ${response.statusCode}`);
+      if (import_errors.RetryableError.isRetryableStatusCode(response.statusCode)) {
+        logger.warn(`Retryable status code received: ${response.statusCode}`);
+        currentRequest.abort();
+        handleReconnect();
+      } else {
+        retryCount = 0;
+      }
+    });
+    currentRequest.on("error", async (err) => {
+      if (stopping) {
+        logger.info("stopping in progress, ignore stream error");
+        return;
+      }
+      logger.error(`Network error during stream, watching [${_docIds}]:`, err.toString());
+      try {
+        import_errors.RetryableError.handleNetworkError(err);
+      } catch (filteredError) {
+        if (filteredError instanceof import_errors.RetryableError) {
+          logger.info(`Retryable error, watching [${_docIds}]:`, filteredError.toString());
+          handleReconnect();
+        } else {
+          logger.error(`Non-retryable error, watching [${_docIds}]`, filteredError.toString());
+          emitter.emit("error", filteredError);
+        }
+      }
+    });
+    currentRequest.on("end", () => {
+      if (buffer.trim()) {
+        try {
+          const change = JSON.parse(buffer);
+          logger.debug("Final change detected:", change);
+          emitter.emit("change", change);
+        } catch (err) {
+          logger.error("Error parsing final change:", err);
+        }
+      }
+      logger.info("Stream completed. Last seen seq: ", lastSeq);
+      emitter.emit("end", { lastSeq });
+      if (!stopping) {
+        handleReconnect();
+      }
+    });
+  };
+  const handleReconnect = async () => {
+    if (stopping || retryCount >= maxRetries) {
+      if (retryCount >= maxRetries) {
+        logger.error(`Max retries (${maxRetries}) reached, giving up`);
+        emitter.emit("error", new Error("Max retries reached"));
+      }
+      return;
+    }
+    const delay = Math.min(initialDelay * Math.pow(2, retryCount), maxDelay);
+    retryCount++;
+    logger.info(`Attempting to reconnect in ${delay}ms (attempt ${retryCount} of ${maxRetries})`);
+    await (0, import_patch.sleep)(delay);
+    try {
+      connect();
+    } catch (err) {
+      logger.error("Error during reconnection:", err);
+      handleReconnect();
+    }
+  };
+  connect();
+  emitter.on("change", onChange);
+  return {
+    on: (event, listener) => emitter.on(event, listener),
+    removeListener: (event, listener) => emitter.removeListener(event, listener),
+    stop: () => {
+      stopping = true;
+      if (currentRequest) currentRequest.abort();
+      emitter.emit("end", { lastSeq });
+      emitter.removeAllListeners();
+    }
+  };
+});

package/cjs/impl/trackedEmitter.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 trackedEmitter_exports = {};
+__export(trackedEmitter_exports, {
+  TrackedEmitter: () => TrackedEmitter,
+  setupEmitter: () => setupEmitter
+});
+module.exports = __toCommonJS(trackedEmitter_exports);
+var import_events = require("events");
+class TrackedEmitter extends import_events.EventEmitter {
+  // create a constructor with some options
+  constructor(options) {
+    super(options);
+    if (options.delay) this.delay = options.delay;
+  }
+  emit(event, ...args) {
+    const listeners = this.listeners(event);
+    let completed = 0;
+    return new Promise((resolve) => {
+      if (!listeners || listeners.length === 0) {
+        return resolve();
+      }
+      listeners.forEach((listener) => {
+        listener(...args);
+        completed++;
+        if (completed === listeners.length) {
+          if (!this.delay) resolve();
+          setTimeout(resolve, this.delay);
+        }
+      });
+    });
+  }
+}
+const setupEmitter = (config) => {
+  if (!config._emitter) return { emit: async () => {
+  } };
+  return config._emitter;
+};

package/cjs/impl/transactionErrors.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 transactionErrors_exports = {};
+__export(transactionErrors_exports, {
+  TransactionBulkOperationError: () => TransactionBulkOperationError,
+  TransactionRollbackError: () => TransactionRollbackError,
+  TransactionSetupError: () => TransactionSetupError,
+  TransactionVersionConflictError: () => TransactionVersionConflictError
+});
+module.exports = __toCommonJS(transactionErrors_exports);
+class TransactionSetupError extends Error {
+  /**
+   * @param {string} message
+   * @param {Record<string, any>} details
+   */
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "TransactionSetupError";
+    this.details = details;
+  }
+}
+class TransactionVersionConflictError extends Error {
+  /**
+   * @param {string[]} conflictingIds
+   */
+  constructor(conflictingIds) {
+    super(`Revision mismatch for documents: ${conflictingIds.join(", ")}`);
+    this.name = "TransactionVersionConflictError";
+    this.conflictingIds = conflictingIds;
+  }
+}
+class TransactionBulkOperationError extends Error {
+  /**
+   * @param {Array<{ok?: boolean|null, id?: string|null, rev?: string|null, error?: string|null, reason?: string|null}>} failedDocs
+   */
+  constructor(failedDocs) {
+    super(`Failed to save documents: ${failedDocs.map((d) => d.id).join(", ")}`);
+    this.name = "TransactionBulkOperationError";
+    this.failedDocs = failedDocs;
+  }
+}
+class TransactionRollbackError extends Error {
+  /**
+   * @param {string} message
+   * @param {Error} originalError
+   * @param {Array<{ok?: boolean|null, id?: string|null, rev?: string|null, error?: string|null, reason?: string|null}>} rollbackResults
+   */
+  constructor(message, originalError, rollbackResults) {
+    super(message);
+    this.name = "TransactionRollbackError";
+    this.originalError = originalError;
+    this.rollbackResults = rollbackResults;
+  }
+}

package/cjs/index.cjs

@@ -0,0 +1,115 @@
+"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 index_exports = {};
+__export(index_exports, {
+  bindConfig: () => bindConfig,
+  bulkGet: () => import_bulk.bulkGet,
+  bulkGetDictionary: () => import_bulk.bulkGetDictionary,
+  bulkRemove: () => import_bulk.bulkRemove,
+  bulkSave: () => import_bulk.bulkSave,
+  bulkSaveTransaction: () => import_bulk.bulkSaveTransaction,
+  createLock: () => import_lock.createLock,
+  createQuery: () => import_queryBuilder.createQuery,
+  get: () => import_crud.get,
+  getAtRev: () => import_crud.getAtRev,
+  patch: () => import_patch.patch,
+  patchDangerously: () => import_patch.patchDangerously,
+  put: () => import_crud.put,
+  query: () => import_query.query,
+  queryStream: () => import_stream.queryStream,
+  removeLock: () => import_lock.removeLock,
+  schema: () => schema,
+  withRetry: () => import_retry.withRetry
+});
+module.exports = __toCommonJS(index_exports);
+var import_bulk = require("./impl/bulk.cjs");
+var import_crud = require("./impl/crud.cjs");
+var import_changes = require("./impl/changes.cjs");
+var import_patch = require("./impl/patch.cjs");
+var import_lock = require("./impl/sugar/lock.cjs");
+var import_watch = require("./impl/sugar/watch.cjs");
+var import_query = require("./impl/query.cjs");
+var import_stream = require("./impl/stream.cjs");
+var import_queryBuilder = require("./impl/queryBuilder.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_changes2 = require("./schema/changes.cjs");
+var import_stream2 = require("./schema/stream.cjs");
+var import_patch2 = require("./schema/patch.cjs");
+var import_lock2 = require("./schema/sugar/lock.cjs");
+var import_watch2 = require("./schema/sugar/watch.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,
+  BulkRemove: import_bulk2.BulkRemove,
+  BulkGetDictionary: import_bulk2.BulkGetDictionary,
+  BulkSaveTransaction: import_bulk2.BulkSaveTransaction,
+  CouchGet: import_crud2.CouchGet,
+  CouchPut: import_crud2.CouchPut,
+  CouchDoc: import_crud2.CouchDoc,
+  CouchDocResponse: import_crud2.CouchDocResponse,
+  Patch: import_patch2.Patch,
+  PatchDangerously: import_patch2.PatchDangerously,
+  CouchGetAtRev: import_crud2.CouchGetAtRev,
+  Bind: import_bind.Bind,
+  Lock: import_lock2.Lock,
+  WatchDocs: import_watch2.WatchDocs,
+  LockOptions: import_lock2.LockOptions,
+  CreateLock: import_lock2.CreateLock,
+  RemoveLock: import_lock2.RemoveLock,
+  Changes: import_changes2.Changes,
+  ChangesOptions: import_changes2.ChangesOptions,
+  ChangesResponse: import_changes2.ChangesResponse
+};
+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),
+    getAtRev: config.bindWithRetry ? (0, import_retry.withRetry)(import_crud.getAtRev.bind(null, config), retryOptions) : import_crud.getAtRev.bind(null, config),
+    put: config.bindWithRetry ? (0, import_retry.withRetry)(import_crud.put.bind(null, config), retryOptions) : import_crud.put.bind(null, config),
+    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),
+    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),
+    // Sugar Methods
+    patch: config.bindWithRetry ? (0, import_retry.withRetry)(import_patch.patch.bind(null, config), retryOptions) : import_patch.patch.bind(null, config),
+    patchDangerously: import_patch.patchDangerously.bind(null, config),
+    // patchDangerously not included in retry
+    bulkRemove: config.bindWithRetry ? (0, import_retry.withRetry)(import_bulk.bulkRemove.bind(null, config), retryOptions) : import_bulk.bulkRemove.bind(null, config),
+    bulkGetDictionary: config.bindWithRetry ? (0, import_retry.withRetry)(import_bulk.bulkGetDictionary.bind(null, config), retryOptions) : import_bulk.bulkGetDictionary.bind(null, config),
+    bulkSaveTransaction: import_bulk.bulkSaveTransaction.bind(null, config),
+    createLock: import_lock.createLock.bind(null, config),
+    removeLock: import_lock.removeLock.bind(null, config),
+    watchDocs: import_watch.watchDocs.bind(null, config),
+    changes: import_changes.changes.bind(null, config)
+  };
+});

package/cjs/integration/changes.cjs

@@ -0,0 +1,76 @@
+"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 __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 import_trackedEmitter = require("../impl/trackedEmitter.cjs");
+var import_tap = __toESM(require("tap"), 1);
+var import_child_process = require("child_process");
+var import__ = require("../index.cjs");
+var import_needle = __toESM(require("needle"), 1);
+let DB_URL = `https://admin:iEZCEQhVR9PVCmYuZ5Bv@redman-couchdb.staging.brivity.io/testdb`;
+const config = {
+  couch: DB_URL,
+  bindWithRetry: true,
+  logger: (level, ...args) => {
+    console.log(`[${level.toUpperCase()}]`, ...args);
+  }
+};
+import_tap.default.test("changes tests", async (t) => {
+  await (0, import_needle.default)("put", DB_URL);
+  t.teardown(async () => {
+    await (0, import_needle.default)("delete", DB_URL);
+  });
+  const db = (0, import__.bindConfig)(config);
+  t.test("basic changes feed", (t2) => new Promise(async (resolve) => {
+    const onChange = (change) => {
+      t2.equal(change.id, "test-changes-doc", "change notification received");
+      changesEmitter.stop();
+      t2.end();
+      resolve();
+    };
+    const changesEmitter = await db.changes(onChange, { since: "now", feed: "continuous" });
+    t2.ok(changesEmitter.on, "changes emitter has on method");
+    t2.ok(changesEmitter.removeListener, "changes emitter has removeListener method");
+    t2.ok(changesEmitter.stop, "changes emitter has stop method");
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    await db.put({ _id: "test-changes-doc", data: "test" });
+  }));
+  t.test("document id", (t2) => new Promise(async (resolve) => {
+    const opts = {
+      since: "now",
+      include_docs: true,
+      feed: "continuous"
+    };
+    const onChange = (change) => {
+      console.log("got a change", change);
+      if (change.id === "test-a") {
+        setTimeout(() => {
+          resolve();
+        }, 1e3);
+      }
+    };
+    const changesEmitter = await db.changes(onChange, opts);
+    await new Promise((resolve2) => setTimeout(resolve2, 4e3));
+    await db.put({ _id: "test-changes-doc-2", data: "test" });
+    await db.put({ _id: "test-a", data: "test" });
+  }));
+});

package/cjs/integration/disconnect-watch.cjs

@@ -0,0 +1,52 @@
+"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 __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 import_watch = require("../impl/sugar/watch.cjs");
+var import__ = require("../index.cjs");
+var import_needle = __toESM(require("needle"), 1);
+let DB_URL = `https://admin:iEZCEQhVR9PVCmYuZ5Bv@redman-couchdb.staging.brivity.io/testdb`;
+const config = {
+  couch: DB_URL,
+  bindWithRetry: true,
+  logger: (level, ...args) => {
+    console.log(`[${level.toUpperCase()}]`, ...args);
+  }
+};
+const run = async () => {
+  await (0, import_needle.default)("put", DB_URL);
+  const db = (0, import__.bindConfig)(config);
+  const onChange = (change) => {
+    console.log(change);
+  };
+  const feed = (0, import_watch.watchDocs)(config, "doc-a-1", onChange, { include_docs: true });
+  feed.on("end", ({ lastSeq }) => {
+    console.log("ending");
+    console.log("lastSeq", lastSeq);
+  });
+  setTimeout(() => {
+    console.log("stopping...");
+    feed.stop();
+    console.log("stopped");
+  }, 19e4);
+};
+run();

package/cjs/integration/watch.cjs

@@ -0,0 +1,59 @@
+"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 __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 import_watch = require("../impl/sugar/watch.cjs");
+var import_tap = __toESM(require("tap"), 1);
+var import__ = require("../index.cjs");
+var import_needle = __toESM(require("needle"), 1);
+let DB_URL = `https://admin:iEZCEQhVR9PVCmYuZ5Bv@redman-couchdb.staging.brivity.io/testdb`;
+const config = {
+  couch: DB_URL,
+  bindWithRetry: true,
+  logger: (level, ...args) => {
+    console.log(`[${level.toUpperCase()}]`, ...args);
+  }
+};
+import_tap.default.test("changes tests", async (t) => {
+  await (0, import_needle.default)("put", DB_URL);
+  t.teardown(async () => {
+    await (0, import_needle.default)("delete", DB_URL);
+  });
+  const db = (0, import__.bindConfig)(config);
+  t.test("watch a doc", (t2) => new Promise(async (resolve) => {
+    let feed = null;
+    const onChange = (change) => {
+      t2.equal(change.id, "doc-a-1");
+      t2.equal(change.doc._id, "doc-a-1");
+      t2.equal(change.doc.data, "test");
+      feed.stop();
+      resolve();
+    };
+    feed = db.watchDocs("doc-a-1", onChange, { include_docs: true });
+    feed.on("end", ({ lastSeq }) => {
+      console.log("ending");
+      console.log("lastSeq", lastSeq);
+    });
+    await db.put({ _id: "doc-a-fake-out", data: "test" });
+    await db.put({ _id: "doc-a-1", data: "test" });
+  }));
+});

package/cjs/schema/bind.cjs

@@ -0,0 +1,51 @@
+"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 bind_exports = {};
+__export(bind_exports, {
+  Bind: () => Bind
+});
+module.exports = __toCommonJS(bind_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+var import_bulk = require("./bulk.cjs");
+var import_crud = require("./crud.cjs");
+var import_patch = require("./patch.cjs");
+var import_query = require("./query.cjs");
+var import_stream = require("./stream.cjs");
+var import_lock = require("./sugar/lock.cjs");
+var import_changes = require("./changes.cjs");
+var import_watch = require("./sugar/watch.cjs");
+const BindReturns = import_zod.z.object({
+  bulkGet: import_bulk.BulkGetBound,
+  bulkSave: import_bulk.BulkSaveBound,
+  bulkRemove: import_bulk.BulkRemoveBound,
+  bulkGetDictionary: import_bulk.BulkGetDictionaryBound,
+  bulkSaveTransaction: import_bulk.BulkSaveTransactionBound,
+  get: import_crud.CouchGetBound,
+  getAtRev: import_crud.CouchGetAtRevBound,
+  put: import_crud.CouchPutBound,
+  patch: import_patch.PatchBound,
+  query: import_query.SimpleViewQueryBound,
+  queryStream: import_stream.SimpleViewQueryStreamBound,
+  createLock: import_lock.CreateLockBound,
+  removeLock: import_lock.RemoveLockBound,
+  changes: import_changes.ChangesBound,
+  watchDocs: import_watch.WatchDocsBound
+});
+const Bind = import_zod.z.function().args(import_config.CouchConfig).returns(BindReturns);