hide-a-bed 5.0.2 → 5.0.4

package/cjs/impl/patch.cjs

@@ -0,0 +1,95 @@
+"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,
+  patchDangerously: () => patchDangerously,
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(patch_exports);
+var import_crud = require("./crud.cjs");
+var import_patch = require("../schema/patch.cjs");
+var import_logger = require("./logger.cjs");
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const patch = import_patch.Patch.implement(async (config, id, properties) => {
+  const logger = (0, import_logger.createLogger)(config);
+  logger.info(`Starting patch operation for document ${id}`);
+  logger.debug("Patch properties:", properties);
+  const doc = await (0, import_crud.get)(config, id);
+  if (doc._rev !== properties._rev) {
+    const result2 = {};
+    result2.ok = false;
+    result2.error = "conflict";
+    result2.statusCode = 409;
+    return result2;
+  }
+  const updatedDoc = { ...doc, ...properties };
+  logger.debug("Merged document:", updatedDoc);
+  const result = await (0, import_crud.put)(config, updatedDoc);
+  logger.info(`Successfully patched document ${id}, rev: ${result.rev}`);
+  return result;
+});
+const patchDangerously = import_patch.PatchDangerously.implement(async (config, id, properties) => {
+  const logger = (0, import_logger.createLogger)(config);
+  const maxRetries = config.maxRetries || 5;
+  let delay = config.initialDelay || 1e3;
+  let attempts = 0;
+  logger.info(`Starting patch operation for document ${id}`);
+  logger.debug("Patch properties:", properties);
+  while (attempts <= maxRetries) {
+    logger.debug(`Attempt ${attempts + 1} of ${maxRetries + 1}`);
+    try {
+      const doc = await (0, import_crud.get)(config, id);
+      if (!doc) {
+        logger.warn(`Document ${id} not found`);
+        return { ok: false, statusCode: 404, error: "not_found" };
+      }
+      const updatedDoc = { ...doc, ...properties };
+      logger.debug("Merged document:", updatedDoc);
+      const result = await (0, import_crud.put)(config, updatedDoc);
+      if (result.ok) {
+        logger.info(`Successfully patched document ${id}, rev: ${result.rev}`);
+        return result;
+      }
+      attempts++;
+      if (attempts > maxRetries) {
+        logger.error(`Failed to patch ${id} after ${maxRetries} attempts`);
+        throw new Error(`Failed to patch after ${maxRetries} attempts`);
+      }
+      logger.warn(`Conflict detected for ${id}, retrying (attempt ${attempts})`);
+      await sleep(delay);
+      delay *= config.backoffFactor;
+      logger.debug(`Next retry delay: ${delay}ms`);
+    } catch (err) {
+      if (err.message === "not_found") {
+        logger.warn(`Document ${id} not found during patch operation`);
+        return { ok: false, statusCode: 404, error: "not_found" };
+      }
+      attempts++;
+      if (attempts > maxRetries) {
+        const error = `Failed to patch after ${maxRetries} attempts: ${err.message}`;
+        logger.error(error);
+        return { ok: false, statusCode: 500, error };
+      }
+      logger.warn(`Error during patch attempt ${attempts}: ${err.message}`);
+      await sleep(delay);
+      logger.debug(`Retrying after ${delay}ms`);
+    }
+  }
+});

package/cjs/impl/query.cjs

@@ -0,0 +1,116 @@
+"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_errors = require("./errors.cjs");
+var import_logger = require("./logger.cjs");
+var import_lodash = __toESM(require("lodash"), 1);
+const { includes } = import_lodash.default;
+const query = import_query.SimpleViewQuery.implement(async (config, view, options = {}) => {
+  const logger = (0, import_logger.createLogger)(config);
+  logger.info(`Starting view query: ${view}`);
+  logger.debug("Query options:", options);
+  let qs = queryString(options, ["key", "startkey", "endkey", "reduce", "group", "group_level", "stale", "limit"]);
+  let method = "GET";
+  let payload = null;
+  const opts = {
+    json: true,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  };
+  if (typeof options.keys !== "undefined") {
+    const MAX_URL_LENGTH = 2e3;
+    const _options = JSON.parse(JSON.stringify(options));
+    delete _options.keys;
+    qs = queryString(_options, ["key", "startkey", "endkey", "reduce", "group", "group_level", "stale", "limit"]);
+    const keysAsString = `keys=${JSON.stringify(options.keys)}`;
+    if (keysAsString.length + qs.length + 1 <= MAX_URL_LENGTH) {
+      method = "GET";
+      if (qs.length > 0) qs += "&";
+      else qs = "?";
+      qs += keysAsString;
+    } else {
+      method = "POST";
+      payload = { keys: options.keys };
+    }
+  }
+  logger.debug("Generated query string:", qs);
+  const url = `${config.couch}/${view}?${qs.toString()}`;
+  let results;
+  try {
+    logger.debug(`Sending ${method} request to: ${url}`);
+    results = method === "GET" ? await (0, import_needle.default)("get", url, opts) : await (0, import_needle.default)("post", url, payload, opts);
+  } catch (err) {
+    logger.error("Network error during query:", err);
+    import_errors.RetryableError.handleNetworkError(err);
+  }
+  if (!results) {
+    logger.error("No response received from query request");
+    throw new import_errors.RetryableError("no response", 503);
+  }
+  const body = results.body;
+  if (import_errors.RetryableError.isRetryableStatusCode(results.statusCode)) {
+    logger.warn(`Retryable status code received: ${results.statusCode}`);
+    throw new import_errors.RetryableError(body.error || "retryable error during query", results.statusCode);
+  }
+  if (body.error) {
+    logger.error(`Query error: ${body.error}`);
+    throw new Error(body.error);
+  }
+  logger.info(`Successfully executed view query: ${view}`);
+  logger.debug("Query response:", body);
+  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/queryBuilder.cjs

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var queryBuilder_exports = {};
+__export(queryBuilder_exports, {
+  QueryBuilder: () => QueryBuilder,
+  createQuery: () => createQuery
+});
+module.exports = __toCommonJS(queryBuilder_exports);
+class QueryBuilder {
+  /** @type {QueryOptions} */
+  #options = {};
+  /**
+   * @param {any} key
+   * @returns {QueryBuilder}
+   */
+  key(key) {
+    this.#options.key = key;
+    return this;
+  }
+  /**
+   * @param {any} startkey
+   * @returns {QueryBuilder}
+   */
+  startKey(startkey) {
+    this.#options.startkey = startkey;
+    return this;
+  }
+  /**
+   * @param {any} endkey
+   * @returns {QueryBuilder}
+   */
+  endKey(endkey) {
+    this.#options.endkey = endkey;
+    return this;
+  }
+  /**
+   * @param {boolean} reduce
+   * @returns {QueryBuilder}
+   */
+  reduce(reduce = true) {
+    this.#options.reduce = reduce;
+    return this;
+  }
+  /**
+   * @param {boolean} group
+   * @returns {QueryBuilder}
+   */
+  group(group = true) {
+    this.#options.group = group;
+    return this;
+  }
+  /**
+   * @param {number} level
+   * @returns {QueryBuilder}
+   */
+  groupLevel(level) {
+    this.#options.group_level = level;
+    return this;
+  }
+  /**
+   * @param {string} stale
+   * @returns {QueryBuilder}
+   */
+  stale(stale) {
+    this.#options.stale = stale;
+    return this;
+  }
+  /**
+   * @param {number} limit
+   * @returns {QueryBuilder}
+   */
+  limit(limit) {
+    this.#options.limit = limit;
+    return this;
+  }
+  /**
+   * @returns {QueryOptions}
+   */
+  build() {
+    return { ...this.#options };
+  }
+}
+const createQuery = () => new QueryBuilder();

package/cjs/impl/retry.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 retry_exports = {};
+__export(retry_exports, {
+  withRetry: () => withRetry
+});
+module.exports = __toCommonJS(retry_exports);
+var import_errors = require("./errors.cjs");
+var import_patch = require("./patch.cjs");
+function withRetry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    initialDelay = 1e3,
+    // 1 second
+    backoffFactor = 2
+    // exponential backoff multiplier
+  } = options;
+  return async (...args) => {
+    let lastError;
+    let delay = initialDelay;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn(...args);
+      } catch (error) {
+        lastError = error;
+        if (!(error instanceof import_errors.RetryableError)) {
+          throw error;
+        }
+        if (attempt === maxRetries) {
+          throw error;
+        }
+        await (0, import_patch.sleep)(delay);
+        delay *= backoffFactor;
+      }
+    }
+    throw lastError;
+  };
+}

package/cjs/impl/stream.cjs

@@ -0,0 +1,121 @@
+"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_config = require("../schema/config.cjs");
+var import_query = require("./query.cjs");
+var import_errors = require("./errors.cjs");
+var import_logger = require("./logger.cjs");
+var import_JSONStream = __toESM(require("JSONStream"), 1);
+const queryStream = (rawConfig, view, options, onRow) => new Promise((resolve, reject) => {
+  const config = import_config.CouchConfig.parse(rawConfig);
+  const logger = (0, import_logger.createLogger)(config);
+  logger.info(`Starting view query stream: ${view}`);
+  logger.debug("Query options:", options);
+  if (!options) options = {};
+  let method = "GET";
+  let payload = null;
+  let qs = (0, import_query.queryString)(options, ["key", "startkey", "endkey", "reduce", "group", "group_level", "stale", "limit"]);
+  logger.debug("Generated query string:", qs);
+  if (typeof options.keys !== "undefined") {
+    const MAX_URL_LENGTH = 2e3;
+    const keysAsString = `keys=${encodeURIComponent(JSON.stringify(options.keys))}`;
+    if (keysAsString.length + qs.length + 1 <= MAX_URL_LENGTH) {
+      qs += (qs[0] === "?" ? "&" : "?") + keysAsString;
+    } else {
+      method = "POST";
+      payload = { keys: options.keys };
+    }
+  }
+  const url = `${config.couch}/${view}?${qs.toString()}`;
+  const opts = {
+    json: true,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    parse_response: false
+    // Keep as stream
+  };
+  const streamer = import_JSONStream.default.parse("rows.*");
+  let rowCount = 0;
+  streamer.on(
+    "data",
+    /** @param {object} row */
+    (row) => {
+      rowCount++;
+      onRow(row);
+    }
+  );
+  streamer.on(
+    "error",
+    /** @param {Error} err */
+    (err) => {
+      logger.error("Stream parsing error:", err);
+      reject(new Error(`Stream parsing error: ${err.message}`));
+    }
+  );
+  streamer.on(
+    "done",
+    /** @param {Error|null} err */
+    (err) => {
+      try {
+        import_errors.RetryableError.handleNetworkError(err);
+      } catch (e) {
+        reject(e);
+      }
+    }
+  );
+  streamer.on("end", () => {
+    logger.info(`Stream completed, processed ${rowCount} rows`);
+    resolve(void 0);
+  });
+  const req = method === "GET" ? import_needle.default.get(url, opts) : import_needle.default.post(url, payload, opts);
+  req.on("response", (response) => {
+    logger.debug(`Received response with status code: ${response.statusCode}`);
+    if (import_errors.RetryableError.isRetryableStatusCode(response.statusCode)) {
+      logger.warn(`Retryable status code received: ${response.statusCode}`);
+      reject(new import_errors.RetryableError("retryable error during stream query", response.statusCode));
+    }
+  });
+  req.on("error", (err) => {
+    logger.error("Network error during stream query:", err);
+    try {
+      import_errors.RetryableError.handleNetworkError(err);
+    } catch (retryErr) {
+      reject(retryErr);
+      return;
+    }
+    reject(err);
+  });
+  req.pipe(streamer);
+});

package/cjs/impl/sugar/lock.cjs

@@ -0,0 +1,81 @@
+"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 lock_exports = {};
+__export(lock_exports, {
+  createLock: () => createLock,
+  removeLock: () => removeLock
+});
+module.exports = __toCommonJS(lock_exports);
+var import_lock = require("../../schema/sugar/lock.cjs");
+var import_crud = require("../crud.cjs");
+var import_logger = require("../logger.cjs");
+const createLock = import_lock.CreateLock.implement(async (config, docId, options) => {
+  const logger = (0, import_logger.createLogger)(config);
+  if (!options.enableLocking) {
+    logger.debug("Locking disabled, returning true");
+    return true;
+  }
+  const _id = `lock-${docId}`;
+  const lock = {
+    _id,
+    type: "lock",
+    locks: docId,
+    lockedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lockedBy: options.username
+  };
+  try {
+    const result = await (0, import_crud.put)(config, lock);
+    logger.info(`Lock created for ${docId} by ${options.username}`);
+    return result.ok === true;
+  } catch (error) {
+    if (error.status === 409) {
+      logger.warn(`Lock conflict for ${docId} - already locked`);
+    } else {
+      logger.error(`Error creating lock for ${docId}:`, error);
+    }
+    return false;
+  }
+});
+const removeLock = import_lock.RemoveLock.implement(async (config, docId, options) => {
+  const logger = (0, import_logger.createLogger)(config);
+  if (!options.enableLocking) {
+    logger.debug("Locking disabled, skipping unlock");
+    return;
+  }
+  if (!docId) {
+    logger.warn("No docId provided for unlock");
+    return;
+  }
+  const _id = `lock-${docId}`;
+  const existingLock = await (0, import_crud.get)(config, _id);
+  if (!existingLock) {
+    logger.debug(`No lock found for ${docId}`);
+    return;
+  }
+  if (existingLock.lockedBy !== options.username) {
+    logger.warn(`Cannot remove lock for ${docId} - owned by ${existingLock.lockedBy}`);
+    return;
+  }
+  try {
+    await (0, import_crud.put)(config, { ...existingLock, _deleted: true });
+    logger.info(`Lock removed for ${docId}`);
+  } catch (error) {
+    logger.error(`Error removing lock for ${docId}:`, error);
+  }
+});