hide-a-bed 4.0.3 → 4.1.2

package/impl/bulk.d.mts

@@ -4,4 +4,8 @@ export const bulkSave: import("../schema/bulk.mjs").BulkSaveSchema;
 export const bulkGet: import("../schema/bulk.mjs").BulkGetSchema;
 /** @type { import('../schema/bulk.mjs').BulkRemoveSchema } */
 export const bulkRemove: import("../schema/bulk.mjs").BulkRemoveSchema;
+/** @type { import('../schema/bulk.mjs').BulkGetDictionarySchema } */
+export const bulkGetDictionary: import("../schema/bulk.mjs").BulkGetDictionarySchema;
+/** @type { import('../schema/bulk.mjs').BulkSaveTransactionSchema } bulkSaveTransaction */
+export const bulkSaveTransaction: import("../schema/bulk.mjs").BulkSaveTransactionSchema;
 //# sourceMappingURL=bulk.d.mts.map

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,CAkCpD;AAEF,8DAA8D;AAC9D,yBADY,OAAO,oBAAoB,EAAE,gBAAgB,CAOvD"}
+{"version":3,"file":"bulk.d.mts","sourceRoot":"","sources":["bulk.mjs"],"names":[],"mappings":"AAkBA,4DAA4D;AAC5D,uBADY,OAAO,oBAAoB,EAAE,cAAc,CAsCrD;AAEF,2DAA2D;AAC3D,sBADY,OAAO,oBAAoB,EAAE,aAAa,CA8BpD;AAIF,8DAA8D;AAC9D,yBADY,OAAO,oBAAoB,EAAE,gBAAgB,CAkBvD;AAEF,qEAAqE;AACrE,gCADY,OAAO,oBAAoB,EAAE,uBAAuB,CAwB9D;AAEF,2FAA2F;AAC3F,kCADY,OAAO,oBAAoB,EAAE,yBAAyB,CAiJhE"}

package/impl/bulk.mjs

@@ -1,8 +1,13 @@
 // @ts-check
 import needle from 'needle'
-import { BulkSave, BulkGet, BulkRemove } from '../schema/bulk.mjs'
+import { BulkSave, BulkGet, BulkRemove, BulkGetDictionary, BulkSaveTransaction } from '../schema/bulk.mjs'
+import { withRetry } from './retry.mjs'
+import { put } from './crud.mjs'
 import { RetryableError } from './errors.mjs'
+import { TransactionSetupError, TransactionVersionConflictError, TransactionBulkOperationError, TransactionRollbackError } from './transactionErrors.mjs'
 import { createLogger } from './logger.mjs'
+import { CouchDoc } from '../schema/crud.mjs'
+import { setupEmitter } from './trackedEmitter.mjs'
 
 const opts = {
   json: true,
@@ -58,10 +63,10 @@ export const bulkGet = BulkGet.implement(async (config, ids) => {
 
   logger.info(`Starting bulk get for ${keys.length} documents`)
   const url = `${config.couch}/_all_docs?include_docs=true`
-  const body = { keys }
+  const payload = { keys }
   let resp
   try {
-    resp = await needle('post', url, body, opts)
+    resp = await needle('post', url, payload, opts)
   } catch (err) {
     logger.error('Network error during bulk get:', err)
     RetryableError.handleNetworkError(err)
@@ -78,20 +83,202 @@ export const bulkGet = BulkGet.implement(async (config, ids) => {
     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 = rows.map((
-    /** @type {{ error?: any, key?: string, doc?: import('../schema/crud.mjs').CouchDocSchema }} */ r
-  ) => r.doc)
-  logger.info(`Successfully retrieved ${docs.length} documents`)
-  return docs
+  /** @type { import('../schema/query.mjs').SimpleViewQueryResponseSchema } body */
+  const body = resp.body
+  return body
 })
 
+// sugar methods
+
 /** @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)
+  const resp = await bulkGet(config, ids)
+  /** @type { Array<import('../schema/crud.mjs').CouchDocSchema> } toRemove */
+  const toRemove = []
+  resp.rows.forEach(row => {
+    if (!row.doc) return
+    try {
+      const d = CouchDoc.parse(row.doc)
+      d._deleted = true
+      toRemove.push(d)
+    } catch (e) {
+      logger.warn(`Invalid document structure in bulk remove: ${row.id}`, e)
+    }
+  })
+  return bulkSave(config, toRemove)
+})
+
+/** @type { import('../schema/bulk.mjs').BulkGetDictionarySchema } */
+export const bulkGetDictionary = BulkGetDictionary.implement(async (config, ids) => {
+  const resp = await bulkGet(config, ids)
+
+  /** @type { import('../schema/bulk.mjs').BulkGetDictionaryResponseSchema } results */
+  const results = { found: {}, notFound: {} }
+
+  resp.rows.forEach(
+    /** @param { import('../schema/query.mjs').ViewRowSchema } row */
+    row => {
+      if (!row.key) return
+      if (row.error) {
+        results.notFound[row.key] = row
+        return
+      }
+      try {
+      /** @type { import('../schema/crud.mjs').CouchDocSchema } doc */
+        const doc = CouchDoc.parse(row.doc)
+        results.found[doc._id] = doc
+      } catch (e) {
+        results.notFound[row.key] = row
+      }
+    })
+  return results
+})
+
+/** @type { import('../schema/bulk.mjs').BulkSaveTransactionSchema } bulkSaveTransaction */
+export const bulkSaveTransaction = BulkSaveTransaction.implement(async (config, transactionId, docs) => {
+  const emitter = setupEmitter(config)
+  const logger = createLogger(config)
+  const retryOptions = {
+    maxRetries: config.maxRetries ?? 10,
+    initialDelay: config.initialDelay ?? 1000,
+    backoffFactor: config.backoffFactor ?? 2
+  }
+  const _put = config.bindWithRetry ? withRetry(put.bind(null, config), retryOptions) : put.bind(null, config)
+  logger.info(`Starting bulk save transaction ${transactionId} for ${docs.length} documents`)
+
+  // Create transaction document
+  const txnDoc = {
+    _id: `txn:${transactionId}`,
+    _rev: null,
+    type: 'transaction',
+    status: 'pending',
+    changes: docs,
+    timestamp: new Date().toISOString()
+  }
+
+  // Save transaction document
+  let txnresp = await _put(txnDoc)
+  logger.debug('Transaction document created:', txnDoc, txnresp)
+  await emitter.emit('transaction-created', { txnresp, txnDoc })
+  if (txnresp.error) {
+    throw new TransactionSetupError('Failed to create transaction document', {
+      error: txnresp.error,
+      response: txnresp.body
+    })
+  }
+
+  // Get current revisions of all documents
+  const existingDocs = await bulkGetDictionary(config, docs.map(d => d._id))
+  logger.debug('Fetched current revisions of documents:', existingDocs)
+  await emitter.emit('transaction-revs-fetched', existingDocs)
+
+  /** @type {string[]} */
+  const revErrors = []
+  // if any of the existingDocs, and the docs provided dont match on rev, then throw an error
+  docs.forEach(d => {
+    if (existingDocs.found[d._id] && existingDocs.found[d._id]._rev !== d._rev) revErrors.push(d._id)
+    if (existingDocs.notFound[d._id] && d._rev) revErrors.push(d._id)
+  })
+
+  if (revErrors.length > 0) {
+    throw new TransactionVersionConflictError(revErrors)
+  }
+  logger.debug('Checked document revisions:', existingDocs)
+  await emitter.emit('transaction-revs-checked', existingDocs)
+
+  /** @type {Record<string, import('../schema/crud.mjs').CouchDocSchema>} providedDocsById */
+  const providedDocsById = {}
+  docs.forEach((
+    /** @type {import('../schema/crud.mjs').CouchDocSchema} */ d
+  ) => {
+    if (!d._id) return
+    providedDocsById[d._id] = d
+  })
+
+  /** @type {import('../schema/bulk.mjs').Response} */
+  const newDocsToRollback = []
+  /** @type {import('../schema/bulk.mjs').Response} */
+  const potentialExistingDocsToRollack = []
+  /** @type {import('../schema/bulk.mjs').Response} */
+  const failedDocs = []
+
+  try {
+    logger.info('Transaction started:', txnDoc)
+    await emitter.emit('transaction-started', txnDoc)
+    // Apply updates
+    const results = await bulkSave(config, docs)
+    logger.info('Transaction updates applied:', results)
+    await emitter.emit('transaction-updates-applied', results)
+
+    // Check for failures
+    results.forEach(r => {
+      if (!r.id) return // not enough info
+      if (!r.error) {
+        if (existingDocs.notFound[r.id]) newDocsToRollback.push(r)
+        if (existingDocs.found[r.id]) potentialExistingDocsToRollack.push(r)
+      } else {
+        failedDocs.push(r)
+      }
+    })
+    if (failedDocs.length > 0) {
+      throw new TransactionBulkOperationError(failedDocs)
+    }
+
+    // Update transaction status to completed
+    txnDoc.status = 'completed'
+    txnDoc._rev = txnresp.rev
+    txnresp = await _put(txnDoc)
+    logger.info('Transaction completed:', txnDoc)
+    await emitter.emit('transaction-completed', { txnresp, txnDoc })
+    if (txnresp.statusCode !== 201) {
+      logger.error('Failed to update transaction status to completed')
+    }
+
+    return results
+  } catch (error) {
+    logger.error('Transaction failed, attempting rollback:', error)
+
+    // Rollback changes
+    /** @type {Array<import('../schema/crud.mjs').CouchDocSchema>} */
+    const toRollback = []
+    potentialExistingDocsToRollack.forEach(row => {
+      if (!row.id || !row.rev) return
+      const doc = existingDocs.found[row.id]
+      doc._rev = row.rev
+      toRollback.push(doc)
+    })
+    newDocsToRollback.forEach(d => {
+      if (!d.id || !d.rev) return
+      const before = structuredClone(providedDocsById[d.id])
+      before._rev = d.rev
+      before._deleted = true
+      toRollback.push(before)
+    })
+
+    // rollback all the changes
+    const bulkRollbackResult = await bulkSave(config, toRollback)
+    let status = 'rolled_back'
+    bulkRollbackResult.forEach(r => {
+      if (r.error) status = 'rollback_failed'
+    })
+    logger.warn('Transaction rolled back:', { bulkRollbackResult, status })
+    await emitter.emit('transaction-rolled-back', { bulkRollbackResult, status })
+
+    // Update transaction status to rolled back
+    txnDoc.status = status
+    txnDoc._rev = txnresp.rev
+    txnresp = await _put(txnDoc)
+    logger.warn('Transaction rollback status updated:', txnDoc)
+    await emitter.emit('transaction-rolled-back-status', { txnresp, txnDoc })
+    if (txnresp.statusCode !== 201) {
+      logger.error('Failed to update transaction status to rolled_back')
+    }
+    throw new TransactionRollbackError(
+      'Transaction failed and rollback was unsuccessful',
+      /** @type {Error} */ (error),
+      bulkRollbackResult
+    )
+  }
 })

package/impl/crud.d.mts

@@ -1,5 +1,7 @@
 /** @type { import('../schema/crud.mjs').CouchGetSchema } */
 export const get: import("../schema/crud.mjs").CouchGetSchema;
+/** @type { import('../schema/crud.mjs').CouchGetAtRevSchema } */
+export const getAtRev: import("../schema/crud.mjs").CouchGetAtRevSchema;
 /** @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

@@ -1 +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"}
+{"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAqDA,4DAA4D;AAC5D,kBADY,OAAO,oBAAoB,EAAE,cAAc,CAIrD;AAEF,iEAAiE;AACjE,uBADY,OAAO,oBAAoB,EAAE,mBAAmB,CAI1D;AAEF,4DAA4D;AAC5D,kBADY,OAAO,oBAAoB,EAAE,cAAc,CAqCrD"}

package/impl/crud.mjs

@@ -1,7 +1,7 @@
 // @ts-check
 import needle from 'needle'
-import { CouchGet, CouchPut } from '../schema/crud.mjs'
-import { RetryableError } from './errors.mjs'
+import { CouchGet, CouchPut, CouchGetWithOptions, CouchGetAtRev } from '../schema/crud.mjs'
+import { RetryableError, NotFoundError } from './errors.mjs'
 import { createLogger } from './logger.mjs'
 
 const opts = {
@@ -11,11 +11,13 @@ const opts = {
   }
 }
 
-/** @type { import('../schema/crud.mjs').CouchGetSchema } */
-export const get = CouchGet.implement(async (config, id) => {
+/** @type { import('../schema/crud.mjs').CouchGetWithOptionsSchema } */
+const _getWithOptions = CouchGetWithOptions.implement(async (config, id, getOpts) => {
   const logger = createLogger(config)
-  const url = `${config.couch}/${id}`
-  logger.info(`Getting document with id: ${id}`)
+  const rev = getOpts?.rev
+  const path = rev ? `${id}?rev=${rev}` : id
+  const url = `${config.couch}/${path}`
+  logger.info(`Getting document with id: ${id}, rev ${rev || 'latest'}`)
 
   try {
     const resp = await needle('get', url, opts)
@@ -23,18 +25,14 @@ export const get = CouchGet.implement(async (config, id) => {
       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')
+        logger.warn(`Document not found (throwing error): ${id}, rev ${rev || 'latest'}`)
+        throw new NotFoundError(id, result.reason || 'not_found')
       } else {
-        logger.debug(`Document not found (returning undefined): ${id}`)
-        return undefined
+        logger.debug(`Document not found (returning undefined): ${id}, rev ${rev || 'latest'}`)
+        return null
       }
     }
     if (RetryableError.isRetryableStatusCode(resp.statusCode)) {
@@ -45,7 +43,7 @@ export const get = CouchGet.implement(async (config, id) => {
       logger.error(`Unexpected status code: ${resp.statusCode}`)
       throw new Error(result.reason || 'failed')
     }
-    logger.info(`Successfully retrieved document: ${id}`)
+    logger.info(`Successfully retrieved document: ${id}, rev ${rev || 'latest'}`)
     return result
   } catch (err) {
     logger.error('Error during get operation:', err)
@@ -53,6 +51,18 @@ export const get = CouchGet.implement(async (config, id) => {
   }
 })
 
+/** @type { import('../schema/crud.mjs').CouchGetSchema } */
+export const get = CouchGet.implement(async (config, id) => {
+  const getOptions = {}
+  return _getWithOptions(config, id, getOptions)
+})
+
+/** @type { import('../schema/crud.mjs').CouchGetAtRevSchema } */
+export const getAtRev = CouchGetAtRev.implement(async (config, id, rev) => {
+  const getOptions = { rev }
+  return _getWithOptions(config, id, getOptions)
+})
+
 /** @type { import('../schema/crud.mjs').CouchPutSchema } */
 export const put = CouchPut.implement(async (config, doc) => {
   const logger = createLogger(config)

package/impl/errors.d.mts

@@ -3,6 +3,14 @@
  * @property {string} code - The error code
  * @property {string} [message] - Optional error message
  */
+export class NotFoundError extends Error {
+    /**
+     * @param {string} docId - The ID of the document that wasn't found
+     * @param {string} [message] - Optional error message
+     */
+    constructor(docId: string, message?: string | undefined);
+    docId: string;
+}
 export class RetryableError extends Error {
     /**
      * @param {number|undefined} statusCode - The HTTP status code to check

package/impl/errors.d.mts.map

@@ -1 +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"}
+{"version":3,"file":"errors.d.mts","sourceRoot":"","sources":["errors.mjs"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;IACE;;;OAGG;IACH,mBAHW,MAAM,gCAOhB;IADC,cAAkB;CAErB;AAED;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;;;;;UA5Da,MAAM"}

package/impl/errors.mjs

@@ -6,6 +6,18 @@
  * @property {string} [message] - Optional error message
  */
 
+export class NotFoundError extends Error {
+  /**
+   * @param {string} docId - The ID of the document that wasn't found
+   * @param {string} [message] - Optional error message
+   */
+  constructor(docId, message = 'Document not found') {
+    super(message)
+    this.name = 'NotFoundError'
+    this.docId = docId
+  }
+}
+
 export class RetryableError extends Error {
   /**
    * @param {string} message - The error message

package/impl/patch.d.mts

@@ -1,4 +1,6 @@
 export function sleep(ms: any): Promise<any>;
 /** @type { import('../schema/patch.mjs').PatchSchema } */
 export const patch: import("../schema/patch.mjs").PatchSchema;
+/** @type { import('../schema/patch.mjs').PatchDangerouslySchema } */
+export const patchDangerously: import("../schema/patch.mjs").PatchDangerouslySchema;
 //# sourceMappingURL=patch.d.mts.map

package/impl/patch.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAIO,6CAAmE;AAE1E,0DAA0D;AAC1D,oBADY,OAAO,qBAAqB,EAAE,WAAW,CA4DnD"}
+{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAIO,6CAAmE;AAE1E,0DAA0D;AAC1D,oBADY,OAAO,qBAAqB,EAAE,WAAW,CAmBnD;AAEF,qEAAqE;AACrE,+BADY,OAAO,qBAAqB,EAAE,sBAAsB,CA4D9D"}

package/impl/patch.mjs

@@ -1,5 +1,5 @@
 import { get, put } from './crud.mjs'
-import { Patch } from '../schema/patch.mjs'
+import { Patch, PatchDangerously } from '../schema/patch.mjs'
 import { createLogger } from './logger.mjs'
 
 export const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
@@ -7,6 +7,27 @@ 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 logger = createLogger(config)
+
+  logger.info(`Starting patch operation for document ${id}`)
+  logger.debug('Patch properties:', properties)
+  const doc = await get(config, id)
+  if (doc._rev !== properties._rev) {
+    const result = {}
+    result.ok = false
+    result.error = 'conflict'
+    result.statusCode = 409
+    return result
+  }
+  const updatedDoc = { ...doc, ...properties }
+  logger.debug('Merged document:', updatedDoc)
+  const result = await put(config, updatedDoc)
+  logger.info(`Successfully patched document ${id}, rev: ${result.rev}`)
+  return result
+})
+
+/** @type { import('../schema/patch.mjs').PatchDangerouslySchema } */
+export const patchDangerously = PatchDangerously.implement(async (config, id, properties) => {
+  const logger = createLogger(config)
   const maxRetries = config.maxRetries || 5
   let delay = config.initialDelay || 1000
   let attempts = 0

package/impl/query.d.mts

@@ -120,17 +120,20 @@ export const query: z.infer<z.ZodFunction<z.ZodTuple<[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">>>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         id?: string | undefined;
         key?: any;
         value?: any;
-        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
     }, {
         id?: string | undefined;
         key?: any;
         value?: any;
-        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
     }>, "many">;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     error: z.ZodOptional<z.ZodString>;
@@ -138,17 +141,20 @@ export const query: z.infer<z.ZodFunction<z.ZodTuple<[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">>>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         id?: string | undefined;
         key?: any;
         value?: any;
-        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
     }, {
         id?: string | undefined;
         key?: any;
         value?: any;
-        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
     }>, "many">;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     error: z.ZodOptional<z.ZodString>;
@@ -156,17 +162,20 @@ export const query: z.infer<z.ZodFunction<z.ZodTuple<[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">>>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         id?: string | undefined;
         key?: any;
         value?: any;
-        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
     }, {
         id?: string | undefined;
         key?: any;
         value?: any;
-        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
     }>, "many">;
 }, z.ZodTypeAny, "passthrough">>>>>;
 import { z } from 'zod';

package/impl/query.d.mts.map

@@ -1 +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"}
+{"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/queryBuilder.d.mts

@@ -0,0 +1,94 @@
+/**
+ * @typedef {Object} QueryOptions
+ * @property {any} [key] - Exact key to match
+ * @property {any} [startkey] - Start of key range
+ * @property {any} [endkey] - End of key range
+ * @property {boolean} [reduce] - Whether to use reduce function
+ * @property {boolean} [group] - Whether to group results
+ * @property {number} [group_level] - Level at which to group
+ * @property {string} [stale] - Stale parameter value
+ * @property {number} [limit] - Max number of results
+ */
+export class QueryBuilder {
+    /**
+     * @param {any} key
+     * @returns {QueryBuilder}
+     */
+    key(key: any): QueryBuilder;
+    /**
+     * @param {any} startkey
+     * @returns {QueryBuilder}
+     */
+    startKey(startkey: any): QueryBuilder;
+    /**
+     * @param {any} endkey
+     * @returns {QueryBuilder}
+     */
+    endKey(endkey: any): QueryBuilder;
+    /**
+     * @param {boolean} reduce
+     * @returns {QueryBuilder}
+     */
+    reduce(reduce?: boolean): QueryBuilder;
+    /**
+     * @param {boolean} group
+     * @returns {QueryBuilder}
+     */
+    group(group?: boolean): QueryBuilder;
+    /**
+     * @param {number} level
+     * @returns {QueryBuilder}
+     */
+    groupLevel(level: number): QueryBuilder;
+    /**
+     * @param {string} stale
+     * @returns {QueryBuilder}
+     */
+    stale(stale: string): QueryBuilder;
+    /**
+     * @param {number} limit
+     * @returns {QueryBuilder}
+     */
+    limit(limit: number): QueryBuilder;
+    /**
+     * @returns {QueryOptions}
+     */
+    build(): QueryOptions;
+    #private;
+}
+export function createQuery(): QueryBuilder;
+export type QueryOptions = {
+    /**
+     * - Exact key to match
+     */
+    key?: any;
+    /**
+     * - Start of key range
+     */
+    startkey?: any;
+    /**
+     * - End of key range
+     */
+    endkey?: any;
+    /**
+     * - Whether to use reduce function
+     */
+    reduce?: boolean | undefined;
+    /**
+     * - Whether to group results
+     */
+    group?: boolean | undefined;
+    /**
+     * - Level at which to group
+     */
+    group_level?: number | undefined;
+    /**
+     * - Stale parameter value
+     */
+    stale?: string | undefined;
+    /**
+     * - Max number of results
+     */
+    limit?: number | undefined;
+};
+//# sourceMappingURL=queryBuilder.d.mts.map

package/impl/queryBuilder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryBuilder.d.mts","sourceRoot":"","sources":["queryBuilder.mjs"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH;IAIE;;;OAGG;IACH,SAHW,GAAG,GACD,YAAY,CAKxB;IAED;;;OAGG;IACH,mBAHW,GAAG,GACD,YAAY,CAKxB;IAED;;;OAGG;IACH,eAHW,GAAG,GACD,YAAY,CAKxB;IAED;;;OAGG;IACH,gBAHW,OAAO,GACL,YAAY,CAKxB;IAED;;;OAGG;IACH,cAHW,OAAO,GACL,YAAY,CAKxB;IAED;;;OAGG;IACH,kBAHW,MAAM,GACJ,YAAY,CAKxB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,YAAY,CAKxB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,YAAY,CAKxB;IAED;;OAEG;IACH,SAFa,YAAY,CAIxB;;CACF;AAEM,4CAA4C;;;;;UA9FrC,GAAG;;;;eACH,GAAG;;;;aACH,GAAG"}