hide-a-bed 4.0.0 → 4.0.2

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.map

@@ -1 +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,CA0CpD;AAEF,8DAA8D;AAC9D,yBADY,OAAO,oBAAoB,EAAE,gBAAgB,CAOvD"}
+{"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.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.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.map

@@ -1 +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,CAsClB;;;;;WA/Ca,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"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAGO,6CAAmE;AAE1E,0DAA0D;AAC1D,oBADY,OAAO,qBAAqB,EAAE,WAAW,CAmCnD"}
+{"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`)

package/impl/query.d.mts

@@ -13,6 +13,7 @@ export const query: z.infer<z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -37,6 +38,7 @@ export const query: z.infer<z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -61,6 +63,7 @@ export const query: z.infer<z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;

package/impl/query.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.mts","sourceRoot":"","sources":["query.mjs"],"names":[],"mappings":"AAuCA;;;GAGG;AACH,qCAHW;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,UACtB,MAAM,EAAE,UAoBlB;AAnDD,+CAA+C;AAC/C,oBADY,CAAC,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAAiB,CA2BlC;kBAnCgB,KAAK"}
+{"version":3,"file":"query.d.mts","sourceRoot":"","sources":["query.mjs"],"names":[],"mappings":"AA6DA;;;GAGG;AACH,qCAHW;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,UACtB,MAAM,EAAE,UAoBlB;AAxED,+CAA+C;AAC/C,oBADY,CAAC,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAAiB,CAgDlC;kBAzDgB,KAAK"}

package/impl/query.mjs

@@ -43,7 +43,7 @@ export const query = SimpleViewQuery.implement(async (config, view, options) =>
 
   /** @type { z.infer<SimpleViewQueryResponse> } body */
   const body = results.body
-  
+
   if (RetryableError.isRetryableStatusCode(results.statusCode)) {
     logger.warn(`Retryable status code received: ${results.statusCode}`)
     throw new RetryableError(body.error || 'retryable error during query', results.statusCode)
@@ -64,10 +64,6 @@ export const query = SimpleViewQuery.implement(async (config, view, options) =>
  * @param {string[]} params - The list of parameter names to include in the query string.
  */
 export function queryString (options, params) {
-  const logger = createLogger({ useConsoleLogger: false })
-  logger.debug('Building query string with options:', options)
-  logger.debug('Allowed params:', params)
-  
   const parts = Object.keys(options).map(key => {
     let value = options[key]
     if (includes(params, key)) {

package/impl/retry.mjs

@@ -1,11 +1,11 @@
 import { RetryableError } from './errors.mjs'
 import { sleep } from './patch.mjs'
 
-export function withRetry(fn, options = {}) {
+export function withRetry (fn, options = {}) {
   const {
     maxRetries = 3,
     initialDelay = 1000, // 1 second
-    backoffFactor = 2    // exponential backoff multiplier
+    backoffFactor = 2 // exponential backoff multiplier
   } = options
 
   return async (...args) => {
@@ -17,7 +17,7 @@ export function withRetry(fn, options = {}) {
         return await fn(...args)
       } catch (error) {
         lastError = error
-        
+
         // Only retry if it's a RetryableError
         if (!(error instanceof RetryableError)) {
           throw error

package/impl/stream.d.mts

@@ -1,3 +1,3 @@
-/** @type { import('../schema/stream.mjs').SimpleViewQueryStreamSchema } */
+/** @type { import('../schema/stream.mjs').SimpleViewQueryStreamSchema } queryStream */
 export const queryStream: import("../schema/stream.mjs").SimpleViewQueryStreamSchema;
 //# sourceMappingURL=stream.d.mts.map

package/impl/stream.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.mts","sourceRoot":"","sources":["stream.mjs"],"names":[],"mappings":"AAOA,2EAA2E;AAC3E,0BADY,OAAO,sBAAsB,EAAE,2BAA2B,CAoDpE"}
+{"version":3,"file":"stream.d.mts","sourceRoot":"","sources":["stream.mjs"],"names":[],"mappings":"AAQA,uFAAuF;AACvF,0BADY,OAAO,sBAAsB,EAAE,2BAA2B,CA2DpE"}

package/impl/stream.mjs

@@ -6,16 +6,12 @@ import { createLogger } from './logger.mjs'
 // @ts-ignore
 import JSONStream from 'JSONStream'
 
-/** @type { import('../schema/stream.mjs').SimpleViewQueryStreamSchema } */
+/** @type { import('../schema/stream.mjs').SimpleViewQueryStreamSchema } queryStream */
 export const queryStream = (config, view, options, onRow) => new Promise((resolve, reject) => {
-  const logger = createLogger(config)
-  logger.info(`Starting stream query for view: ${view}`)
-  
+
   if (!options) options = {}
-  logger.debug('Stream query options:', options)
 
   const qs = queryString(options, ['key', 'startkey', 'endkey', 'reduce', 'group', 'group_level', 'stale', 'limit'])
-  logger.debug('Generated query string:', qs)
   const url = `${config.couch}/${view}?${qs.toString()}`
   const opts = {
     json: true,
@@ -26,53 +22,42 @@ export const queryStream = (config, view, options, onRow) => new Promise((resolv
   }
 
   const streamer = JSONStream.parse('rows.*')
-  
+
   let rowCount = 0
-  streamer.on('data', row => {
+  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 => {
-    if (err) {
-      logger.error('Stream done with error:', err)
-    }
     try {
       RetryableError.handleNetworkError(err)
     } catch (e) {
-      logger.error('Retryable error in stream:', e)
       reject(e)
     }
   })
-  
+
   streamer.on('end', () => {
-    logger.info(`Stream completed successfully, processed ${rowCount} rows`)
     resolve(undefined) // all work should be done in the stream
   })
-  
+
   const req = needle.get(url, opts)
-  
+
   req.on('response', response => {
-    logger.debug(`Received response with status code: ${response.statusCode}`)
     if (RetryableError.isRetryableStatusCode(response.statusCode)) {
-      logger.warn(`Retryable status code received: ${response.statusCode}`)
       reject(new RetryableError('retryable error during stream query', response.statusCode))
       // req.abort()
-      return
     }
   })
 
   req.on('error', err => {
-    logger.error('Request error:', err)
     try {
       RetryableError.handleNetworkError(err)
     } catch (retryErr) {
-      logger.error('Retryable error in request:', retryErr)
       reject(retryErr)
       return
     }
@@ -80,5 +65,4 @@ export const queryStream = (config, view, options, onRow) => new Promise((resolv
   })
 
   req.pipe(streamer)
-  
 })

package/index.d.mts

@@ -14,6 +14,7 @@ export namespace schema {
     export { OnRow };
     export { BulkSave };
     export { BulkGet };
+    export { BulkRemove };
     export { CouchGet };
     export { CouchPut };
     export { CouchDoc };
@@ -30,6 +31,7 @@ import { SimpleViewQueryStream } from './schema/stream.mjs';
 import { OnRow } from './schema/stream.mjs';
 import { BulkSave } from './schema/bulk.mjs';
 import { BulkGet } from './schema/bulk.mjs';
+import { BulkRemove } from './schema/bulk.mjs';
 import { CouchGet } from './schema/crud.mjs';
 import { CouchPut } from './schema/crud.mjs';
 import { CouchDoc } from './schema/crud.mjs';

package/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mjs"],"names":[],"mappings":"oBAEyB,iBAAiB;oBAAjB,iBAAiB;sBACpB,kBAAkB;wBAFM,iBAAiB;yBAAjB,iBAAiB;2BAAjB,iBAAiB;sBAGzC,kBAAkB;4BACZ,mBAAmB;;;;;;;;;;;;;;;AAyB/C,uDAAuD;AACvD,yBADY,OAAO,mBAAmB,EAAE,UAAU,CAsBhD;0BA9CwB,kBAAkB;4BAEhB,qBAAqB;gCACQ,oBAAoB;wCAApB,oBAAoB;sCAChC,qBAAqB;sBAArB,qBAAqB;yBAHhC,mBAAmB;wBAAnB,mBAAmB;yBAKU,mBAAmB;yBAAnB,mBAAmB;yBAAnB,mBAAmB;iCAAnB,mBAAmB;sBAD5D,oBAAoB"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mjs"],"names":[],"mappings":"oBAEyB,iBAAiB;oBAAjB,iBAAiB;sBACpB,kBAAkB;wBAFM,iBAAiB;yBAAjB,iBAAiB;2BAAjB,iBAAiB;sBAGzC,kBAAkB;4BACZ,mBAAmB;;;;;;;;;;;;;;;;AA0B/C,uDAAuD;AACvD,yBADY,OAAO,mBAAmB,EAAE,UAAU,CAsBhD;0BA/CwB,kBAAkB;4BAEhB,qBAAqB;gCACQ,oBAAoB;wCAApB,oBAAoB;sCAChC,qBAAqB;sBAArB,qBAAqB;yBAHpB,mBAAmB;wBAAnB,mBAAmB;2BAAnB,mBAAmB;yBAKF,mBAAmB;yBAAnB,mBAAmB;yBAAnB,mBAAmB;iCAAnB,mBAAmB;sBAD5D,oBAAoB"}

package/index.mjs

@@ -5,7 +5,7 @@ import { patch } from './impl/patch.mjs'
 import { query } from './impl/query.mjs'
 import { queryStream } from './impl/stream.mjs'
 import { withRetry } from './impl/retry.mjs'
-import { BulkSave, BulkGet } from './schema/bulk.mjs'
+import { BulkSave, BulkGet, BulkRemove } from './schema/bulk.mjs'
 import { CouchConfig } from './schema/config.mjs'
 import { SimpleViewQuery, SimpleViewQueryResponse } from './schema/query.mjs'
 import { SimpleViewQueryStream, OnRow } from './schema/stream.mjs'
@@ -21,6 +21,7 @@ const schema = {
   OnRow,
   BulkSave,
   BulkGet,
+  BulkRemove,
   CouchGet,
   CouchPut,
   CouchDoc,
@@ -48,7 +49,7 @@ const bindConfig = Bind.implement((
     bulkSave: config.bindWithRetry ? withRetry(bulkSave.bind(null, config), retryOptions) : bulkSave.bind(null, config),
     bulkRemove: config.bindWithRetry ? withRetry(bulkRemove.bind(null, config), retryOptions) : bulkRemove.bind(null, config),
     query: config.bindWithRetry ? withRetry(query.bind(null, config), retryOptions) : query.bind(null, config),
-    queryStream: config.bindWithRetry? withRetry(queryStream.bind(null, config), retryOptions) : queryStream.bind(null, config) 
+    queryStream: config.bindWithRetry ? withRetry(queryStream.bind(null, config), retryOptions) : queryStream.bind(null, config)
   }
 })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hide-a-bed",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "An abstraction over couchdb calls that includes easy mock/stubs with pouchdb",
   "module": "index.mjs",
   "main": "cjs/index.cjs",

package/schema/bind.d.mts

@@ -5,6 +5,7 @@ export const Bind: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -29,6 +30,7 @@ export const Bind: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -53,6 +55,7 @@ export const Bind: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -299,7 +302,7 @@ export const Bind: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
         key?: any;
         value?: any;
         doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }>], z.ZodUnknown>, z.ZodUndefined>], z.ZodUnknown>, z.ZodPromise<z.ZodUndefined>>;
+    }>], z.ZodUnknown>, z.ZodUnknown>], z.ZodUnknown>, z.ZodPromise<z.ZodUndefined>>;
 }, "strip", z.ZodTypeAny, {
     query: (args_0: string, args_1: {
         startkey?: any;
@@ -381,7 +384,7 @@ export const Bind: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
         key?: any;
         value?: any;
         doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }, ...args: unknown[]) => undefined, ...args: unknown[]) => Promise<undefined>;
+    }, ...args: unknown[]) => unknown, ...args: unknown[]) => Promise<undefined>;
 }, {
     query: (args_0: string, args_1: {
         startkey?: any;
@@ -463,7 +466,7 @@ export const Bind: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
         key?: any;
         value?: any;
         doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }, ...args: unknown[]) => undefined, ...args: unknown[]) => Promise<undefined>;
+    }, ...args: unknown[]) => unknown, ...args: unknown[]) => Promise<undefined>;
 }>>;
 export type BindSchema = z.infer<typeof Bind>;
 import { z } from 'zod';

package/schema/bind.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"bind.d.mts","sourceRoot":"","sources":["bind.mjs"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAuE;yBACxD,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC;kBAnBjB,KAAK"}
+{"version":3,"file":"bind.d.mts","sourceRoot":"","sources":["bind.mjs"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAuE;yBACxD,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC;kBAnBjB,KAAK"}

package/schema/bulk.d.mts

@@ -25,6 +25,7 @@ export const BulkSave: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -49,6 +50,7 @@ export const BulkSave: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -73,6 +75,7 @@ export const BulkSave: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -149,6 +152,7 @@ export const BulkGet: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -173,6 +177,7 @@ export const BulkGet: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -197,6 +202,7 @@ export const BulkGet: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -243,6 +249,7 @@ export const BulkRemove: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -267,6 +274,7 @@ export const BulkRemove: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -291,6 +299,7 @@ export const BulkRemove: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;

package/schema/bulk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"bulk.d.mts","sourceRoot":"","sources":["bulk.mjs"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;YAMG;AACH,mEAAmE;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAK4C;AAC5C,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;cAI4C;AAC5C,qEAAqE;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAGuC;AACvC,yDAAyD;AAEzD;;;;;;;;;4CAEuC;AACvC,mEAAmE;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG4C;AAC5C,+DAA+D;AAE/D;;;;;;;;;;;;;;;;;;cAE4C;uBApC7B,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC;6BAQtC,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;kCAOxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;4BAM7B,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC;iCAKvB,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC;+BAM5B,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC;oCAK1B,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC;kBAhD5B,KAAK"}
+{"version":3,"file":"bulk.d.mts","sourceRoot":"","sources":["bulk.mjs"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;YAMG;AACH,mEAAmE;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAK4C;AAC5C,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;cAI4C;AAC5C,qEAAqE;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAGuC;AACvC,yDAAyD;AAEzD;;;;;;;;;4CAEuC;AACvC,mEAAmE;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG4C;AAC5C,+DAA+D;AAE/D;;;;;;;;;;;;;;;;;;cAE4C;uBApC7B,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC;6BAQtC,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;kCAOxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;4BAM7B,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC;iCAKvB,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC;+BAM5B,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC;oCAK1B,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC;kBAhD5B,KAAK"}

package/schema/config.d.mts

@@ -5,6 +5,7 @@ export const CouchConfig: z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -29,6 +30,7 @@ export const CouchConfig: z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -53,6 +55,7 @@ export const CouchConfig: z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;

package/schema/config.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.mts","sourceRoot":"","sources":["config.mjs"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCASkD;gCAEnC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC;kBAvBxB,KAAK"}
+{"version":3,"file":"config.d.mts","sourceRoot":"","sources":["config.mjs"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAUkD;gCAEnC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC;kBAxBxB,KAAK"}

package/schema/config.mjs

@@ -7,7 +7,7 @@ const LoggerSchema = z.object({
   debug: z.function().args(z.any()).returns(z.void()).optional()
 }).or(z.function().args(
   z.string(), // level
-  z.any()     // message/args
+  z.any() // message/args
 ).returns(z.void()))
 
 export const CouchConfig = z.object({
@@ -22,4 +22,4 @@ export const CouchConfig = z.object({
   _normalizedLogger: z.any().optional() // Internal property for caching normalized logger
 }).passthrough().describe('The std config object')
 
-/** @typedef { z.infer<typeof CouchConfig> } CouchConfigSchema*/
+/** @typedef { z.infer<typeof CouchConfig> } CouchConfigSchema */

package/schema/crud.d.mts

@@ -35,6 +35,7 @@ export const CouchPut: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -59,6 +60,7 @@ export const CouchPut: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -83,6 +85,7 @@ export const CouchPut: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -165,6 +168,7 @@ export const CouchGet: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -189,6 +193,7 @@ export const CouchGet: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -213,6 +218,7 @@ export const CouchGet: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;

package/schema/crud.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAGA;;;;;;;;;iCAGgB;AAChB,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;GAME;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGsC;AACtC,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEsC;AACtC,qEAAqE;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAGyC;AACzC,2DAA2D;AAE3D;;;;;;;;;oCAEyC;6BA7B1B,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;6BAcxB,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;kCAKxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;6BAM7B,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;+BAKxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;kBArC1B,KAAK"}
+{"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAGA;;;;;;;;;iCAGgB;AAChB,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;GAME;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGsC;AACtC,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEsC;AACtC,qEAAqE;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAGyC;AACzC,2DAA2D;AAE3D;;;;;;;;;oCAEyC;6BA7B1B,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;6BAcxB,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;kCAKxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;6BAM7B,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;+BAKxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;kBArC1B,KAAK"}

package/schema/patch.d.mts

@@ -6,6 +6,7 @@ export const Patch: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -30,6 +31,7 @@ export const Patch: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -54,6 +56,7 @@ export const Patch: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;

package/schema/patch.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAIA,iEAA4D;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMuC;AACvC,qDAAqD;AAErD;;;;;;;;;;;;;;;;;;KAKuC;0BAPxB,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC;+BAQrB,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC;kBArBvB,KAAK"}
+{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAIA,iEAA4D;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMuC;AACvC,qDAAqD;AAErD;;;;;;;;;;;;;;;;;;KAKuC;0BAPxB,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC;+BAQrB,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC;kBArBvB,KAAK"}

package/schema/query.d.mts

@@ -112,6 +112,7 @@ export const SimpleViewQuery: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -136,6 +137,7 @@ export const SimpleViewQuery: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -160,6 +162,7 @@ export const SimpleViewQuery: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;

package/schema/query.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.mts","sourceRoot":"","sources":["query.mjs"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAKE;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGgB;AAChB,yFAAyF;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWuC;AACvC,6EAA6E;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAI6C;AAC7C,yEAAyE;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAG6C;4CA1B9B,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC;sCAcvC,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC;oCAOjC,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC;yCAM/B,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC;kBAxCjC,KAAK"}
+{"version":3,"file":"query.d.mts","sourceRoot":"","sources":["query.mjs"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAKE;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGgB;AAChB,yFAAyF;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWuC;AACvC,6EAA6E;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAI6C;AAC7C,yEAAyE;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAG6C;4CA1B9B,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC;sCAcvC,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC;oCAOjC,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC;yCAM/B,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC;kBAxCjC,KAAK"}

package/schema/query.mjs

@@ -9,7 +9,7 @@ export const ViewRow = z.object({
 })
 export const SimpleViewQueryResponse = z.object({
   error: z.string().optional().describe('if something is wrong'),
-  rows: z.array(ViewRow),
+  rows: z.array(ViewRow)
 }).passthrough()
 /** @typedef { z.infer<typeof SimpleViewQueryResponse> } SimpleViewQueryResponseSchema */
 

package/schema/stream.d.mts

@@ -13,7 +13,7 @@ export const OnRow: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     key?: any;
     value?: any;
     doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-}>], z.ZodUnknown>, z.ZodUndefined>;
+}>], z.ZodUnknown>, z.ZodUnknown>;
 /** @typedef { z.infer<typeof OnRow> } OnRowSchema */
 export const SimpleViewQueryStream: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -22,6 +22,7 @@ export const SimpleViewQueryStream: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -46,6 +47,7 @@ export const SimpleViewQueryStream: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -70,6 +72,7 @@ export const SimpleViewQueryStream: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
         warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
@@ -135,7 +138,7 @@ export const SimpleViewQueryStream: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     key?: any;
     value?: any;
     doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-}>], z.ZodUnknown>, z.ZodUndefined>], z.ZodUnknown>, z.ZodPromise<z.ZodUndefined>>;
+}>], z.ZodUnknown>, z.ZodUnknown>], z.ZodUnknown>, z.ZodPromise<z.ZodUndefined>>;
 /** @typedef { z.infer<typeof SimpleViewQueryStream> } SimpleViewQueryStreamSchema */
 export const SimpleViewQueryStreamBound: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
     startkey: z.ZodOptional<z.ZodAny>;
@@ -185,7 +188,7 @@ export const SimpleViewQueryStreamBound: z.ZodFunction<z.ZodTuple<[z.ZodString,
     key?: any;
     value?: any;
     doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-}>], z.ZodUnknown>, z.ZodUndefined>], z.ZodUnknown>, z.ZodPromise<z.ZodUndefined>>;
+}>], z.ZodUnknown>, z.ZodUnknown>], z.ZodUnknown>, z.ZodPromise<z.ZodUndefined>>;
 export type OnRowSchema = z.infer<typeof OnRow>;
 export type SimpleViewQueryStreamSchema = z.infer<typeof SimpleViewQueryStream>;
 export type SimpleViewQueryStreamBoundSchema = z.infer<typeof SimpleViewQueryStreamBound>;

package/schema/stream.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.mts","sourceRoot":"","sources":["stream.mjs"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;oCAEwB;AACxB,qDAAqD;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mFAKmC;AACnC,qFAAqF;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mFAImC;0BAdpB,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC;0CAQrB,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC;+CAOrC,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC;kBAtBvC,KAAK"}
+{"version":3,"file":"stream.d.mts","sourceRoot":"","sources":["stream.mjs"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;kCAEC;AACD,qDAAqD;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFAKmC;AACnC,qFAAqF;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFAImC;0BAdpB,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC;0CAQrB,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC;+CAOrC,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC;kBAtBvC,KAAK"}