hide-a-bed 2.1.0 → 3.0.0

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/patch.mjs

@@ -13,7 +13,7 @@ export const patch = CouchPatch.implement(async (config, id, properties) => {
       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

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

@@ -24,4 +24,3 @@ const schema = {
 }
 
 export { get, put, patch, bulkGet, bulkSave, bulkRemove, query, queryStream, schema }
-

package/package.json

@@ -1,10 +1,22 @@
 {
   "name": "hide-a-bed",
-  "version": "2.1.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,14 +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'),

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
+  }
+}