hide-a-bed 4.0.1 → 4.0.3

package/cjs/impl/bulk.cjs

@@ -104,14 +104,7 @@ const bulkGet = import_bulk.BulkGet.implement(async (config, ids) => {
     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);
-  });
+  const docs = rows.map((r) => r.doc);
   logger.info(`Successfully retrieved ${docs.length} documents`);
   return docs;
 });

package/cjs/impl/logger.cjs

@@ -26,16 +26,25 @@ function createLogger(config) {
     return config._normalizedLogger;
   }
   if (!config.logger) {
-    config._normalizedLogger = {
-      error: () => {
-      },
-      warn: () => {
-      },
-      info: () => {
-      },
-      debug: () => {
-      }
-    };
+    if (config.useConsoleLogger) {
+      config._normalizedLogger = {
+        error: (...args) => console.error(...args),
+        warn: (...args) => console.warn(...args),
+        info: (...args) => console.info(...args),
+        debug: (...args) => console.debug(...args)
+      };
+    } else {
+      config._normalizedLogger = {
+        error: () => {
+        },
+        warn: () => {
+        },
+        info: () => {
+        },
+        debug: () => {
+        }
+      };
+    }
     return config._normalizedLogger;
   }
   if (typeof config.logger === "function") {

package/cjs/impl/patch.cjs

@@ -24,34 +24,53 @@ __export(patch_exports, {
 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);
   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) return { ok: false, statusCode: 404, error: "not_found" };
+      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") return { ok: false, statusCode: 404, error: "not_found" };
+      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

@@ -36,10 +36,15 @@ 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);
   const qs = queryString(options, ["key", "startkey", "endkey", "reduce", "group", "group_level", "stale", "limit"]);
+  logger.debug("Generated query string:", qs);
   const opts = {
     json: true,
     headers: {
@@ -49,16 +54,27 @@ const query = import_query.SimpleViewQuery.implement(async (config, view, option
   const url = `${config.couch}/${view}?${qs.toString()}`;
   let results;
   try {
+    logger.debug(`Sending GET request to: ${url}`);
     results = await (0, import_needle.default)("get", url, opts);
   } catch (err) {
+    logger.error("Network error during query:", err);
     import_errors.RetryableError.handleNetworkError(err);
   }
-  if (!results) throw new import_errors.RetryableError("no response", 503);
+  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) throw new Error(body.error);
+  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) {

package/cjs/impl/stream.cjs

@@ -34,6 +34,7 @@ module.exports = __toCommonJS(stream_exports);
 var import_needle = __toESM(require("needle"), 1);
 var import_query = require("./query.cjs");
 var import_errors = require("./errors.cjs");
+var import_logger = require("./logger.cjs");
 var import_JSONStream = __toESM(require("JSONStream"), 1);
 const queryStream = (config, view, options, onRow) => new Promise((resolve, reject) => {
   if (!options) options = {};
@@ -48,7 +49,15 @@ const queryStream = (config, view, options, onRow) => new Promise((resolve, reje
     // Keep as stream
   };
   const streamer = import_JSONStream.default.parse("rows.*");
-  streamer.on("data", onRow);
+  let rowCount = 0;
+  streamer.on(
+    "data",
+    /** @param {object} row */
+    (row) => {
+      rowCount++;
+      onRow(row);
+    }
+  );
   streamer.on(
     "error",
     /** @param {Error} err */
@@ -74,7 +83,6 @@ const queryStream = (config, view, options, onRow) => new Promise((resolve, reje
   req.on("response", (response) => {
     if (import_errors.RetryableError.isRetryableStatusCode(response.statusCode)) {
       reject(new import_errors.RetryableError("retryable error during stream query", response.statusCode));
-      return;
     }
   });
   req.on("error", (err) => {

package/cjs/index.cjs

@@ -52,6 +52,7 @@ const schema = {
   OnRow: import_stream2.OnRow,
   BulkSave: import_bulk2.BulkSave,
   BulkGet: import_bulk2.BulkGet,
+  BulkRemove: import_bulk2.BulkRemove,
   CouchGet: import_crud2.CouchGet,
   CouchPut: import_crud2.CouchPut,
   CouchDoc: import_crud2.CouchDoc,

package/cjs/schema/config.cjs

@@ -40,6 +40,7 @@ const CouchConfig = import_zod.z.object({
   maxRetries: import_zod.z.number().optional().default(3).describe("maximum number of retry attempts"),
   initialDelay: import_zod.z.number().optional().default(1e3).describe("initial retry delay in milliseconds"),
   backoffFactor: import_zod.z.number().optional().default(2).describe("multiplier for exponential backoff"),
+  useConsoleLogger: import_zod.z.boolean().optional().default(false).describe("turn on console as a fallback logger"),
   logger: LoggerSchema.optional().describe("logging interface supporting winston-like or simple function interface"),
   _normalizedLogger: import_zod.z.any().optional()
   // Internal property for caching normalized logger

package/cjs/schema/stream.cjs

@@ -28,7 +28,7 @@ var import_config = require("./config.cjs");
 var import_query = require("./query.cjs");
 const OnRow = import_zod.z.function().args(
   import_query.ViewRow
-).returns(import_zod.z.undefined());
+);
 const SimpleViewQueryStream = import_zod.z.function().args(
   import_config.CouchConfig,
   import_zod.z.string().describe("the view name"),

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":"AAaA,4DAA4D;AAC5D,uBADY,OAAO,oBAAoB,EAAE,cAAc,CAsCrD;AAEF,2DAA2D;AAC3D,sBADY,OAAO,oBAAoB,EAAE,aAAa,CAkCpD;AAEF,8DAA8D;AAC9D,yBADY,OAAO,oBAAoB,EAAE,gBAAgB,CAOvD"}

package/impl/bulk.mjs

@@ -15,7 +15,7 @@ const opts = {
 export const bulkSave = BulkSave.implement(async (config, docs) => {
   /** @type {import('./logger.mjs').Logger }  */
   const logger = createLogger(config)
-  
+
   if (!docs) {
     logger.warn('bulkSave called with no docs')
     return { ok: false, error: 'noDocs', reason: 'no docs provided' }
@@ -55,7 +55,7 @@ export const bulkSave = BulkSave.implement(async (config, docs) => {
 export const bulkGet = BulkGet.implement(async (config, ids) => {
   const logger = createLogger(config)
   const keys = ids
-  
+
   logger.info(`Starting bulk get for ${keys.length} documents`)
   const url = `${config.couch}/_all_docs?include_docs=true`
   const body = { keys }
@@ -80,17 +80,9 @@ export const bulkGet = BulkGet.implement(async (config, ids) => {
   }
   const rows = resp?.body?.rows || []
   /** @type {Array<import('../schema/crud.mjs').CouchDocSchema>} */
-  const docs = []
-  rows.forEach((
+  const docs = rows.map((
     /** @type {{ error?: any, key?: string, doc?: import('../schema/crud.mjs').CouchDocSchema }} */ r
-  ) => {
-    if (r.error) return
-    if (!r.key) return
-    if (!r.doc) return
-    /** @type { import('../schema/crud.mjs').CouchDocSchema } */
-    const doc = r.doc
-    docs.push(doc)
-  })
+  ) => r.doc)
   logger.info(`Successfully retrieved ${docs.length} documents`)
   return docs
 })

package/impl/crud.d.mts

@@ -0,0 +1,5 @@
+/** @type { import('../schema/crud.mjs').CouchGetSchema } */
+export const get: import("../schema/crud.mjs").CouchGetSchema;
+/** @type { import('../schema/crud.mjs').CouchPutSchema } */
+export const put: import("../schema/crud.mjs").CouchPutSchema;
+//# sourceMappingURL=crud.d.mts.map

package/impl/crud.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAaA,4DAA4D;AAC5D,kBADY,OAAO,oBAAoB,EAAE,cAAc,CAwCrD;AAEF,4DAA4D;AAC5D,kBADY,OAAO,oBAAoB,EAAE,cAAc,CAqCrD"}

package/impl/crud.mjs

@@ -16,7 +16,7 @@ export const get = CouchGet.implement(async (config, id) => {
   const logger = createLogger(config)
   const url = `${config.couch}/${id}`
   logger.info(`Getting document with id: ${id}`)
-  
+
   try {
     const resp = await needle('get', url, opts)
     if (!resp) {
@@ -58,7 +58,7 @@ export const put = CouchPut.implement(async (config, doc) => {
   const logger = createLogger(config)
   const url = `${config.couch}/${doc._id}`
   const body = doc
-  
+
   logger.info(`Putting document with id: ${doc._id}`)
   let resp
   try {
@@ -67,27 +67,27 @@ export const put = CouchPut.implement(async (config, doc) => {
     logger.error('Error during put operation:', err)
     RetryableError.handleNetworkError(err)
   }
-  
+
   if (!resp) {
     logger.error('No response received from put request')
     throw new RetryableError('no response', 503)
   }
-  
+
   const result = resp?.body || {}
   result.statusCode = resp.statusCode
-  
+
   if (resp.statusCode === 409) {
     logger.warn(`Conflict detected for document: ${doc._id}`)
     result.ok = false
     result.error = 'conflict'
     return result
   }
-  
+
   if (RetryableError.isRetryableStatusCode(resp.statusCode)) {
     logger.warn(`Retryable status code received: ${resp.statusCode}`)
     throw new RetryableError(result.reason || 'retryable error', resp.statusCode)
   }
-  
+
   logger.info(`Successfully saved document: ${doc._id}`)
   return result
 })

package/impl/errors.d.mts

@@ -0,0 +1,35 @@
+/**
+ * @typedef {Object} NetworkError
+ * @property {string} code - The error code
+ * @property {string} [message] - Optional error message
+ */
+export class RetryableError extends Error {
+    /**
+     * @param {number|undefined} statusCode - The HTTP status code to check
+     * @returns {boolean} Whether the status code is retryable
+     */
+    static isRetryableStatusCode(statusCode: number | undefined): boolean;
+    /**
+     * @param {NetworkError | unknown} err - The network error to handle
+     * @throws {RetryableError} If the error is retryable
+     * @throws {Error} If the error is not retryable
+     */
+    static handleNetworkError(err: NetworkError | unknown): void;
+    /**
+     * @param {string} message - The error message
+     * @param {number|undefined} statusCode - The HTTP status code
+     */
+    constructor(message: string, statusCode: number | undefined);
+    statusCode: number | undefined;
+}
+export type NetworkError = {
+    /**
+     * - The error code
+     */
+    code: string;
+    /**
+     * - Optional error message
+     */
+    message?: string | undefined;
+};
+//# sourceMappingURL=errors.d.mts.map

package/impl/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","sourceRoot":"","sources":["errors.mjs"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;IAWE;;;OAGG;IACH,yCAHW,MAAM,GAAC,SAAS,GACd,OAAO,CAKnB;IAED;;;;OAIG;IACH,+BAJW,YAAY,GAAG,OAAO,QAsBhC;IA1CD;;;OAGG;IACH,qBAHW,MAAM,cACN,MAAM,GAAC,SAAS,EAM1B;IADC,+BAA4B;CAoC/B;;;;;UAhDa,MAAM"}

package/impl/errors.mjs

@@ -11,19 +11,19 @@ export class RetryableError extends Error {
    * @param {string} message - The error message
    * @param {number|undefined} statusCode - The HTTP status code
    */
-  constructor(message, statusCode) {
-    super(message);
-    this.name = 'RetryableError';
-    this.statusCode = statusCode;
+  constructor (message, statusCode) {
+    super(message)
+    this.name = 'RetryableError'
+    this.statusCode = statusCode
   }
 
   /**
    * @param {number|undefined} statusCode - The HTTP status code to check
    * @returns {boolean} Whether the status code is retryable
    */
-  static isRetryableStatusCode(statusCode) {
-    if (statusCode === undefined) return false;
-    return [408, 429, 500, 502, 503, 504].includes(statusCode);
+  static isRetryableStatusCode (statusCode) {
+    if (statusCode === undefined) return false
+    return [408, 429, 500, 502, 503, 504].includes(statusCode)
   }
 
   /**
@@ -31,7 +31,7 @@ export class RetryableError extends Error {
    * @throws {RetryableError} If the error is retryable
    * @throws {Error} If the error is not retryable
    */
-  static handleNetworkError(err) {
+  static handleNetworkError (err) {
     /** @type {Record<string, number>} */
     const networkErrors = {
       ECONNREFUSED: 503,
@@ -42,12 +42,12 @@ export class RetryableError extends Error {
       EPIPE: 503,
       EHOSTUNREACH: 503,
       ESOCKETTIMEDOUT: 503
-    };
+    }
 
     // Type guard for NetworkError shape
     if (typeof err === 'object' && err !== null && 'code' in err && typeof err.code === 'string' && networkErrors[err.code]) {
-      throw new RetryableError(`Network error: ${err.code}`, networkErrors[err.code]);
+      throw new RetryableError(`Network error: ${err.code}`, networkErrors[err.code])
     }
-    throw err;
+    throw err
   }
 }

package/impl/logger.d.mts

@@ -0,0 +1,32 @@
+/**
+ * @typedef {Object} Logger
+ * @property {(...args: any[]) => void} error - Log error messages
+ * @property {(...args: any[]) => void} warn - Log warning messages
+ * @property {(...args: any[]) => void} info - Log info messages
+ * @property {(...args: any[]) => void} debug - Log debug messages
+ */
+/**
+ * Creates a unified logger interface that works with both function and object-style loggers
+ * @param {import('../schema/config.mjs').CouchConfigSchema} config
+ * @returns {Logger} Normalized logger interface
+ */
+export function createLogger(config: import("../schema/config.mjs").CouchConfigSchema): Logger;
+export type Logger = {
+    /**
+     * - Log error messages
+     */
+    error: (...args: any[]) => void;
+    /**
+     * - Log warning messages
+     */
+    warn: (...args: any[]) => void;
+    /**
+     * - Log info messages
+     */
+    info: (...args: any[]) => void;
+    /**
+     * - Log debug messages
+     */
+    debug: (...args: any[]) => void;
+};
+//# sourceMappingURL=logger.d.mts.map

package/impl/logger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.mts","sourceRoot":"","sources":["logger.mjs"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,qCAHW,OAAO,sBAAsB,EAAE,iBAAiB,GAC9C,MAAM,CA+ClB;;;;;WAxDa,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;;;;UACxB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;;;;UACxB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;;;;WACxB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI"}

package/impl/logger.mjs

@@ -11,7 +11,7 @@
  * @param {import('../schema/config.mjs').CouchConfigSchema} config
  * @returns {Logger} Normalized logger interface
  */
-export function createLogger(config) {
+export function createLogger (config) {
   // Return cached logger if it exists
   if (config._normalizedLogger) {
     return config._normalizedLogger

package/impl/patch.d.mts

@@ -0,0 +1,4 @@
+export function sleep(ms: any): Promise<any>;
+/** @type { import('../schema/patch.mjs').PatchSchema } */
+export const patch: import("../schema/patch.mjs").PatchSchema;
+//# sourceMappingURL=patch.d.mts.map

package/impl/patch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAIO,6CAAmE;AAE1E,0DAA0D;AAC1D,oBADY,OAAO,qBAAqB,EAAE,WAAW,CA4DnD"}

package/impl/patch.mjs

@@ -22,10 +22,10 @@ export const patch = Patch.implement(async (config, id, properties) => {
         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 put(config, updatedDoc)
 
       // Check if the response indicates a conflict
@@ -33,25 +33,24 @@ export const patch = Patch.implement(async (config, id, properties) => {
         logger.info(`Successfully patched document ${id}, rev: ${result.rev}`)
         return result
       }
-      
+
       // If not ok, treat as conflict and retry
       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' }
       }
-      
+
       // Handle other errors (network, etc)
       attempts++
       if (attempts > maxRetries) {
@@ -59,7 +58,7 @@ export const patch = Patch.implement(async (config, id, properties) => {
         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`)