hide-a-bed 4.0.3 → 4.1.2

package/cjs/impl/crud.cjs

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var crud_exports = {};
 __export(crud_exports, {
   get: () => get,
+  getAtRev: () => getAtRev,
   put: () => put
 });
 module.exports = __toCommonJS(crud_exports);
@@ -42,28 +43,26 @@ const opts = {
     "Content-Type": "application/json"
   }
 };
-const get = import_crud.CouchGet.implement(async (config, id) => {
+const _getWithOptions = import_crud.CouchGetWithOptions.implement(async (config, id, getOpts) => {
   const logger = (0, import_logger.createLogger)(config);
-  const url = `${config.couch}/${id}`;
-  logger.info(`Getting document with id: ${id}`);
+  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);
     }
-    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");
+        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}`);
-        return void 0;
+        logger.debug(`Document not found (returning undefined): ${id}, rev ${rev || "latest"}`);
+        return null;
       }
     }
     if (import_errors.RetryableError.isRetryableStatusCode(resp.statusCode)) {
@@ -74,13 +73,21 @@ const get = import_crud.CouchGet.implement(async (config, id) => {
       logger.error(`Unexpected status code: ${resp.statusCode}`);
       throw new Error(result.reason || "failed");
     }
-    logger.info(`Successfully retrieved document: ${id}`);
+    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}`;

package/cjs/impl/errors.cjs

@@ -18,9 +18,21 @@ var __copyProps = (to, from, except, desc) => {
 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

package/cjs/impl/patch.cjs

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var patch_exports = {};
 __export(patch_exports, {
   patch: () => patch,
+  patchDangerously: () => patchDangerously,
   sleep: () => sleep
 });
 module.exports = __toCommonJS(patch_exports);
@@ -27,6 +28,24 @@ var import_patch = require("../schema/patch.cjs");
 var import_logger = require("./logger.cjs");
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const patch = import_patch.Patch.implement(async (config, id, properties) => {
+  const logger = (0, import_logger.createLogger)(config);
+  logger.info(`Starting patch operation for document ${id}`);
+  logger.debug("Patch properties:", properties);
+  const doc = await (0, import_crud.get)(config, id);
+  if (doc._rev !== properties._rev) {
+    const result2 = {};
+    result2.ok = false;
+    result2.error = "conflict";
+    result2.statusCode = 409;
+    return result2;
+  }
+  const updatedDoc = { ...doc, ...properties };
+  logger.debug("Merged document:", updatedDoc);
+  const result = await (0, import_crud.put)(config, updatedDoc);
+  logger.info(`Successfully patched document ${id}, rev: ${result.rev}`);
+  return result;
+});
+const patchDangerously = import_patch.PatchDangerously.implement(async (config, id, properties) => {
   const logger = (0, import_logger.createLogger)(config);
   const maxRetries = config.maxRetries || 5;
   let delay = config.initialDelay || 1e3;

package/cjs/impl/queryBuilder.cjs

@@ -0,0 +1,99 @@
+"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 queryBuilder_exports = {};
+__export(queryBuilder_exports, {
+  QueryBuilder: () => QueryBuilder,
+  createQuery: () => createQuery
+});
+module.exports = __toCommonJS(queryBuilder_exports);
+class QueryBuilder {
+  /** @type {QueryOptions} */
+  #options = {};
+  /**
+   * @param {any} key
+   * @returns {QueryBuilder}
+   */
+  key(key) {
+    this.#options.key = key;
+    return this;
+  }
+  /**
+   * @param {any} startkey
+   * @returns {QueryBuilder}
+   */
+  startKey(startkey) {
+    this.#options.startkey = startkey;
+    return this;
+  }
+  /**
+   * @param {any} endkey
+   * @returns {QueryBuilder}
+   */
+  endKey(endkey) {
+    this.#options.endkey = endkey;
+    return this;
+  }
+  /**
+   * @param {boolean} reduce
+   * @returns {QueryBuilder}
+   */
+  reduce(reduce = true) {
+    this.#options.reduce = reduce;
+    return this;
+  }
+  /**
+   * @param {boolean} group
+   * @returns {QueryBuilder}
+   */
+  group(group = true) {
+    this.#options.group = group;
+    return this;
+  }
+  /**
+   * @param {number} level
+   * @returns {QueryBuilder}
+   */
+  groupLevel(level) {
+    this.#options.group_level = level;
+    return this;
+  }
+  /**
+   * @param {string} stale
+   * @returns {QueryBuilder}
+   */
+  stale(stale) {
+    this.#options.stale = stale;
+    return this;
+  }
+  /**
+   * @param {number} limit
+   * @returns {QueryBuilder}
+   */
+  limit(limit) {
+    this.#options.limit = limit;
+    return this;
+  }
+  /**
+   * @returns {QueryOptions}
+   */
+  build() {
+    return { ...this.#options };
+  }
+}
+const createQuery = () => new QueryBuilder();

package/cjs/impl/stream.cjs

@@ -32,13 +32,19 @@ __export(stream_exports, {
 });
 module.exports = __toCommonJS(stream_exports);
 var import_needle = __toESM(require("needle"), 1);
+var import_config = require("../schema/config.cjs");
 var import_query = require("./query.cjs");
 var import_errors = require("./errors.cjs");
 var import_logger = require("./logger.cjs");
 var import_JSONStream = __toESM(require("JSONStream"), 1);
-const queryStream = (config, view, options, onRow) => new Promise((resolve, reject) => {
+const queryStream = (rawConfig, view, options, onRow) => new Promise((resolve, reject) => {
+  const config = import_config.CouchConfig.parse(rawConfig);
+  const logger = (0, import_logger.createLogger)(config);
+  logger.info(`Starting view query stream: ${view}`);
+  logger.debug("Query options:", options);
   if (!options) options = {};
   const qs = (0, import_query.queryString)(options, ["key", "startkey", "endkey", "reduce", "group", "group_level", "stale", "limit"]);
+  logger.debug("Generated query string:", qs);
   const url = `${config.couch}/${view}?${qs.toString()}`;
   const opts = {
     json: true,
@@ -62,6 +68,7 @@ const queryStream = (config, view, options, onRow) => new Promise((resolve, reje
     "error",
     /** @param {Error} err */
     (err) => {
+      logger.error("Stream parsing error:", err);
       reject(new Error(`Stream parsing error: ${err.message}`));
     }
   );
@@ -77,15 +84,19 @@ const queryStream = (config, view, options, onRow) => new Promise((resolve, reje
     }
   );
   streamer.on("end", () => {
+    logger.info(`Stream completed, processed ${rowCount} rows`);
     resolve(void 0);
   });
   const req = import_needle.default.get(url, opts);
   req.on("response", (response) => {
+    logger.debug(`Received response with status code: ${response.statusCode}`);
     if (import_errors.RetryableError.isRetryableStatusCode(response.statusCode)) {
+      logger.warn(`Retryable status code received: ${response.statusCode}`);
       reject(new import_errors.RetryableError("retryable error during stream query", response.statusCode));
     }
   });
   req.on("error", (err) => {
+    logger.error("Network error during stream query:", err);
     try {
       import_errors.RetryableError.handleNetworkError(err);
     } catch (retryErr) {

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

@@ -20,10 +20,15 @@ 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,
+  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,
@@ -36,6 +41,7 @@ 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_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");
@@ -53,11 +59,16 @@ const schema = {
   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
+  Patch: import_patch2.Patch,
+  PatchDangerously: import_patch2.PatchDangerously,
+  CouchGetAtRev: import_crud2.CouchGetAtRev,
+  Bind: import_bind.Bind
 };
 const bindConfig = import_bind.Bind.implement((config) => {
   const retryOptions = {
@@ -67,13 +78,18 @@ const bindConfig = import_bind.Bind.implement((config) => {
   };
   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),
-    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)
+    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)
   };
 });

package/cjs/schema/bind.cjs

@@ -31,7 +31,11 @@ var import_stream = require("./stream.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,

package/cjs/schema/bulk.cjs

@@ -20,41 +20,45 @@ var bulk_exports = {};
 __export(bulk_exports, {
   BulkGet: () => BulkGet,
   BulkGetBound: () => BulkGetBound,
+  BulkGetDictionary: () => BulkGetDictionary,
+  BulkGetDictionaryBound: () => BulkGetDictionaryBound,
+  BulkGetDictionaryResponse: () => BulkGetDictionaryResponse,
   BulkRemove: () => BulkRemove,
   BulkRemoveBound: () => BulkRemoveBound,
   BulkSave: () => BulkSave,
   BulkSaveBound: () => BulkSaveBound,
-  BulkSaveResponseSchema: () => BulkSaveResponseSchema
+  BulkSaveResponseSchema: () => BulkSaveResponseSchema,
+  BulkSaveRow: () => BulkSaveRow,
+  BulkSaveTransaction: () => BulkSaveTransaction,
+  BulkSaveTransactionBound: () => BulkSaveTransactionBound
 });
 module.exports = __toCommonJS(bulk_exports);
 var import_zod = require("zod");
 var import_config = require("./config.cjs");
+var import_query = require("./query.cjs");
 var import_crud = require("./crud.cjs");
-const BulkSaveResponseSchema = import_zod.z.array(import_zod.z.object({
+const BulkSaveRow = import_zod.z.object({
   ok: import_zod.z.boolean().nullish(),
   id: import_zod.z.string().nullish(),
   rev: import_zod.z.string().nullish(),
   error: import_zod.z.string().nullish().describe("if an error occured, one word reason, eg conflict"),
   reason: import_zod.z.string().nullish().describe("a full error message")
-}));
+});
+const BulkSaveResponseSchema = import_zod.z.array(BulkSaveRow);
 const BulkSave = import_zod.z.function().args(
   import_config.CouchConfig,
-  import_zod.z.array(import_zod.z.object({
-    _id: import_zod.z.string()
-  }).passthrough())
+  import_zod.z.array(import_crud.CouchDoc)
 ).returns(import_zod.z.promise(BulkSaveResponseSchema));
 const BulkSaveBound = import_zod.z.function().args(
-  import_zod.z.array(import_zod.z.object({
-    _id: import_zod.z.string()
-  }).passthrough())
+  import_zod.z.array(import_crud.CouchDoc)
 ).returns(import_zod.z.promise(BulkSaveResponseSchema));
 const BulkGet = import_zod.z.function().args(
   import_config.CouchConfig,
   import_zod.z.array(import_zod.z.string().describe("the ids to get"))
-).returns(import_zod.z.promise(import_zod.z.array(import_crud.CouchDoc)));
+).returns(import_zod.z.promise(import_query.SimpleViewQueryResponse));
 const BulkGetBound = import_zod.z.function().args(
   import_zod.z.array(import_zod.z.string().describe("the ids to get"))
-).returns(import_zod.z.promise(import_zod.z.array(import_crud.CouchDoc)));
+).returns(import_zod.z.promise(import_query.SimpleViewQueryResponse));
 const BulkRemove = import_zod.z.function().args(
   import_config.CouchConfig,
   import_zod.z.array(import_zod.z.string().describe("the ids to delete"))
@@ -62,3 +66,23 @@ const BulkRemove = import_zod.z.function().args(
 const BulkRemoveBound = import_zod.z.function().args(
   import_zod.z.array(import_zod.z.string().describe("the ids to delete"))
 ).returns(import_zod.z.promise(BulkSaveResponseSchema));
+const BulkGetDictionaryResponse = import_zod.z.object({
+  found: import_zod.z.record(import_zod.z.string(), import_crud.CouchDoc),
+  notFound: import_zod.z.record(import_zod.z.string(), import_query.ViewRow)
+});
+const BulkGetDictionary = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.array(import_zod.z.string().describe("the ids to get"))
+).returns(import_zod.z.promise(BulkGetDictionaryResponse));
+const BulkGetDictionaryBound = import_zod.z.function().args(
+  import_zod.z.array(import_zod.z.string().describe("the ids to get"))
+).returns(import_zod.z.promise(BulkGetDictionaryResponse));
+const BulkSaveTransaction = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("transaction id"),
+  import_zod.z.array(import_crud.CouchDoc)
+).returns(import_zod.z.promise(BulkSaveResponseSchema));
+const BulkSaveTransactionBound = import_zod.z.function().args(
+  import_zod.z.string().describe("transaction id"),
+  import_zod.z.array(import_crud.CouchDoc)
+).returns(import_zod.z.promise(BulkSaveResponseSchema));

package/cjs/schema/config.cjs

@@ -42,6 +42,7 @@ const CouchConfig = import_zod.z.object({
   backoffFactor: import_zod.z.number().optional().default(2).describe("multiplier for exponential backoff"),
   useConsoleLogger: import_zod.z.boolean().optional().default(false).describe("turn on console as a fallback logger"),
   logger: LoggerSchema.optional().describe("logging interface supporting winston-like or simple function interface"),
+  // _emitter: z.any().optional().describe('emitter for events'),
   _normalizedLogger: import_zod.z.any().optional()
   // Internal property for caching normalized logger
 }).passthrough().describe("The std config object");

package/cjs/schema/crud.cjs

@@ -21,7 +21,11 @@ __export(crud_exports, {
   CouchDoc: () => CouchDoc,
   CouchDocResponse: () => CouchDocResponse,
   CouchGet: () => CouchGet,
+  CouchGetAtRev: () => CouchGetAtRev,
+  CouchGetAtRevBound: () => CouchGetAtRevBound,
   CouchGetBound: () => CouchGetBound,
+  CouchGetOptions: () => CouchGetOptions,
+  CouchGetWithOptions: () => CouchGetWithOptions,
   CouchPut: () => CouchPut,
   CouchPutBound: () => CouchPutBound
 });
@@ -30,7 +34,8 @@ var import_zod = require("zod");
 var import_config = require("./config.cjs");
 const CouchDoc = import_zod.z.object({
   _id: import_zod.z.string().describe("the couch doc id"),
-  _rev: import_zod.z.string().optional().describe("the doc revision")
+  _rev: import_zod.z.string().optional().nullish().describe("the doc revision"),
+  _deleted: import_zod.z.boolean().optional().describe("is the doc deleted")
 }).passthrough();
 const CouchDocResponse = import_zod.z.object({
   ok: import_zod.z.boolean().optional().describe("did the request succeed"),
@@ -53,3 +58,20 @@ const CouchGet = import_zod.z.function().args(
 const CouchGetBound = import_zod.z.function().args(
   import_zod.z.string().describe("the couch doc id")
 ).returns(import_zod.z.promise(CouchDoc.nullable()));
+const CouchGetAtRev = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the couch doc id"),
+  import_zod.z.string().describe("the rev")
+).returns(import_zod.z.promise(CouchDoc.nullable()));
+const CouchGetAtRevBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the couch doc id"),
+  import_zod.z.string().describe("the rev")
+).returns(import_zod.z.promise(CouchDoc.nullable()));
+const CouchGetOptions = import_zod.z.object({
+  rev: import_zod.z.string().optional().describe("the couch doc revision")
+});
+const CouchGetWithOptions = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the couch doc id"),
+  CouchGetOptions
+).returns(import_zod.z.promise(CouchDoc.nullable()));

package/cjs/schema/patch.cjs

@@ -20,19 +20,34 @@ var patch_exports = {};
 __export(patch_exports, {
   Patch: () => Patch,
   PatchBound: () => PatchBound,
-  PatchProperties: () => PatchProperties
+  PatchDangerously: () => PatchDangerously,
+  PatchDangerouslyBound: () => PatchDangerouslyBound,
+  PatchProperties: () => PatchProperties,
+  StrictPatchProperties: () => StrictPatchProperties
 });
 module.exports = __toCommonJS(patch_exports);
 var import_zod = require("zod");
 var import_config = require("./config.cjs");
 var import_crud = require("./crud.cjs");
 const PatchProperties = import_zod.z.record(import_zod.z.string(), import_zod.z.any());
+const StrictPatchProperties = import_zod.z.object({
+  _rev: import_zod.z.string()
+}).and(PatchProperties);
 const Patch = import_zod.z.function().args(
   import_config.CouchConfig,
   import_zod.z.string().describe("the couch doc id"),
-  PatchProperties
+  StrictPatchProperties
 ).returns(import_zod.z.promise(import_crud.CouchDocResponse));
 const PatchBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the couch doc id"),
+  StrictPatchProperties
+).returns(import_zod.z.promise(import_crud.CouchDocResponse));
+const PatchDangerously = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the couch doc id"),
+  PatchProperties
+).returns(import_zod.z.promise(import_crud.CouchDocResponse));
+const PatchDangerouslyBound = import_zod.z.function().args(
   import_zod.z.string().describe("the couch doc id"),
   PatchProperties
 ).returns(import_zod.z.promise(import_crud.CouchDocResponse));

package/cjs/schema/query.cjs

@@ -31,7 +31,8 @@ const ViewRow = import_zod.z.object({
   id: import_zod.z.string().optional(),
   key: import_zod.z.any().nullable(),
   value: import_zod.z.any().nullable(),
-  doc: import_zod.z.object({}).passthrough().optional()
+  doc: import_zod.z.object({}).passthrough().optional().nullish(),
+  error: import_zod.z.string().optional().describe("usually not_found, if something is wrong with this doc")
 });
 const SimpleViewQueryResponse = import_zod.z.object({
   error: import_zod.z.string().optional().describe("if something is wrong"),

package/config.json

@@ -0,0 +1,5 @@
+{
+  "couchdb": {
+    "uuid": "92fcdcf8-7d8a-4a1a-896c-fba3fa7eb623"
+  }
+}