hide-a-bed 3.0.1 → 4.0.1

package/cjs/schema/bind.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bind_exports = {};
+__export(bind_exports, {
+  Bind: () => Bind
+});
+module.exports = __toCommonJS(bind_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+var import_bulk = require("./bulk.cjs");
+var import_crud = require("./crud.cjs");
+var import_patch = require("./patch.cjs");
+var import_query = require("./query.cjs");
+var import_stream = require("./stream.cjs");
+const BindReturns = import_zod.z.object({
+  bulkGet: import_bulk.BulkGetBound,
+  bulkSave: import_bulk.BulkSaveBound,
+  get: import_crud.CouchGetBound,
+  put: import_crud.CouchPutBound,
+  patch: import_patch.PatchBound,
+  query: import_query.SimpleViewQueryBound,
+  queryStream: import_stream.SimpleViewQueryStreamBound
+});
+const Bind = import_zod.z.function().args(import_config.CouchConfig).returns(BindReturns);

package/cjs/schema/bulk.cjs

@@ -19,8 +19,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var bulk_exports = {};
 __export(bulk_exports, {
   BulkGet: () => BulkGet,
+  BulkGetBound: () => BulkGetBound,
   BulkRemove: () => BulkRemove,
+  BulkRemoveBound: () => BulkRemoveBound,
   BulkSave: () => BulkSave,
+  BulkSaveBound: () => BulkSaveBound,
   BulkSaveResponseSchema: () => BulkSaveResponseSchema
 });
 module.exports = __toCommonJS(bulk_exports);
@@ -40,11 +43,22 @@ const BulkSave = import_zod.z.function().args(
     _id: import_zod.z.string()
   }).passthrough())
 ).returns(import_zod.z.promise(BulkSaveResponseSchema));
+const BulkSaveBound = import_zod.z.function().args(
+  import_zod.z.array(import_zod.z.object({
+    _id: import_zod.z.string()
+  }).passthrough())
+).returns(import_zod.z.promise(BulkSaveResponseSchema));
 const BulkGet = import_zod.z.function().args(
   import_config.CouchConfig,
   import_zod.z.array(import_zod.z.string().describe("the ids to get"))
 ).returns(import_zod.z.promise(import_zod.z.array(import_crud.CouchDoc)));
+const BulkGetBound = import_zod.z.function().args(
+  import_zod.z.array(import_zod.z.string().describe("the ids to get"))
+).returns(import_zod.z.promise(import_zod.z.array(import_crud.CouchDoc)));
 const BulkRemove = import_zod.z.function().args(
   import_config.CouchConfig,
   import_zod.z.array(import_zod.z.string().describe("the ids to delete"))
 ).returns(import_zod.z.promise(BulkSaveResponseSchema));
+const BulkRemoveBound = import_zod.z.function().args(
+  import_zod.z.array(import_zod.z.string().describe("the ids to delete"))
+).returns(import_zod.z.promise(BulkSaveResponseSchema));

package/cjs/schema/config.cjs

@@ -22,6 +22,25 @@ __export(config_exports, {
 });
 module.exports = __toCommonJS(config_exports);
 var import_zod = require("zod");
+const LoggerSchema = import_zod.z.object({
+  error: import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()).optional(),
+  warn: import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()).optional(),
+  info: import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()).optional(),
+  debug: import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()).optional()
+}).or(import_zod.z.function().args(
+  import_zod.z.string(),
+  // level
+  import_zod.z.any()
+  // message/args
+).returns(import_zod.z.void()));
 const CouchConfig = import_zod.z.object({
-  couch: import_zod.z.string().describe("the url of the couch db")
+  throwOnGetNotFound: import_zod.z.boolean().optional().default(false).describe("if a get is 404 should we throw or return undefined"),
+  couch: import_zod.z.string().describe("the url of the couch db"),
+  bindWithRetry: import_zod.z.boolean().optional().default(true).describe("should we bind with retry"),
+  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"),
+  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
 }).passthrough().describe("The std config object");

package/cjs/schema/crud.cjs

@@ -21,7 +21,9 @@ __export(crud_exports, {
   CouchDoc: () => CouchDoc,
   CouchDocResponse: () => CouchDocResponse,
   CouchGet: () => CouchGet,
-  CouchPut: () => CouchPut
+  CouchGetBound: () => CouchGetBound,
+  CouchPut: () => CouchPut,
+  CouchPutBound: () => CouchPutBound
 });
 module.exports = __toCommonJS(crud_exports);
 var import_zod = require("zod");
@@ -41,7 +43,13 @@ const CouchPut = import_zod.z.function().args(
   import_config.CouchConfig,
   CouchDoc
 ).returns(import_zod.z.promise(CouchDocResponse));
+const CouchPutBound = import_zod.z.function().args(
+  CouchDoc
+).returns(import_zod.z.promise(CouchDocResponse));
 const CouchGet = import_zod.z.function().args(
   import_config.CouchConfig,
   import_zod.z.string().describe("the couch doc id")
 ).returns(import_zod.z.promise(CouchDoc.nullable()));
+const CouchGetBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the couch doc id")
+).returns(import_zod.z.promise(CouchDoc.nullable()));

package/cjs/schema/patch.cjs

@@ -19,20 +19,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var patch_exports = {};
 __export(patch_exports, {
   Patch: () => Patch,
-  PatchConfig: () => PatchConfig,
+  PatchBound: () => PatchBound,
   PatchProperties: () => PatchProperties
 });
 module.exports = __toCommonJS(patch_exports);
 var import_zod = require("zod");
 var import_config = require("./config.cjs");
 var import_crud = require("./crud.cjs");
-const PatchConfig = import_config.CouchConfig.extend({
-  retries: import_zod.z.number().min(0).max(100).optional(),
-  delay: import_zod.z.number().min(0).optional()
-});
 const PatchProperties = import_zod.z.record(import_zod.z.string(), import_zod.z.any());
 const Patch = import_zod.z.function().args(
-  PatchConfig,
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the couch doc id"),
+  PatchProperties
+).returns(import_zod.z.promise(import_crud.CouchDocResponse));
+const PatchBound = import_zod.z.function().args(
   import_zod.z.string().describe("the couch doc id"),
   PatchProperties
 ).returns(import_zod.z.promise(import_crud.CouchDocResponse));

package/cjs/schema/query.cjs

@@ -18,34 +18,43 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var query_exports = {};
 __export(query_exports, {
+  SimpleViewOptions: () => SimpleViewOptions,
   SimpleViewQuery: () => SimpleViewQuery,
-  SimpleViewQueryResponse: () => SimpleViewQueryResponse
+  SimpleViewQueryBound: () => SimpleViewQueryBound,
+  SimpleViewQueryResponse: () => SimpleViewQueryResponse,
+  ViewRow: () => ViewRow
 });
 module.exports = __toCommonJS(query_exports);
 var import_zod = require("zod");
 var import_config = require("./config.cjs");
+const ViewRow = import_zod.z.object({
+  id: import_zod.z.string().optional(),
+  key: import_zod.z.any().nullable(),
+  value: import_zod.z.any().nullable(),
+  doc: import_zod.z.object({}).passthrough().optional()
+});
 const SimpleViewQueryResponse = import_zod.z.object({
   error: import_zod.z.string().optional().describe("if something is wrong"),
-  rows: import_zod.z.array(import_zod.z.object({
-    id: import_zod.z.string().optional(),
-    key: import_zod.z.any().nullable(),
-    value: import_zod.z.any().nullable(),
-    doc: import_zod.z.object({}).passthrough().optional()
-  }))
+  rows: import_zod.z.array(ViewRow)
 }).passthrough();
+const SimpleViewOptions = import_zod.z.object({
+  startkey: import_zod.z.any().optional(),
+  endkey: import_zod.z.any().optional(),
+  descending: import_zod.z.boolean().optional().describe("sort results descending"),
+  skip: import_zod.z.number().positive().optional().describe("skip this many rows"),
+  limit: import_zod.z.number().positive().optional().describe("limit the results to this many rows"),
+  key: import_zod.z.any().optional(),
+  include_docs: import_zod.z.boolean().optional().describe("join the id to the doc and return it"),
+  reduce: import_zod.z.boolean().optional().describe("reduce the results"),
+  group: import_zod.z.boolean().optional().describe("group the results"),
+  group_level: import_zod.z.number().positive().optional().describe("group the results at this level")
+}).optional().describe("query options");
 const SimpleViewQuery = import_zod.z.function().args(
   import_config.CouchConfig,
   import_zod.z.string().describe("the view name"),
-  import_zod.z.object({
-    startkey: import_zod.z.any().optional(),
-    endkey: import_zod.z.any().optional(),
-    descending: import_zod.z.boolean().optional().describe("sort results descending"),
-    skip: import_zod.z.number().positive().optional().describe("skip this many rows"),
-    limit: import_zod.z.number().positive().optional().describe("limit the results to this many rows"),
-    key: import_zod.z.any().optional(),
-    include_docs: import_zod.z.boolean().optional().describe("join the id to the doc and return it"),
-    reduce: import_zod.z.boolean().optional().describe("reduce the results"),
-    group: import_zod.z.boolean().optional().describe("group the results"),
-    group_level: import_zod.z.number().positive().optional().describe("group the results at this level")
-  }).optional().describe("query options")
+  SimpleViewOptions
+).returns(import_zod.z.promise(SimpleViewQueryResponse));
+const SimpleViewQueryBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the view name"),
+  SimpleViewOptions
 ).returns(import_zod.z.promise(SimpleViewQueryResponse));

package/cjs/schema/stream.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stream_exports = {};
+__export(stream_exports, {
+  OnRow: () => OnRow,
+  SimpleViewQueryStream: () => SimpleViewQueryStream,
+  SimpleViewQueryStreamBound: () => SimpleViewQueryStreamBound
+});
+module.exports = __toCommonJS(stream_exports);
+var import_zod = require("zod");
+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"),
+  import_query.SimpleViewOptions,
+  OnRow
+).returns(import_zod.z.promise(import_zod.z.undefined()));
+const SimpleViewQueryStreamBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the view name"),
+  import_query.SimpleViewOptions,
+  OnRow
+).returns(import_zod.z.promise(import_zod.z.undefined()));

package/impl/bulk.mjs

@@ -1,6 +1,8 @@
 // @ts-check
 import needle from 'needle'
 import { BulkSave, BulkGet, BulkRemove } from '../schema/bulk.mjs'
+import { RetryableError } from './errors.mjs'
+import { createLogger } from './logger.mjs'
 
 const opts = {
   json: true,
@@ -11,24 +13,71 @@ const opts = {
 
 /** @type { import('../schema/bulk.mjs').BulkSaveSchema } */
 export const bulkSave = BulkSave.implement(async (config, docs) => {
-  if (!docs) return { ok: false, error: 'noDocs', reason: 'no docs provided' }
-  if (!docs.length) return { ok: false, error: 'noDocs', reason: 'no docs provided' }
+  /** @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' }
+  }
+  if (!docs.length) {
+    logger.warn('bulkSave called with empty docs array')
+    return { ok: false, error: 'noDocs', reason: 'no docs provided' }
+  }
 
+  logger.info(`Starting bulk save of ${docs.length} documents`)
   const url = `${config.couch}/_bulk_docs`
   const body = { docs }
-  const resp = await needle('post', url, body, opts)
-  if (resp.statusCode !== 201) throw new Error('could not save')
+  let resp
+  try {
+    resp = await needle('post', url, body, opts)
+  } catch (err) {
+    logger.error('Network error during bulk save:', err)
+    RetryableError.handleNetworkError(err)
+  }
+  if (!resp) {
+    logger.error('No response received from bulk save request')
+    throw new RetryableError('no response', 503)
+  }
+  if (RetryableError.isRetryableStatusCode(resp.statusCode)) {
+    logger.warn(`Retryable status code received: ${resp.statusCode}`)
+    throw new RetryableError('retryable error during bulk save', resp.statusCode)
+  }
+  if (resp.statusCode !== 201) {
+    logger.error(`Unexpected status code: ${resp.statusCode}`)
+    throw new Error('could not save')
+  }
   const results = resp?.body || []
   return results
 })
 
 /** @type { import('../schema/bulk.mjs').BulkGetSchema } */
 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 }
-  const resp = await needle('post', url, body, opts)
-  if (resp.statusCode !== 200) throw new Error('could not fetch')
+  let resp
+  try {
+    resp = await needle('post', url, body, opts)
+  } catch (err) {
+    logger.error('Network error during bulk get:', err)
+    RetryableError.handleNetworkError(err)
+  }
+  if (!resp) {
+    logger.error('No response received from bulk get request')
+    throw new RetryableError('no response', 503)
+  }
+  if (RetryableError.isRetryableStatusCode(resp.statusCode)) {
+    logger.warn(`Retryable status code received: ${resp.statusCode}`)
+    throw new RetryableError('retryable error during bulk get', resp.statusCode)
+  }
+  if (resp.statusCode !== 200) {
+    logger.error(`Unexpected status code: ${resp.statusCode}`)
+    throw new Error('could not fetch')
+  }
   const rows = resp?.body?.rows || []
   /** @type {Array<import('../schema/crud.mjs').CouchDocSchema>} */
   const docs = []
@@ -42,11 +91,14 @@ export const bulkGet = BulkGet.implement(async (config, ids) => {
     const doc = r.doc
     docs.push(doc)
   })
+  logger.info(`Successfully retrieved ${docs.length} documents`)
   return docs
 })
 
 /** @type { import('../schema/bulk.mjs').BulkRemoveSchema } */
 export const bulkRemove = BulkRemove.implement(async (config, ids) => {
+  const logger = createLogger(config)
+  logger.info(`Starting bulk remove for ${ids.length} documents`)
   const docs = await bulkGet(config, ids)
   docs.forEach(d => { d._deleted = true })
   return bulkSave(config, docs)

package/impl/crud.mjs

@@ -1,6 +1,8 @@
 // @ts-check
 import needle from 'needle'
 import { CouchGet, CouchPut } from '../schema/crud.mjs'
+import { RetryableError } from './errors.mjs'
+import { createLogger } from './logger.mjs'
 
 const opts = {
   json: true,
@@ -9,24 +11,83 @@ const opts = {
   }
 }
 
+/** @type { import('../schema/crud.mjs').CouchGetSchema } */
 export const get = CouchGet.implement(async (config, id) => {
+  const logger = createLogger(config)
   const url = `${config.couch}/${id}`
-  const resp = await needle('get', url, opts)
-  if (resp.statusCode === 404) return null
-  const result = resp?.body || {}
-  if (resp.statusCode !== 200) { throw new Error(result.reason || 'failed') }
-  return result
+  logger.info(`Getting document with id: ${id}`)
+  
+  try {
+    const resp = await needle('get', url, opts)
+    if (!resp) {
+      logger.error('No response received from get request')
+      throw new RetryableError('no response', 503)
+    }
+    if (resp.statusCode === 404) {
+      logger.debug(`Document not found: ${id}`)
+      return null
+    }
+    const result = resp?.body || {}
+    if (resp.statusCode === 404) {
+      if (config.throwOnGetNotFound) {
+        logger.warn(`Document not found (throwing error): ${id}`)
+        throw new Error(result.reason || 'not_found')
+      } else {
+        logger.debug(`Document not found (returning undefined): ${id}`)
+        return undefined
+      }
+    }
+    if (RetryableError.isRetryableStatusCode(resp.statusCode)) {
+      logger.warn(`Retryable status code received: ${resp.statusCode}`)
+      throw new RetryableError(result.reason || 'retryable error', resp.statusCode)
+    }
+    if (resp.statusCode !== 200) {
+      logger.error(`Unexpected status code: ${resp.statusCode}`)
+      throw new Error(result.reason || 'failed')
+    }
+    logger.info(`Successfully retrieved document: ${id}`)
+    return result
+  } catch (err) {
+    logger.error('Error during get operation:', err)
+    RetryableError.handleNetworkError(err)
+  }
 })
 
+/** @type { import('../schema/crud.mjs').CouchPutSchema } */
 export const put = CouchPut.implement(async (config, doc) => {
+  const logger = createLogger(config)
   const url = `${config.couch}/${doc._id}`
   const body = doc
-  const resp = await needle('put', url, body, opts)
+  
+  logger.info(`Putting document with id: ${doc._id}`)
+  let resp
+  try {
+    resp = await needle('put', url, body, opts)
+  } catch (err) {
+    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

@@ -0,0 +1,53 @@
+// @ts-check
+
+/**
+ * @typedef {Object} NetworkError
+ * @property {string} code - The error code
+ * @property {string} [message] - Optional error message
+ */
+
+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;
+  }
+
+  /**
+   * @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);
+  }
+
+  /**
+   * @param {NetworkError | unknown} err - The network error to handle
+   * @throws {RetryableError} If the error is retryable
+   * @throws {Error} If the error is not retryable
+   */
+  static handleNetworkError(err) {
+    /** @type {Record<string, number>} */
+    const networkErrors = {
+      ECONNREFUSED: 503,
+      ECONNRESET: 503,
+      ETIMEDOUT: 503,
+      ENETUNREACH: 503,
+      ENOTFOUND: 503,
+      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 err;
+  }
+}

package/impl/logger.mjs

@@ -0,0 +1,59 @@
+/**
+ * @typedef {Object} Logger
+ * @property {(...args: any[]) => void} error - Log error messages
+ * @property {(...args: any[]) => void} warn - Log warning messages
+ * @property {(...args: any[]) => void} info - Log info messages
+ * @property {(...args: any[]) => void} debug - Log debug messages
+ */
+
+/**
+ * Creates a unified logger interface that works with both function and object-style loggers
+ * @param {import('../schema/config.mjs').CouchConfigSchema} config
+ * @returns {Logger} Normalized logger interface
+ */
+export function createLogger(config) {
+  // Return cached logger if it exists
+  if (config._normalizedLogger) {
+    return config._normalizedLogger
+  }
+
+  // If no logger provided, use console if useConsoleLogger is set, otherwise return no-op logger
+  if (!config.logger) {
+    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 logger is a function, wrap it to provide object interface
+  if (typeof config.logger === 'function') {
+    config._normalizedLogger = {
+      error: (...args) => config.logger('error', ...args),
+      warn: (...args) => config.logger('warn', ...args),
+      info: (...args) => config.logger('info', ...args),
+      debug: (...args) => config.logger('debug', ...args)
+    }
+    return config._normalizedLogger
+  }
+
+  // If logger is an object, use its methods or provide no-ops for missing ones
+  config._normalizedLogger = {
+    error: config.logger.error || (() => {}),
+    warn: config.logger.warn || (() => {}),
+    info: config.logger.info || (() => {}),
+    debug: config.logger.debug || (() => {})
+  }
+  return config._normalizedLogger
+}

package/impl/patch.mjs

@@ -1,36 +1,68 @@
 import { get, put } from './crud.mjs'
 import { Patch } from '../schema/patch.mjs'
+import { createLogger } from './logger.mjs'
 
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+export const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
 
+/** @type { import('../schema/patch.mjs').PatchSchema } */
 export const patch = Patch.implement(async (config, id, properties) => {
-  const maxRetries = config.retries || 5
-  const delay = config.delay || 1000
+  const logger = createLogger(config)
+  const maxRetries = config.maxRetries || 5
+  let delay = config.initialDelay || 1000
   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 get(config, id)
+      if (!doc) {
+        logger.warn(`Document ${id} not found`)
+        return { ok: false, statusCode: 404, error: 'not_found' }
+      }
+      
       const updatedDoc = { ...doc, ...properties }
+      logger.debug('Merged document:', updatedDoc)
+      
       const result = await put(config, updatedDoc)
 
       // Check if the response indicates a conflict
       if (result.ok) {
+        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) {
-        throw new Error(`Failed to patch after ${maxRetries} attempts: ${err.message}`)
+        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`)
     }
   }
 })