hide-a-bed 3.0.0 → 4.0.0

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

@@ -18,21 +18,21 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var patch_exports = {};
 __export(patch_exports, {
-  CouchPatch: () => CouchPatch,
-  PatchConfig: () => PatchConfig,
+  Patch: () => Patch,
+  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 CouchPatch = import_zod.z.function().args(
-  PatchConfig,
+const Patch = import_zod.z.function().args(
+  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.d.mts

@@ -0,0 +1,7 @@
+/** @type { import('../schema/bulk.mjs').BulkSaveSchema } */
+export const bulkSave: import("../schema/bulk.mjs").BulkSaveSchema;
+/** @type { import('../schema/bulk.mjs').BulkGetSchema } */
+export const bulkGet: import("../schema/bulk.mjs").BulkGetSchema;
+/** @type { import('../schema/bulk.mjs').BulkRemoveSchema } */
+export const bulkRemove: import("../schema/bulk.mjs").BulkRemoveSchema;
+//# sourceMappingURL=bulk.d.mts.map

package/impl/bulk.d.mts.map

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

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.d.mts

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

package/impl/crud.d.mts.map

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

package/impl/crud.mjs

@@ -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.d.mts

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

package/impl/errors.d.mts.map

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

package/impl/errors.mjs

@@ -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.d.mts

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

package/impl/logger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.mts","sourceRoot":"","sources":["logger.mjs"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,qCAHW,OAAO,sBAAsB,EAAE,iBAAiB,GAC9C,MAAM,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"}