hide-a-bed 2.1.0 → 3.0.1

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,
+  Patch: import_patch2.Patch
+};

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, {
+  Patch: () => Patch,
+  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 Patch = 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.d.mts

@@ -0,0 +1,7 @@
+/** @type { import('../schema/bulk.mjs').BulkSaveSchema } */
+export const bulkSave: import("../schema/bulk.mjs").BulkSaveSchema;
+/** @type { import('../schema/bulk.mjs').BulkGetSchema } */
+export const bulkGet: import("../schema/bulk.mjs").BulkGetSchema;
+/** @type { import('../schema/bulk.mjs').BulkRemoveSchema } */
+export const bulkRemove: import("../schema/bulk.mjs").BulkRemoveSchema;
+//# sourceMappingURL=bulk.d.mts.map

package/impl/bulk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk.d.mts","sourceRoot":"","sources":["bulk.mjs"],"names":[],"mappings":"AAWA,4DAA4D;AAC5D,uBADY,OAAO,oBAAoB,EAAE,cAAc,CAWrD;AAEF,2DAA2D;AAC3D,sBADY,OAAO,oBAAoB,EAAE,aAAa,CAqBpD;AAEF,8DAA8D;AAC9D,yBADY,OAAO,oBAAoB,EAAE,gBAAgB,CAKvD"}