hide-a-bed 1.2.0 → 3.0.0

package/README.md

@@ -1,73 +1,168 @@
-hide-a-bed
------------
-
-A simple way to abstract couchdb, and make your interface to the database testable. 
+API 
+-------------
 
-Install
------
+### Document Operations
 
-There are two packages, one for runtime that contains the real implementations and schema, and the other contains the stubs for tests.
+#### get(config, id)
+Get a single document by ID.
+- `config`: Object with `couch` URL string
+- `id`: Document ID string
+- Returns: Promise resolving to document object or null if not found
 
+```javascript
+const config = { couch: 'http://localhost:5984/mydb' }
+const doc = await get(config, 'doc-123')
+if (doc) {
+  console.log(doc._id, doc._rev)
+}
 ```
-npm i hide-a-bed --save
-npm i hide-a-bed-stub --save-dev
 
-```
+#### put(config, doc) 
+Save a document.
+- `config`: Object with `couch` URL string
+- `doc`: Document object with `_id` property
+- Returns: Promise resolving to response with `ok`, `id`, `rev` properties
 
-Code that uses some example db apis
-```
-export function doStuff (config, services, id) {
-  const doc = await services.db.get(config, id)
-  const apiResult = services.callSomeApi(config, doc.userName)
-  const query = {
-    startkey: apiResult.startTime,
-    endkey: apiResult.endTime
-  }
-  const queryResults = await db.query(config, '_design/userThings/_view/byTime', query)
-  return queryResults.rows
+```javascript
+const config = { couch: 'http://localhost:5984/mydb' }
+const doc = { 
+  _id: 'doc-123',
+  type: 'user',
+  name: 'Alice'
 }
-
+const result = await put(config, doc)
+// result: { ok: true, id: 'doc-123', rev: '1-abc123' }
 ```
 
-Using doStuff, in a real env, connecting to a real couch
+#### patch(config, id, properties)
+Update specific properties of a document with retry mechanism.
+- `config`: Object with:
+  - `couch`: URL string
+  - `retries`: Optional number of retry attempts (default: 5)
+  - `delay`: Optional milliseconds between retries (default: 1000)
+- `id`: Document ID string
+- `properties`: Object with properties to update
+- Returns: Promise resolving to response with `ok`, `id`, `rev` properties
+
+```javascript
+const config = { 
+  couch: 'http://localhost:5984/mydb',
+  retries: 3,
+  delay: 500
+}
+const properties = { 
+  name: 'Alice Smith',
+  updated: true
+}
+const result = await patch(config, 'doc-123', properties)
+// result: { ok: true, id: 'doc-123', rev: '2-xyz789' }
 ```
-import db from 'hide-a-bed'
-import { doStuff } from './doStuff'
-import { callSomeApi } from './api'
-// the config object needs a couch url
-const config = { couch: 'http://localhost:5984/mydb' }
-// build up a service api for all your external calls that can be mocked/stubbed
-const services = { db, callSomeApi }
-const afterStuff = await doStuff(config, services, 'happy-doc-id')
 
-```
+#### remove(config, id)
+Delete a document by ID.
+- `config`: Object with `couch` URL string
+- `id`: Document ID string to delete
+- Returns: Promise resolving to response with `ok` and `rev` properties
 
-Mocking out the calls in a test, never connects to the network
+```javascript
+const config = { couch: 'http://localhost:5984/mydb' }
+const result = await remove(config, 'doc-123')
+// result: { ok: true, id: 'doc-123', rev: '2-def456' }
 ```
-import { setup } from 'hide-a-bed-stub' // different package, since installed with --save-dev reduces space
-import { doStuff } from './doStuff'
-import { callSomeApiMock } from './test/mock/api'
-// the config object needs a couch url, prove to yourself that its mocked with a fakeurl
-const config = { couch: 'http://fakeurl:5984/mydb' }
 
-// we import or design docs that we will need for the db
-import userThingsDesignDoc from './ddocs/userThingsDDoc.js'
+### Bulk Operations
+
+#### bulkSave(config, docs)
+Save multiple documents in one request.
+- `config`: Object with `couch` URL string
+- `docs`: Array of document objects, each with `_id`
+- Returns: Promise resolving to array of results with `ok`, `id`, `rev` for each doc
 
-test('doStuff works in stub mode', async t => {
-    // we have to setup the db with the design docs that are required
-    const db = await setup([userThingsDesignDoc])
+```javascript
+const config = { couch: 'http://localhost:5984/mydb' }
+const docs = [
+  { _id: 'doc1', type: 'user', name: 'Alice' },
+  { _id: 'doc2', type: 'user', name: 'Bob' }
+]
+const results = await bulkSave(config, docs)
+// results: [
+//   { ok: true, id: 'doc1', rev: '1-abc123' },
+//   { ok: true, id: 'doc2', rev: '1-def456' }
+// ]
+```
 
-    // build up a service api with all your fake endpoints
-    const services = { db, callSomeApi: callSomeApiMock }
-    const afterStuff = await doStuff(config, services, 'happy-doc-id')
-})
+#### bulkGet(config, ids)
+Get multiple documents by ID.
+- `config`: Object with `couch` URL string
+- `ids`: Array of document ID strings
+- Returns: Promise resolving to array of documents
 
+```javascript
+const config = { couch: 'http://localhost:5984/mydb' }
+const ids = ['doc1', 'doc2']
+const docs = await bulkGet(config, ids)
+// docs: [
+//   { _id: 'doc1', _rev: '1-abc123', type: 'user', name: 'Alice' },
+//   { _id: 'doc2', _rev: '1-def456', type: 'user', name: 'Bob' }
+// ]
 ```
 
-Below are all the couch apis available
--------------
+#### bulkRemove(config, ids)
+Delete multiple documents in one request.
+- `config`: Object with `couch` URL string
+- `ids`: Array of document ID strings to delete
+- Returns: Promise resolving to array of results with `ok`, `id`, `rev` for each deletion
 
-__TODO__
+```javascript
+const config = { couch: 'http://localhost:5984/mydb' }
+const ids = ['doc1', 'doc2']
+const results = await bulkRemove(config, ids)
+// results: [
+//   { ok: true, id: 'doc1', rev: '2-ghi789' },
+//   { ok: true, id: 'doc2', rev: '2-jkl012' }
+// ]
+```
 
+### View Queries
+
+#### query(config, view, options)
+Query a view with options.
+- `config`: Object with `couch` URL string
+- `view`: View path string (e.g. '_design/doc/_view/name')
+- `options`: Optional object with query parameters:
+  - `startkey`: Start key for range
+  - `endkey`: End key for range
+  - `key`: Exact key match
+  - `descending`: Boolean to reverse sort
+  - `skip`: Number of results to skip
+  - `limit`: Max number of results
+  - `include_docs`: Boolean to include full docs
+  - `reduce`: Boolean to reduce results
+  - `group`: Boolean to group results
+  - `group_level`: Number for group level
+- Returns: Promise resolving to response with `rows` array
+
+```javascript
+const config = { couch: 'http://localhost:5984/mydb' }
+const view = '_design/users/_view/by_name'
+const options = {
+  startkey: 'A',
+  endkey: 'B',
+  include_docs: true,
+  limit: 10
+}
+const result = await query(config, view, options)
+// result: {
+//   rows: [
+//     { 
+//       id: 'doc1',
+//       key: 'Alice',
+//       value: 1,
+//       doc: { _id: 'doc1', name: 'Alice', type: 'user' }
+//     },
+//     // ... more rows
+//   ]
+// }
+```
 
 

package/build/build.mjs

@@ -0,0 +1,16 @@
+import esbuild from 'esbuild'
+import { globSync } from 'glob'
+import { RewriteImportsPlugin } from './build.rewrite-imports.mjs'
+
+esbuild
+  .build({
+    entryPoints: globSync('./**/*.mjs', {
+      ignore: ['./node_modules/**/*', './tests/**/*', './build/**/*']
+    }),
+    outdir: 'cjs',
+    format: 'cjs',
+    outExtension: { '.js': '.cjs' },
+    bundle: false,
+    plugins: [new RewriteImportsPlugin()]
+  })
+  .catch(() => process.exit(1))

package/build/build.rewrite-imports.mjs

@@ -0,0 +1,14 @@
+import fs from 'fs'
+
+export class RewriteImportsPlugin {
+  name = 'rewrite-imports'
+
+  setup (build) {
+    build.onLoad({ filter: /\.mjs$/ }, async (args) => {
+      const contents = fs
+        .readFileSync(args.path, 'utf8')
+        .replace(/(from\s+['"].*?)\.mjs(['"])/g, '$1.cjs$2')
+      return { contents, loader: 'js' }
+    })
+  }
+}

package/cjs/impl/bulk.cjs

@@ -0,0 +1,77 @@
+"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,
+  bulkRemove: () => bulkRemove,
+  bulkSave: () => bulkSave
+});
+module.exports = __toCommonJS(bulk_exports);
+var import_needle = __toESM(require("needle"), 1);
+var import_bulk = require("../schema/bulk.cjs");
+const opts = {
+  json: true,
+  headers: {
+    "Content-Type": "application/json"
+  }
+};
+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 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");
+  const results = resp?.body || [];
+  return results;
+});
+const bulkGet = import_bulk.BulkGet.implement(async (config, ids) => {
+  const keys = ids;
+  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");
+  const rows = resp?.body?.rows || [];
+  const docs = [];
+  rows.forEach((r) => {
+    if (r.error) return;
+    if (!r.key) return;
+    if (!r.doc) return;
+    const doc = r.doc;
+    docs.push(doc);
+  });
+  return docs;
+});
+const bulkRemove = import_bulk.BulkRemove.implement(async (config, ids) => {
+  const docs = await bulkGet(config, ids);
+  docs.forEach((d) => {
+    d._deleted = true;
+  });
+  return bulkSave(config, docs);
+});

package/cjs/impl/crud.cjs

@@ -0,0 +1,64 @@
+"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,
+  put: () => put
+});
+module.exports = __toCommonJS(crud_exports);
+var import_needle = __toESM(require("needle"), 1);
+var import_crud = require("../schema/crud.cjs");
+const opts = {
+  json: true,
+  headers: {
+    "Content-Type": "application/json"
+  }
+};
+const get = import_crud.CouchGet.implement(async (config, id) => {
+  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");
+  }
+  return result;
+});
+const put = import_crud.CouchPut.implement(async (config, doc) => {
+  const url = `${config.couch}/${doc._id}`;
+  const body = doc;
+  const resp = await (0, import_needle.default)("put", url, body, opts);
+  const result = resp?.body || {};
+  result.statusCode = resp.statusCode;
+  if (resp.statusCode === 409) {
+    result.ok = false;
+    result.error = "conflict";
+  }
+  return result;
+});

package/cjs/impl/patch.cjs

@@ -0,0 +1,52 @@
+"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 patch_exports = {};
+__export(patch_exports, {
+  patch: () => patch
+});
+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;
+  let attempts = 0;
+  while (attempts <= maxRetries) {
+    try {
+      const doc = await (0, import_crud.get)(config, id);
+      const updatedDoc = { ...doc, ...properties };
+      const result = await (0, import_crud.put)(config, updatedDoc);
+      if (result.ok) {
+        return result;
+      }
+      attempts++;
+      if (attempts > maxRetries) {
+        throw new Error(`Failed to patch after ${maxRetries} attempts`);
+      }
+      await sleep(delay);
+    } catch (err) {
+      attempts++;
+      if (attempts > maxRetries) {
+        throw new Error(`Failed to patch after ${maxRetries} attempts: ${err.message}`);
+      }
+      await sleep(delay);
+    }
+  }
+});

package/cjs/impl/query.cjs

@@ -0,0 +1,72 @@
+"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 query_exports = {};
+__export(query_exports, {
+  query: () => query,
+  queryString: () => queryString
+});
+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_lodash = __toESM(require("lodash"), 1);
+const { includes } = import_lodash.default;
+const query = import_query.SimpleViewQuery.implement(async (config, view, options) => {
+  const qs = queryString(options, ["key", "startkey", "endkey", "reduce", "group", "group_level", "stale", "limit"]);
+  const opts = {
+    json: true,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  };
+  const url = `${config.couch}/${view}?${qs.toString()}`;
+  const results = await (0, import_needle.default)("get", url, opts);
+  const body = results.body;
+  if (body.error) throw new Error(body.error);
+  return body;
+});
+function queryString(options, params) {
+  const parts = Object.keys(options).map((key) => {
+    let value = options[key];
+    if (includes(params, key)) {
+      if (typeof value === "string" && key !== "stale") value = `"${value}"`;
+      if (Array.isArray(value)) {
+        value = "[" + value.map((i) => {
+          if (i === null) return "null";
+          if (typeof i === "string") return `"${i}"`;
+          if (typeof i === "object" && Object.keys(i).length === 0) return "{}";
+          if (typeof i === "object") return JSON.stringify(i);
+          return i;
+        }).join(",") + "]";
+      }
+    }
+    return `${key}=${value}`;
+  });
+  return parts.join("&");
+}

package/cjs/impl/stream.cjs

@@ -0,0 +1,49 @@
+"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 stream_exports = {};
+__export(stream_exports, {
+  queryStream: () => queryStream
+});
+module.exports = __toCommonJS(stream_exports);
+var import_needle = __toESM(require("needle"), 1);
+var import_query = require("./query.cjs");
+var import_JSONStream = __toESM(require("JSONStream"), 1);
+const queryStream = (config, view, options) => 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 url = `${config.couch}/${view}?${qs.toString()}`;
+  const streamer = import_JSONStream.default.parse("rows.*");
+  streamer.on("data", onRow);
+  streamer.on("end", (err) => {
+    if (err) return reject(err);
+    resolve(null);
+  });
+  import_needle.default.get(url).pipe(streamer);
+});

package/cjs/index.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 index_exports = {};
+__export(index_exports, {
+  bulkGet: () => import_bulk.bulkGet,
+  bulkRemove: () => import_bulk.bulkRemove,
+  bulkSave: () => import_bulk.bulkSave,
+  get: () => import_crud.get,
+  patch: () => import_patch.patch,
+  put: () => import_crud.put,
+  query: () => import_query.query,
+  queryStream: () => import_stream.queryStream,
+  schema: () => schema
+});
+module.exports = __toCommonJS(index_exports);
+var import_bulk = require("./impl/bulk.cjs");
+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_bulk2 = require("./schema/bulk.cjs");
+var import_config = require("./schema/config.cjs");
+var import_query2 = require("./schema/query.cjs");
+var import_patch2 = require("./schema/patch.cjs");
+var import_crud2 = require("./schema/crud.cjs");
+const schema = {
+  CouchConfig: import_config.CouchConfig,
+  SimpleViewQuery: import_query2.SimpleViewQuery,
+  SimpleViewQueryResponse: import_query2.SimpleViewQueryResponse,
+  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,
+  PatchDoc: import_patch2.PatchDoc
+};

package/cjs/schema/bulk.cjs

@@ -0,0 +1,50 @@
+"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 bulk_exports = {};
+__export(bulk_exports, {
+  BulkGet: () => BulkGet,
+  BulkRemove: () => BulkRemove,
+  BulkSave: () => BulkSave,
+  BulkSaveResponseSchema: () => BulkSaveResponseSchema
+});
+module.exports = __toCommonJS(bulk_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+var import_crud = require("./crud.cjs");
+const BulkSaveResponseSchema = import_zod.z.array(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 BulkSave = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.array(import_zod.z.object({
+    _id: import_zod.z.string()
+  }).passthrough())
+).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)));
+const BulkRemove = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.array(import_zod.z.string().describe("the ids to delete"))
+).returns(import_zod.z.promise(BulkSaveResponseSchema));

package/cjs/schema/config.cjs

@@ -0,0 +1,27 @@
+"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 config_exports = {};
+__export(config_exports, {
+  CouchConfig: () => CouchConfig
+});
+module.exports = __toCommonJS(config_exports);
+var import_zod = require("zod");
+const CouchConfig = import_zod.z.object({
+  couch: import_zod.z.string().describe("the url of the couch db")
+}).passthrough().describe("The std config object");

package/cjs/schema/crud.cjs

@@ -0,0 +1,47 @@
+"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 crud_exports = {};
+__export(crud_exports, {
+  CouchDoc: () => CouchDoc,
+  CouchDocResponse: () => CouchDocResponse,
+  CouchGet: () => CouchGet,
+  CouchPut: () => CouchPut
+});
+module.exports = __toCommonJS(crud_exports);
+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")
+}).passthrough();
+const CouchDocResponse = import_zod.z.object({
+  ok: import_zod.z.boolean().optional().describe("did the request succeed"),
+  error: import_zod.z.string().optional().describe("the error message, if did not succed"),
+  statusCode: import_zod.z.number(),
+  id: import_zod.z.string().optional().describe("the couch doc id"),
+  rev: import_zod.z.string().optional().describe("the new rev of the doc")
+});
+const CouchPut = import_zod.z.function().args(
+  import_config.CouchConfig,
+  CouchDoc
+).returns(import_zod.z.promise(CouchDocResponse));
+const CouchGet = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the couch doc id")
+).returns(import_zod.z.promise(CouchDoc.nullable()));

package/cjs/schema/patch.cjs

@@ -0,0 +1,38 @@
+"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 patch_exports = {};
+__export(patch_exports, {
+  CouchPatch: () => CouchPatch,
+  PatchConfig: () => PatchConfig,
+  PatchProperties: () => PatchProperties
+});
+module.exports = __toCommonJS(patch_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+var import_crud = require("./crud.cjs");
+const PatchConfig = import_config.CouchConfig.extend({
+  retries: import_zod.z.number().min(0).max(100).optional(),
+  delay: import_zod.z.number().min(0).optional()
+});
+const PatchProperties = import_zod.z.record(import_zod.z.string(), import_zod.z.any());
+const CouchPatch = import_zod.z.function().args(
+  PatchConfig,
+  import_zod.z.string().describe("the couch doc id"),
+  PatchProperties
+).returns(import_zod.z.promise(import_crud.CouchDocResponse));

package/cjs/schema/query.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 query_exports = {};
+__export(query_exports, {
+  SimpleViewQuery: () => SimpleViewQuery,
+  SimpleViewQueryResponse: () => SimpleViewQueryResponse
+});
+module.exports = __toCommonJS(query_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+const SimpleViewQueryResponse = import_zod.z.object({
+  error: import_zod.z.string().optional().describe("if something is wrong"),
+  rows: import_zod.z.array(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()
+  }))
+}).passthrough();
+const SimpleViewQuery = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the view name"),
+  import_zod.z.object({
+    startkey: import_zod.z.any().optional(),
+    endkey: import_zod.z.any().optional(),
+    descending: import_zod.z.boolean().optional().describe("sort results descending"),
+    skip: import_zod.z.number().positive().optional().describe("skip this many rows"),
+    limit: import_zod.z.number().positive().optional().describe("limit the results to this many rows"),
+    key: import_zod.z.any().optional(),
+    include_docs: import_zod.z.boolean().optional().describe("join the id to the doc and return it"),
+    reduce: import_zod.z.boolean().optional().describe("reduce the results"),
+    group: import_zod.z.boolean().optional().describe("group the results"),
+    group_level: import_zod.z.number().positive().optional().describe("group the results at this level")
+  }).optional().describe("query options")
+).returns(import_zod.z.promise(SimpleViewQueryResponse));

package/impl/bulk.mjs

@@ -1,5 +1,6 @@
 // @ts-check
 import needle from 'needle'
+import { BulkSave, BulkGet, BulkRemove } from '../schema/bulk.mjs'
 
 const opts = {
   json: true,
@@ -8,9 +9,10 @@ const opts = {
   }
 }
 
-export async function bulkSave (config, docs) {
-  if (!docs) return
-  if (!docs.length) return
+/** @type { import('../schema/bulk.mjs').BulkSaveSchema } */
+export const bulkSave = 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 url = `${config.couch}/_bulk_docs`
   const body = { docs }
@@ -18,27 +20,34 @@ export async function bulkSave (config, docs) {
   if (resp.statusCode !== 201) throw new Error('could not save')
   const results = resp?.body || []
   return results
-}
+})
 
-export async function bulkGet (config, ids) {
+/** @type { import('../schema/bulk.mjs').BulkGetSchema } */
+export const bulkGet = BulkGet.implement(async (config, ids) => {
   const keys = ids
   const url = `${config.couch}/_all_docs?include_docs=true`
   const body = { keys }
   const resp = await needle('post', url, body, opts)
   if (resp.statusCode !== 200) throw new Error('could not fetch')
   const rows = resp?.body?.rows || []
+  /** @type {Array<import('../schema/crud.mjs').CouchDocSchema>} */
   const docs = []
-  rows.forEach(r => {
+  rows.forEach((
+    /** @type {{ error?: any, key?: string, doc?: import('../schema/crud.mjs').CouchDocSchema }} */ r
+  ) => {
     if (r.error) return
     if (!r.key) return
     if (!r.doc) return
-    docs.push(r.doc)
+    /** @type { import('../schema/crud.mjs').CouchDocSchema } */
+    const doc = r.doc
+    docs.push(doc)
   })
   return docs
-}
+})
 
-export async function bulkRemove (config, ids) {
+/** @type { import('../schema/bulk.mjs').BulkRemoveSchema } */
+export const bulkRemove = BulkRemove.implement(async (config, ids) => {
   const docs = await bulkGet(config, ids)
   docs.forEach(d => { d._deleted = true })
   return bulkSave(config, docs)
-}
+})

package/impl/crud.mjs

@@ -12,11 +12,9 @@ const opts = {
 export const get = CouchGet.implement(async (config, id) => {
   const url = `${config.couch}/${id}`
   const resp = await needle('get', url, opts)
+  if (resp.statusCode === 404) return null
   const result = resp?.body || {}
-  result.statusCode = resp.statusCode
-  if (resp.statusCode !== 200) {
-    throw new Error('not found')
-  }
+  if (resp.statusCode !== 200) { throw new Error(result.reason || 'failed') }
   return result
 })
 

package/impl/patch.mjs

@@ -0,0 +1,36 @@
+import { get, put } from './crud.mjs'
+import { CouchPatch } from '../schema/patch.mjs'
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+
+export const patch = CouchPatch.implement(async (config, id, properties) => {
+  const maxRetries = config.retries || 5
+  const delay = config.delay || 1000
+  let attempts = 0
+
+  while (attempts <= maxRetries) {
+    try {
+      const doc = await get(config, id)
+      const updatedDoc = { ...doc, ...properties }
+      const result = await put(config, updatedDoc)
+
+      // Check if the response indicates a conflict
+      if (result.ok) {
+        return result
+      }
+      // If not ok, treat as conflict and retry
+      attempts++
+      if (attempts > maxRetries) {
+        throw new Error(`Failed to patch after ${maxRetries} attempts`)
+      }
+      await sleep(delay)
+    } catch (err) {
+      // Handle other errors (network, etc)
+      attempts++
+      if (attempts > maxRetries) {
+        throw new Error(`Failed to patch after ${maxRetries} attempts: ${err.message}`)
+      }
+      await sleep(delay)
+    }
+  }
+})

package/impl/query.mjs

@@ -27,6 +27,10 @@ export const query = SimpleViewQuery.implement(async (config, view, options) =>
   return body
 })
 
+/**
+ * @param {{ [key: string]: any }} options - The options object containing query parameters.
+ * @param {string[]} params - The list of parameter names to include in the query string.
+ */
 export function queryString (options, params) {
   const parts = Object.keys(options).map(key => {
     let value = options[key]

package/impl/stream.mjs

@@ -2,8 +2,14 @@
 
 import needle from 'needle'
 import { queryString } from './query.mjs'
+// @ts-ignore
 import JSONStream from 'JSONStream'
 
+/**
+ * @param {any} config
+ * @param {any} view
+ * @param {any} options
+ */
 export const queryStream = (config, view, options) => new Promise((resolve, reject) => {
   if (!options) options = {}
 
@@ -12,7 +18,10 @@ export const queryStream = (config, view, options) => new Promise((resolve, reje
   const url = `${config.couch}/${view}?${qs.toString()}`
   const streamer = JSONStream.parse('rows.*')
   streamer.on('data', onRow)
-  streamer.on('end', (err) => {
+  /**
+   * @param {any} err
+   */
+  streamer.on('end', (/** @type any */err) => {
     if (err) return reject(err)
     resolve(null) // all work should be done in the stream
   })

package/index.mjs

@@ -1,10 +1,12 @@
 import { bulkGet, bulkSave, bulkRemove } from './impl/bulk.mjs'
 import { get, put } from './impl/crud.mjs'
+import { patch } from './impl/patch.mjs'
 import { query } from './impl/query.mjs'
 import { queryStream } from './impl/stream.mjs'
 import { BulkSave, BulkGet } from './schema/bulk.mjs'
 import { CouchConfig } from './schema/config.mjs'
 import { SimpleViewQuery, SimpleViewQueryResponse } from './schema/query.mjs'
+import { PatchConfig, PatchDoc } from './schema/patch.mjs'
 import { CouchDoc, CouchDocResponse, CouchPut, CouchGet } from './schema/crud.mjs'
 
 const schema = {
@@ -16,8 +18,9 @@ const schema = {
   CouchGet,
   CouchPut,
   CouchDoc,
-  CouchDocResponse
+  CouchDocResponse,
+  PatchConfig,
+  PatchDoc
 }
 
-export { get, put, bulkGet, bulkSave, bulkRemove, query, queryStream, schema }
-
+export { get, put, patch, bulkGet, bulkSave, bulkRemove, query, queryStream, schema }

package/package.json

@@ -1,10 +1,22 @@
 {
   "name": "hide-a-bed",
-  "version": "1.2.0",
+  "version": "3.0.0",
   "description": "An abstraction over couchdb calls that includes easy mock/stubs with pouchdb",
-  "main": "index.mjs",
+  "module": "index.mjs",
+  "main": "cjs/index.cjs",
+  "type": "module",
+  "exports": {
+    "import": "./index.mjs",
+    "require": "./cjs/index.cjs",
+    "default": "./cjs/index.cjs"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "clean": "(find . -name \"*.mts\" -type f -delete || true) && (find . -name \"*.map\" -type f -delete || true)",
+    "build": "npm run clean && tsc && npm run build:cjs",
+    "build:cjs": "rm -rf cjs && node build/build.mjs",
+    "test": "standard && tape tests/*.mjs",
+    "lint:fix": "standard --fix",
+    "prepublish": "npm run build"
   },
   "repository": {
     "type": "git",
@@ -25,5 +37,18 @@
     "lodash": "^4.17.21",
     "needle": "^3.2.0",
     "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.15",
+    "@types/needle": "^3.3.0",
+    "esbuild": "^0.24.2",
+    "glob": "^11.0.0",
+    "standard": "17.1.0",
+    "tape": "5.8.1",
+    "typescript": "5.6.2"
+  },
+  "volta": {
+    "node": "20.17.0",
+    "npm": "10.8.2"
   }
 }

package/schema/bulk.mjs

@@ -1,9 +1,10 @@
 import { z } from 'zod'
 import { CouchConfig } from './config.mjs'
+import { CouchDoc } from './crud.mjs'
 
 export const BulkSaveResponseSchema = z.array(z.object({
   ok: z.boolean().nullish(),
-  id: z.string(),
+  id: z.string().nullish(),
   rev: z.string().nullish(),
   error: z.string().nullish().describe('if an error occured, one word reason, eg conflict'),
   reason: z.string().nullish().describe('a full error message')
@@ -16,9 +17,16 @@ export const BulkSave = z.function().args(
     _id: z.string()
   }).passthrough())
 ).returns(z.promise(BulkSaveResponseSchema))
-/** @typedef { z.infer<typeof SaveSchema> } Save */
+/** @typedef { z.infer<typeof BulkSave> } BulkSaveSchema */
 
 export const BulkGet = z.function().args(
   CouchConfig,
   z.array(z.string().describe('the ids to get'))
-)
+).returns(z.promise(z.array(CouchDoc)))
+/** @typedef { z.infer<typeof BulkGet> } BulkGetSchema */
+
+export const BulkRemove = z.function().args(
+  CouchConfig,
+  z.array(z.string().describe('the ids to delete'))
+).returns(z.promise(BulkSaveResponseSchema))
+/** @typedef { z.infer<typeof BulkRemove> } BulkRemoveSchema */

package/schema/crud.mjs

@@ -5,6 +5,7 @@ export const CouchDoc = z.object({
   _id: z.string().describe('the couch doc id'),
   _rev: z.string().optional().describe('the doc revision')
 }).passthrough()
+/** @typedef { z.infer<typeof CouchDoc> } CouchDocSchema */
 
 export const CouchDocResponse = z.object({
   ok: z.boolean().optional().describe('did the request succeed'),
@@ -22,4 +23,4 @@ export const CouchPut = z.function().args(
 export const CouchGet = z.function().args(
   CouchConfig,
   z.string().describe('the couch doc id')
-).returns(z.promise(CouchDoc))
+).returns(z.promise(CouchDoc.nullable()))

package/schema/patch.mjs

@@ -0,0 +1,18 @@
+import { z } from 'zod'
+import { CouchConfig } from './config.mjs'
+import { CouchDocResponse } from './crud.mjs'
+
+export const PatchConfig = CouchConfig.extend({
+  retries: z.number().min(0).max(100).optional(),
+  delay: z.number().min(0).optional()
+})
+
+export const PatchProperties = z.record(z.string(), z.any())
+
+export const CouchPatch = z.function()
+  .args(
+    PatchConfig,
+    z.string().describe('the couch doc id'),
+    PatchProperties
+  )
+  .returns(z.promise(CouchDocResponse))

package/schema/query.mjs

@@ -11,7 +11,6 @@ export const SimpleViewQueryResponse = z.object({
   }))
 }).passthrough()
 
-
 export const SimpleViewQuery = z.function().args(
   CouchConfig,
   z.string().describe('the view name'),

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "include": ["*.mjs"],
+  "compilerOptions": {
+    "module": "Node16",
+    "target": "es2020",
+    "verbatimModuleSyntax": true,
+    "strict": true,
+    "allowJs": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "declarationMap": true
+  }
+}