hide-a-bed 3.0.1 → 4.0.1

package/impl/query.mjs

@@ -3,14 +3,21 @@
 import { z } from 'zod' // eslint-disable-line
 import needle from 'needle'
 import { SimpleViewQuery, SimpleViewQueryResponse } from '../schema/query.mjs' // eslint-disable-line
+import { RetryableError } from './errors.mjs'
+import { createLogger } from './logger.mjs'
 
 import pkg from 'lodash'
 const { includes } = pkg
 
 /** @type { z.infer<SimpleViewQuery> } query */
 export const query = SimpleViewQuery.implement(async (config, view, options) => {
+  const logger = createLogger(config)
+  logger.info(`Starting view query: ${view}`)
+  logger.debug('Query options:', options)
+
   // @ts-ignore
   const qs = queryString(options, ['key', 'startkey', 'endkey', 'reduce', 'group', 'group_level', 'stale', 'limit'])
+  logger.debug('Generated query string:', qs)
 
   const opts = {
     json: true,
@@ -20,10 +27,35 @@ export const query = SimpleViewQuery.implement(async (config, view, options) =>
   }
   const url = `${config.couch}/${view}?${qs.toString()}`
   // @ts-ignore
-  const results = await needle('get', url, opts)
+  let results
+  try {
+    logger.debug(`Sending GET request to: ${url}`)
+    results = await needle('get', url, opts)
+  } catch (err) {
+    logger.error('Network error during query:', err)
+    RetryableError.handleNetworkError(err)
+  }
+
+  if (!results) {
+    logger.error('No response received from query request')
+    throw new RetryableError('no response', 503)
+  }
+
   /** @type { z.infer<SimpleViewQueryResponse> } body */
   const body = results.body
-  if (body.error) throw new Error(body.error)
+  
+  if (RetryableError.isRetryableStatusCode(results.statusCode)) {
+    logger.warn(`Retryable status code received: ${results.statusCode}`)
+    throw new RetryableError(body.error || 'retryable error during query', results.statusCode)
+  }
+
+  if (body.error) {
+    logger.error(`Query error: ${body.error}`)
+    throw new Error(body.error)
+  }
+
+  logger.info(`Successfully executed view query: ${view}`)
+  logger.debug('Query response:', body)
   return body
 })
 
@@ -32,6 +64,10 @@ 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

@@ -0,0 +1,39 @@
+import { RetryableError } from './errors.mjs'
+import { sleep } from './patch.mjs'
+
+export function withRetry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    initialDelay = 1000, // 1 second
+    backoffFactor = 2    // exponential backoff multiplier
+  } = options
+
+  return async (...args) => {
+    let lastError
+    let delay = initialDelay
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn(...args)
+      } catch (error) {
+        lastError = error
+        
+        // Only retry if it's a RetryableError
+        if (!(error instanceof RetryableError)) {
+          throw error
+        }
+
+        // If we've used all retries, throw the last error
+        if (attempt === maxRetries) {
+          throw error
+        }
+
+        // Wait with exponential backoff
+        await sleep(delay)
+        delay *= backoffFactor
+      }
+    }
+
+    throw lastError
+  }
+}

package/impl/stream.mjs

@@ -1,29 +1,84 @@
 // @ts-check
-
 import needle from 'needle'
 import { queryString } from './query.mjs'
+import { RetryableError } from './errors.mjs'
+import { createLogger } from './logger.mjs'
 // @ts-ignore
 import JSONStream from 'JSONStream'
 
-/**
- * @param {any} config
- * @param {any} view
- * @param {any} options
- */
-export const queryStream = (config, view, options) => new Promise((resolve, reject) => {
+/** @type { import('../schema/stream.mjs').SimpleViewQueryStreamSchema } */
+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 { onRow, ...rest } = options
-  const qs = queryString(rest, ['key', 'startkey', 'endkey', 'reduce', 'group', 'group_level', 'stale', 'limit'])
+  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,
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    parse_response: false // Keep as stream
+  }
+
   const streamer = JSONStream.parse('rows.*')
-  streamer.on('data', onRow)
-  /**
-   * @param {any} err
-   */
-  streamer.on('end', (/** @type any */err) => {
-    if (err) return reject(err)
-    resolve(null) // all work should be done in the stream
+  
+  let rowCount = 0
+  streamer.on('data', 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
   })
-  needle.get(url).pipe(streamer)
+  
+  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
+    }
+    reject(err)
+  })
+
+  req.pipe(streamer)
+  
 })

package/index.mjs

@@ -1,26 +1,56 @@
+// @ts-check */
 import { bulkGet, bulkSave, bulkRemove } from './impl/bulk.mjs'
 import { get, put } from './impl/crud.mjs'
 import { patch } from './impl/patch.mjs'
 import { query } from './impl/query.mjs'
 import { queryStream } from './impl/stream.mjs'
-import { BulkSave, BulkGet } from './schema/bulk.mjs'
+import { withRetry } from './impl/retry.mjs'
+import { BulkSave, BulkGet, BulkRemove } from './schema/bulk.mjs'
 import { CouchConfig } from './schema/config.mjs'
 import { SimpleViewQuery, SimpleViewQueryResponse } from './schema/query.mjs'
-import { PatchConfig, Patch } from './schema/patch.mjs'
+import { SimpleViewQueryStream, OnRow } from './schema/stream.mjs'
+import { Patch } from './schema/patch.mjs'
 import { CouchDoc, CouchDocResponse, CouchPut, CouchGet } from './schema/crud.mjs'
+import { Bind } from './schema/bind.mjs'
 
 const schema = {
   CouchConfig,
   SimpleViewQuery,
   SimpleViewQueryResponse,
+  SimpleViewQueryStream,
+  OnRow,
   BulkSave,
   BulkGet,
+  BulkRemove,
   CouchGet,
   CouchPut,
   CouchDoc,
   CouchDocResponse,
-  PatchConfig,
   Patch
 }
 
-export { get, put, patch, bulkGet, bulkSave, bulkRemove, query, queryStream, schema }
+/** @type { import('./schema/bind.mjs').BindSchema } */
+const bindConfig = Bind.implement((
+  /** @type { import('./schema/config.mjs').CouchConfigSchema } */
+  config
+) => {
+  // Default retry options
+  const retryOptions = {
+    maxRetries: config.maxRetries ?? 10,
+    initialDelay: config.initialDelay ?? 1000,
+    backoffFactor: config.backoffFactor ?? 2
+  }
+
+  return {
+    get: config.bindWithRetry ? withRetry(get.bind(null, config), retryOptions) : get.bind(null, config),
+    put: config.bindWithRetry ? withRetry(put.bind(null, config), retryOptions) : put.bind(null, config),
+    patch: patch.bind(null, config), // patch not included in retry
+    bulkGet: config.bindWithRetry ? withRetry(bulkGet.bind(null, config), retryOptions) : bulkGet.bind(null, config),
+    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) 
+  }
+})
+
+export { get, put, patch, bulkGet, bulkSave, bulkRemove, query, queryStream, schema, bindConfig, withRetry }

package/package.json

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

package/schema/bind.mjs

@@ -0,0 +1,21 @@
+// @ts-check
+import { z } from 'zod'
+import { CouchConfig } from './config.mjs'
+import { BulkSaveBound, BulkGetBound } from './bulk.mjs'
+import { CouchGetBound, CouchPutBound } from './crud.mjs'
+import { PatchBound } from './patch.mjs'
+import { SimpleViewQueryBound } from './query.mjs'
+import { SimpleViewQueryStreamBound } from './stream.mjs'
+
+const BindReturns = z.object({
+  bulkGet: BulkGetBound,
+  bulkSave: BulkSaveBound,
+  get: CouchGetBound,
+  put: CouchPutBound,
+  patch: PatchBound,
+  query: SimpleViewQueryBound,
+  queryStream: SimpleViewQueryStreamBound
+})
+
+export const Bind = z.function().args(CouchConfig).returns(BindReturns)
+/** @typedef { z.infer<typeof Bind> } BindSchema */

package/schema/bulk.mjs

@@ -19,14 +19,31 @@ export const BulkSave = z.function().args(
 ).returns(z.promise(BulkSaveResponseSchema))
 /** @typedef { z.infer<typeof BulkSave> } BulkSaveSchema */
 
+export const BulkSaveBound = z.function().args(
+  z.array(z.object({
+    _id: z.string()
+  }).passthrough())
+).returns(z.promise(BulkSaveResponseSchema))
+/** @typedef { z.infer<typeof BulkSaveBound> } BulkSaveBoundSchema */
+
 export const BulkGet = z.function().args(
   CouchConfig,
   z.array(z.string().describe('the ids to get'))
 ).returns(z.promise(z.array(CouchDoc)))
 /** @typedef { z.infer<typeof BulkGet> } BulkGetSchema */
 
+export const BulkGetBound = z.function().args(
+  z.array(z.string().describe('the ids to get'))
+).returns(z.promise(z.array(CouchDoc)))
+/** @typedef { z.infer<typeof BulkGetBound> } BulkGetBoundSchema */
+
 export const BulkRemove = z.function().args(
   CouchConfig,
   z.array(z.string().describe('the ids to delete'))
 ).returns(z.promise(BulkSaveResponseSchema))
 /** @typedef { z.infer<typeof BulkRemove> } BulkRemoveSchema */
+
+export const BulkRemoveBound = z.function().args(
+  z.array(z.string().describe('the ids to delete'))
+).returns(z.promise(BulkSaveResponseSchema))
+/** @typedef { z.infer<typeof BulkRemoveBound> } BulkRemoveBoundSchema */

package/schema/config.mjs

@@ -1,4 +1,25 @@
 import { z } from 'zod'
+
+const LoggerSchema = z.object({
+  error: z.function().args(z.any()).returns(z.void()).optional(),
+  warn: z.function().args(z.any()).returns(z.void()).optional(),
+  info: z.function().args(z.any()).returns(z.void()).optional(),
+  debug: z.function().args(z.any()).returns(z.void()).optional()
+}).or(z.function().args(
+  z.string(), // level
+  z.any()     // message/args
+).returns(z.void()))
+
 export const CouchConfig = z.object({
-  couch: z.string().describe('the url of the couch db')
+  throwOnGetNotFound: z.boolean().optional().default(false).describe('if a get is 404 should we throw or return undefined'),
+  couch: z.string().describe('the url of the couch db'),
+  bindWithRetry: z.boolean().optional().default(true).describe('should we bind with retry'),
+  maxRetries: z.number().optional().default(3).describe('maximum number of retry attempts'),
+  initialDelay: z.number().optional().default(1000).describe('initial retry delay in milliseconds'),
+  backoffFactor: z.number().optional().default(2).describe('multiplier for exponential backoff'),
+  useConsoleLogger: 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: z.any().optional() // Internal property for caching normalized logger
 }).passthrough().describe('The std config object')
+
+/** @typedef { z.infer<typeof CouchConfig> } CouchConfigSchema*/

package/schema/crud.mjs

@@ -19,8 +19,20 @@ export const CouchPut = z.function().args(
   CouchConfig,
   CouchDoc
 ).returns(z.promise(CouchDocResponse))
+/** @typedef { z.infer<typeof CouchPut> } CouchPutSchema */
+
+export const CouchPutBound = z.function().args(
+  CouchDoc
+).returns(z.promise(CouchDocResponse))
+/** @typedef { z.infer<typeof CouchPutBound> } CouchPutBoundSchema */
 
 export const CouchGet = z.function().args(
   CouchConfig,
   z.string().describe('the couch doc id')
 ).returns(z.promise(CouchDoc.nullable()))
+/** @typedef { z.infer<typeof CouchGet> } CouchGetSchema */
+
+export const CouchGetBound = z.function().args(
+  z.string().describe('the couch doc id')
+).returns(z.promise(CouchDoc.nullable()))
+/** @typedef { z.infer<typeof CouchGetBound> } CouchBoundSchema */

package/schema/patch.mjs

@@ -2,17 +2,21 @@ import { z } from 'zod'
 import { CouchConfig } from './config.mjs'
 import { CouchDocResponse } from './crud.mjs'
 
-export const PatchConfig = CouchConfig.extend({
-  retries: z.number().min(0).max(100).optional(),
-  delay: z.number().min(0).optional()
-})
-
 export const PatchProperties = z.record(z.string(), z.any())
 
 export const Patch = z.function()
   .args(
-    PatchConfig,
+    CouchConfig,
+    z.string().describe('the couch doc id'),
+    PatchProperties
+  )
+  .returns(z.promise(CouchDocResponse))
+/** @typedef { z.infer<typeof Patch> } PatchSchema */
+
+export const PatchBound = z.function()
+  .args(
     z.string().describe('the couch doc id'),
     PatchProperties
   )
   .returns(z.promise(CouchDocResponse))
+/** @typedef { z.infer<typeof PatchBound> } PatchBoundSchema */

package/schema/query.mjs

@@ -1,29 +1,41 @@
 import { z } from 'zod'
 import { CouchConfig } from './config.mjs'
 
+export const ViewRow = z.object({
+  id: z.string().optional(),
+  key: z.any().nullable(),
+  value: z.any().nullable(),
+  doc: z.object({}).passthrough().optional()
+})
 export const SimpleViewQueryResponse = z.object({
   error: z.string().optional().describe('if something is wrong'),
-  rows: z.array(z.object({
-    id: z.string().optional(),
-    key: z.any().nullable(),
-    value: z.any().nullable(),
-    doc: z.object({}).passthrough().optional()
-  }))
+  rows: z.array(ViewRow),
 }).passthrough()
+/** @typedef { z.infer<typeof SimpleViewQueryResponse> } SimpleViewQueryResponseSchema */
+
+export const SimpleViewOptions = z.object({
+  startkey: z.any().optional(),
+  endkey: z.any().optional(),
+  descending: z.boolean().optional().describe('sort results descending'),
+  skip: z.number().positive().optional().describe('skip this many rows'),
+  limit: z.number().positive().optional().describe('limit the results to this many rows'),
+  key: z.any().optional(),
+  include_docs: z.boolean().optional().describe('join the id to the doc and return it'),
+  reduce: z.boolean().optional().describe('reduce the results'),
+  group: z.boolean().optional().describe('group the results'),
+  group_level: z.number().positive().optional().describe('group the results at this level')
+}).optional().describe('query options')
+/** @typedef { z.infer<typeof SimpleViewOptions> } SimpleViewOptionsSchema */
 
 export const SimpleViewQuery = z.function().args(
   CouchConfig,
   z.string().describe('the view name'),
-  z.object({
-    startkey: z.any().optional(),
-    endkey: z.any().optional(),
-    descending: z.boolean().optional().describe('sort results descending'),
-    skip: z.number().positive().optional().describe('skip this many rows'),
-    limit: z.number().positive().optional().describe('limit the results to this many rows'),
-    key: z.any().optional(),
-    include_docs: z.boolean().optional().describe('join the id to the doc and return it'),
-    reduce: z.boolean().optional().describe('reduce the results'),
-    group: z.boolean().optional().describe('group the results'),
-    group_level: z.number().positive().optional().describe('group the results at this level')
-  }).optional().describe('query options')
+  SimpleViewOptions
+).returns(z.promise(SimpleViewQueryResponse))
+/** @typedef { z.infer<typeof SimpleViewQuery> } SimpleViewQuerySchema */
+
+export const SimpleViewQueryBound = z.function().args(
+  z.string().describe('the view name'),
+  SimpleViewOptions
 ).returns(z.promise(SimpleViewQueryResponse))
+/** @typedef { z.infer<typeof SimpleViewQueryBound> } SimpleViewQueryBoundSchema */

package/schema/stream.mjs

@@ -0,0 +1,23 @@
+import { z } from 'zod'
+import { CouchConfig } from './config.mjs'
+import { SimpleViewOptions, ViewRow } from './query.mjs'
+
+export const OnRow = z.function().args(
+  ViewRow
+)
+/** @typedef { z.infer<typeof OnRow> } OnRowSchema */
+
+export const SimpleViewQueryStream = z.function().args(
+  CouchConfig,
+  z.string().describe('the view name'),
+  SimpleViewOptions,
+  OnRow
+).returns(z.promise(z.undefined()))
+/** @typedef { z.infer<typeof SimpleViewQueryStream> } SimpleViewQueryStreamSchema */
+
+export const SimpleViewQueryStreamBound = z.function().args(
+  z.string().describe('the view name'),
+  SimpleViewOptions,
+  OnRow
+).returns(z.promise(z.undefined()))
+/** @typedef { z.infer<typeof SimpleViewQueryStreamBound> } SimpleViewQueryStreamBoundSchema */

package/build/build.mjs

@@ -1,16 +0,0 @@
-import esbuild from 'esbuild'
-import { globSync } from 'glob'
-import { RewriteImportsPlugin } from './build.rewrite-imports.mjs'
-
-esbuild
-  .build({
-    entryPoints: globSync('./**/*.mjs', {
-      ignore: ['./node_modules/**/*', './tests/**/*', './build/**/*']
-    }),
-    outdir: 'cjs',
-    format: 'cjs',
-    outExtension: { '.js': '.cjs' },
-    bundle: false,
-    plugins: [new RewriteImportsPlugin()]
-  })
-  .catch(() => process.exit(1))

package/build/build.rewrite-imports.mjs

@@ -1,14 +0,0 @@
-import fs from 'fs'
-
-export class RewriteImportsPlugin {
-  name = 'rewrite-imports'
-
-  setup (build) {
-    build.onLoad({ filter: /\.mjs$/ }, async (args) => {
-      const contents = fs
-        .readFileSync(args.path, 'utf8')
-        .replace(/(from\s+['"].*?)\.mjs(['"])/g, '$1.cjs$2')
-      return { contents, loader: 'js' }
-    })
-  }
-}

package/impl/bulk.d.mts

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

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

package/impl/crud.d.mts

@@ -1,10 +0,0 @@
-export const get: (args_0: import("zod").objectInputType<{
-    couch: import("zod").ZodString;
-}, import("zod").ZodTypeAny, "passthrough">, args_1: string, ...args: unknown[]) => Promise<any>;
-export const put: (args_0: import("zod").objectInputType<{
-    couch: import("zod").ZodString;
-}, import("zod").ZodTypeAny, "passthrough">, args_1: import("zod").objectInputType<{
-    _id: import("zod").ZodString;
-    _rev: import("zod").ZodOptional<import("zod").ZodString>;
-}, import("zod").ZodTypeAny, "passthrough">, ...args: unknown[]) => Promise<any>;
-//# sourceMappingURL=crud.d.mts.map

package/impl/crud.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAWA;;iGAOE;AAEF;;;;;iFAWE"}

package/impl/patch.d.mts

@@ -1,2 +0,0 @@
-export const patch: any;
-//# sourceMappingURL=patch.d.mts.map

package/impl/patch.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAKA,wBA8BE"}