hide-a-bed 4.0.1 → 4.0.3

package/impl/query.d.mts

@@ -0,0 +1,173 @@
+/**
+ * @param {{ [key: string]: any }} options - The options object containing query parameters.
+ * @param {string[]} params - The list of parameter names to include in the query string.
+ */
+export function queryString(options: {
+    [key: string]: any;
+}, params: string[]): string;
+/** @type { z.infer<SimpleViewQuery> } query */
+export const query: z.infer<z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    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>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    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>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    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>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, z.ZodTypeAny, "passthrough">>, z.ZodString, z.ZodOptional<z.ZodObject<{
+    startkey: z.ZodOptional<z.ZodAny>;
+    endkey: z.ZodOptional<z.ZodAny>;
+    descending: z.ZodOptional<z.ZodBoolean>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    key: z.ZodOptional<z.ZodAny>;
+    include_docs: z.ZodOptional<z.ZodBoolean>;
+    reduce: z.ZodOptional<z.ZodBoolean>;
+    group: z.ZodOptional<z.ZodBoolean>;
+    group_level: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    startkey?: any;
+    endkey?: any;
+    descending?: boolean | undefined;
+    skip?: number | undefined;
+    limit?: number | undefined;
+    key?: any;
+    include_docs?: boolean | undefined;
+    reduce?: boolean | undefined;
+    group?: boolean | undefined;
+    group_level?: number | undefined;
+}, {
+    startkey?: any;
+    endkey?: any;
+    descending?: boolean | undefined;
+    skip?: number | undefined;
+    limit?: number | undefined;
+    key?: any;
+    include_docs?: boolean | undefined;
+    reduce?: boolean | undefined;
+    group?: boolean | undefined;
+    group_level?: number | undefined;
+}>>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    }>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>>>>;
+import { z } from 'zod';
+//# sourceMappingURL=query.d.mts.map

package/impl/query.d.mts.map

@@ -0,0 +1 @@
+{"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.d.mts

@@ -0,0 +1,2 @@
+export function withRetry(fn: any, options?: {}): (...args: any[]) => Promise<any>;
+//# sourceMappingURL=retry.d.mts.map

package/impl/retry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.mts","sourceRoot":"","sources":["retry.mjs"],"names":[],"mappings":"AAGA,mFAmCC"}

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

@@ -0,0 +1,3 @@
+/** @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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,41 @@
+import { get } from './impl/crud.mjs';
+import { put } from './impl/crud.mjs';
+import { patch } from './impl/patch.mjs';
+import { bulkGet } from './impl/bulk.mjs';
+import { bulkSave } from './impl/bulk.mjs';
+import { bulkRemove } from './impl/bulk.mjs';
+import { query } from './impl/query.mjs';
+import { queryStream } from './impl/stream.mjs';
+export namespace schema {
+    export { CouchConfig };
+    export { SimpleViewQuery };
+    export { SimpleViewQueryResponse };
+    export { SimpleViewQueryStream };
+    export { OnRow };
+    export { BulkSave };
+    export { BulkGet };
+    export { BulkRemove };
+    export { CouchGet };
+    export { CouchPut };
+    export { CouchDoc };
+    export { CouchDocResponse };
+    export { Patch };
+}
+/** @type { import('./schema/bind.mjs').BindSchema } */
+export const bindConfig: import("./schema/bind.mjs").BindSchema;
+import { withRetry } from './impl/retry.mjs';
+import { CouchConfig } from './schema/config.mjs';
+import { SimpleViewQuery } from './schema/query.mjs';
+import { SimpleViewQueryResponse } from './schema/query.mjs';
+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';
+import { CouchDocResponse } from './schema/crud.mjs';
+import { Patch } from './schema/patch.mjs';
+export { get, put, patch, bulkGet, bulkSave, bulkRemove, query, queryStream, withRetry };
+//# sourceMappingURL=index.d.mts.map

package/index.d.mts.map

@@ -0,0 +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;;;;;;;;;;;;;;;;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

@@ -49,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.1",
+  "version": "4.0.3",
   "description": "An abstraction over couchdb calls that includes easy mock/stubs with pouchdb",
   "module": "index.mjs",
   "main": "cjs/index.cjs",