hide-a-bed 5.2.7 → 6.0.0-beta.0

package/impl/query.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.d.mts","sourceRoot":"","sources":["query.mjs"],"names":[],"mappings":"AA8FA;;;GAGG;AACH;;;;GAIG;AACH,qCAJW;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,sBACtB,MAAM,EAAE,GACN,MAAM,CAoBlB;AA9GD;;;;;GAKG;AACH,oBALW,CAAC,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAAiB,CAgFjC;kBA1FgB,KAAK"}

package/impl/query.mjs

@@ -1,122 +0,0 @@
-// @ts-check
-
-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> }
- * @param {import('../schema/config.mjs').CouchConfigSchema} config
- * @param {string} view
- * @param {import('../schema/query.mjs').SimpleViewOptionsSchema} [options]
- */
-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
-  let qs = queryString(options, ['key', 'startkey', 'endkey', 'reduce', 'group', 'group_level', 'stale', 'limit'])
-  let method = 'GET'
-  let payload = null
-  const opts = {
-    json: true,
-    headers: {
-      'Content-Type': 'application/json'
-    }
-  }
-
-  // If keys are supplied, issue a POST to circumvent GET query string limits
-  // see http://wiki.apache.org/couchdb/HTTP_view_API#Querying_Options
-  if (typeof options.keys !== 'undefined') {
-    const MAX_URL_LENGTH = 2000
-    // according to http://stackoverflow.com/a/417184/680742,
-    // the de facto URL length limit is 2000 characters
-
-    const _options = JSON.parse(JSON.stringify(options))
-    delete _options.keys
-    qs = queryString(_options, ['key', 'startkey', 'endkey', 'reduce', 'group', 'group_level', 'stale', 'limit']) // dont need descening or skip, those will work
-
-    const keysAsString = `keys=${JSON.stringify(options.keys)}`
-
-    if (keysAsString.length + qs.length + 1 <= MAX_URL_LENGTH) {
-      // If the keys are short enough, do a GET. we do this to work around
-      // Safari not understanding 304s on POSTs (see pouchdb/pouchdb#1239)
-      method = 'GET'
-      if (qs.length > 0) qs += '&'
-      else qs = ''
-      qs += keysAsString
-    } else {
-      method = 'POST'
-      payload = { keys: options.keys }
-    }
-  }
-
-  logger.debug('Generated query string:', qs)
-  const url = `${config.couch}/${view}?${qs.toString()}`
-  // @ts-ignore
-  let results
-  try {
-    logger.debug(`Sending ${method} request to: ${url}`)
-    results = (method === 'GET') ? await needle('get', url, opts) : await needle('post', url, payload, 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 (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
-})
-
-/**
- * @param {{ [key: string]: any }} options - The options object containing query parameters.
- * @param {string[]} params - The list of parameter names to include in the query string.
- */
-/**
- * @param {{ [key: string]: any }} options
- * @param {string[]} params
- * @returns {string}
- */
-export function queryString (options = {}, params) {
-  const parts = Object.keys(options).map(key => {
-    let value = options[key]
-    if (includes(params, key)) {
-      if (typeof value === 'string' && key !== 'stale') value = `"${value}"`
-      if (Array.isArray(value)) {
-        value = '[' + value.map(i => {
-          if (i === null) return 'null'
-          if (typeof i === 'string') return `"${i}"`
-          if (typeof i === 'object' && Object.keys(i).length === 0) return '{}'
-          if (typeof i === 'object') return JSON.stringify(i)
-          return i
-        }).join(',') + ']'
-      }
-    }
-    return `${key}=${value}`
-  })
-  return parts.join('&')
-}

package/impl/queryBuilder.d.mts

@@ -1,154 +0,0 @@
-/**
- * @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 {boolean} [include_docs] - Whether to include full couch docs
- * @property {string} [stale] - Stale parameter value
- * @property {number} [limit] - Max number of results
- * @property {boolean} [descending] - Whether to return results in descending order
- * @property {number} [skip] - Number of results to skip
- * @property {any[]} [keys] - Array of keys to match
- */
-export class QueryBuilder {
-    /**
-     * @param {any} key
-     * @returns {QueryBuilder}
-     */
-    key(key: any): QueryBuilder;
-    /**
-     * @param {any} startkey
-     * @returns {QueryBuilder}
-     */
-    startKey(startkey: any): QueryBuilder;
-    /**
-     * @param {any} startkey
-     * @returns {QueryBuilder}
-     */
-    startkey(startkey: any): QueryBuilder;
-    /**
-     * @param {any} endkey
-     * @returns {QueryBuilder}
-     */
-    endKey(endkey: 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 {number} level
-     * @returns {QueryBuilder}
-     */
-    group_level(level: number): QueryBuilder;
-    /**
-     * @param {boolean} includeDocs
-     * @returns {QueryBuilder}
-     */
-    includeDocs(includeDocs?: boolean): QueryBuilder;
-    /**
-     * @param {boolean} includeDocs
-     * @returns {QueryBuilder}
-     */
-    include_docs(includeDocs?: boolean): QueryBuilder;
-    /**
-     * @param {string} stale
-     * @returns {QueryBuilder}
-     */
-    stale(stale: string): QueryBuilder;
-    /**
-     * @param {number} limit
-     * @returns {QueryBuilder}
-     */
-    limit(limit: number): QueryBuilder;
-    /**
-     * @param {boolean} descending
-     * @returns {QueryBuilder}
-     */
-    descending(descending?: boolean): QueryBuilder;
-    /**
-     * @param {number} skip
-     * @returns {QueryBuilder}
-     */
-    skip(skip: number): QueryBuilder;
-    /**
-     * @param {any[]} keys
-     * @returns {QueryBuilder}
-     */
-    keys(keys: any[]): 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;
-    /**
-     * - Whether to include full couch docs
-     */
-    include_docs?: boolean | undefined;
-    /**
-     * - Stale parameter value
-     */
-    stale?: string | undefined;
-    /**
-     * - Max number of results
-     */
-    limit?: number | undefined;
-    /**
-     * - Whether to return results in descending order
-     */
-    descending?: boolean | undefined;
-    /**
-     * - Number of results to skip
-     */
-    skip?: number | undefined;
-    /**
-     * - Array of keys to match
-     */
-    keys?: any[] | undefined;
-};
-//# sourceMappingURL=queryBuilder.d.mts.map

package/impl/queryBuilder.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queryBuilder.d.mts","sourceRoot":"","sources":["queryBuilder.mjs"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH;IAIE;;;OAGG;IACH,SAHW,GAAG,GACD,YAAY,CAKxB;IAED;;;OAGG;IACH,mBAHW,GAAG,GACD,YAAY,CAKxB;IAED;;;OAGG;IACH,mBAHW,GAAG,GACD,YAAY,CAKxB;IAED;;;OAGG;IACH,eAHW,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,mBAHW,MAAM,GACJ,YAAY,CAKxB;IAED;;;OAGG;IACH,0BAHW,OAAO,GACL,YAAY,CAKxB;IAED;;;OAGG;IACH,2BAHW,OAAO,GACL,YAAY,CAKxB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,YAAY,CAKxB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,YAAY,CAKxB;IAED;;;OAGG;IACH,wBAHW,OAAO,GACL,YAAY,CAKxB;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,YAAY,CAKxB;IAED;;;OAGG;IACH,WAHW,GAAG,EAAE,GACH,YAAY,CAKxB;IAED;;OAEG;IACH,SAFa,YAAY,CAIxB;;CACF;AAEM,4CAA4C;;;;;UA1KrC,GAAG;;;;eACH,GAAG;;;;aACH,GAAG"}

package/impl/queryBuilder.mjs

@@ -1,175 +0,0 @@
-// @ts-check
-
-/**
- * @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 {boolean} [include_docs] - Whether to include full couch docs
- * @property {string} [stale] - Stale parameter value
- * @property {number} [limit] - Max number of results
- * @property {boolean} [descending] - Whether to return results in descending order
- * @property {number} [skip] - Number of results to skip
- * @property {any[]} [keys] - Array of keys to match
- */
-
-export class QueryBuilder {
-  /** @type {QueryOptions} */
-  #options = {}
-
-  /**
-   * @param {any} key
-   * @returns {QueryBuilder}
-   */
-  key (key) {
-    this.#options.key = key
-    return this
-  }
-
-  /**
-   * @param {any} startkey
-   * @returns {QueryBuilder}
-   */
-  startKey (startkey) {
-    this.#options.startkey = startkey
-    return this
-  }
-
-  /**
-   * @param {any} startkey
-   * @returns {QueryBuilder}
-   */
-  startkey (startkey) {
-    this.#options.startkey = startkey
-    return this
-  }
-
-  /**
-   * @param {any} endkey
-   * @returns {QueryBuilder}
-   */
-  endKey (endkey) {
-    this.#options.endkey = endkey
-    return this
-  }
-
-  /**
-   * @param {any} endkey
-   * @returns {QueryBuilder}
-   */
-  endkey (endkey) {
-    this.#options.endkey = endkey
-    return this
-  }
-
-  /**
-   * @param {boolean} reduce
-   * @returns {QueryBuilder}
-   */
-  reduce (reduce = true) {
-    this.#options.reduce = reduce
-    return this
-  }
-
-  /**
-   * @param {boolean} group
-   * @returns {QueryBuilder}
-   */
-  group (group = true) {
-    this.#options.group = group
-    return this
-  }
-
-  /**
-   * @param {number} level
-   * @returns {QueryBuilder}
-   */
-  groupLevel (level) {
-    this.#options.group_level = level
-    return this
-  }
-
-  /**
-   * @param {number} level
-   * @returns {QueryBuilder}
-   */
-  group_level (level) {
-    this.#options.group_level = level
-    return this
-  }
-
-  /**
-   * @param {boolean} includeDocs
-   * @returns {QueryBuilder}
-   */
-  includeDocs (includeDocs = true) {
-    this.#options.include_docs = includeDocs
-    return this
-  }
-
-  /**
-   * @param {boolean} includeDocs
-   * @returns {QueryBuilder}
-   */
-  include_docs (includeDocs = true) {
-    this.#options.include_docs = includeDocs
-    return this
-  }
-
-  /**
-   * @param {string} stale
-   * @returns {QueryBuilder}
-   */
-  stale (stale) {
-    this.#options.stale = stale
-    return this
-  }
-
-  /**
-   * @param {number} limit
-   * @returns {QueryBuilder}
-   */
-  limit (limit) {
-    this.#options.limit = limit
-    return this
-  }
-
-  /**
-   * @param {boolean} descending
-   * @returns {QueryBuilder}
-   */
-  descending (descending = true) {
-    this.#options.descending = descending
-    return this
-  }
-
-  /**
-   * @param {number} skip
-   * @returns {QueryBuilder}
-   */
-  skip (skip) {
-    this.#options.skip = skip
-    return this
-  }
-
-  /**
-   * @param {any[]} keys
-   * @returns {QueryBuilder}
-   */
-  keys (keys) {
-    this.#options.keys = keys
-    return this
-  }
-
-  /**
-   * @returns {QueryOptions}
-   */
-  build () {
-    return { ...this.#options }
-  }
-}
-
-export const createQuery = () => new QueryBuilder()

package/impl/retry.d.mts

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

package/impl/retry.d.mts.map

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

package/impl/retry.mjs

@@ -1,39 +0,0 @@
-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
-    maxDelay = 30000 // 30 seconds max delay
-  } = options
-
-  return async (...args) => {
-    let delay = initialDelay
-
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        // Clear any references to previous attempts
-        const result = await fn(...args)
-        return result
-      } catch (error) {
-        // Only retry if it's a RetryableError
-        if (!(error instanceof RetryableError)) {
-          throw error
-        }
-
-        // If we've used all retries, throw the error
-        if (attempt === maxRetries) {
-          throw error
-        }
-
-        // Calculate next delay with a maximum cap
-        const nextDelay = Math.min(delay, maxDelay)
-        // Wait with exponential backoff
-        await sleep(nextDelay)
-        delay *= backoffFactor
-      }
-    }
-  }
-}

package/impl/stream.d.mts

@@ -1,3 +0,0 @@
-/** @type { import('../schema/stream.mjs').SimpleViewQueryStreamSchema } queryStream */
-export const queryStream: import("../schema/stream.mjs").SimpleViewQueryStreamSchema;
-//# sourceMappingURL=stream.d.mts.map

package/impl/stream.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.mts","sourceRoot":"","sources":["stream.mjs"],"names":[],"mappings":"AASA,uFAAuF;AACvF,0BADY,OAAO,sBAAsB,EAAE,2BAA2B,CAwFpE"}

package/impl/stream.mjs

@@ -1,98 +0,0 @@
-// @ts-check
-import needle from 'needle'
-import { CouchConfig } from '../schema/config.mjs'
-import { queryString } from './query.mjs'
-import { RetryableError } from './errors.mjs'
-import { createLogger } from './logger.mjs'
-// @ts-ignore
-import JSONStream from 'JSONStream'
-
-/** @type { import('../schema/stream.mjs').SimpleViewQueryStreamSchema } queryStream */
-export const queryStream = (rawConfig, view, options, onRow) => new Promise((resolve, reject) => {
-  const config = CouchConfig.parse(rawConfig)
-  const logger = createLogger(config)
-  logger.info(`Starting view query stream: ${view}`)
-  logger.debug('Query options:', options)
-
-  if (!options) options = {}
-
-  let method = 'GET'
-  let payload = null
-  let qs = queryString(options, ['key', 'startkey', 'endkey', 'reduce', 'group', 'group_level', 'stale', 'limit'])
-  logger.debug('Generated query string:', qs)
-
-  // If keys are supplied, issue a POST to circumvent GET query string limits
-  if (typeof options.keys !== 'undefined') {
-    const MAX_URL_LENGTH = 2000
-    const keysAsString = `keys=${encodeURIComponent(JSON.stringify(options.keys))}`
-
-    if (keysAsString.length + qs.length + 1 <= MAX_URL_LENGTH) {
-      // If the keys are short enough, do a GET
-      qs += (qs[0] === '?' ? '&' : '?') + keysAsString
-    } else {
-      method = 'POST'
-      payload = { keys: options.keys }
-    }
-  }
-
-  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.*')
-
-  let rowCount = 0
-  streamer.on('data', /** @param {object} row */ row => {
-    rowCount++
-    onRow(row)
-  })
-
-  streamer.on('error', /** @param {Error} err */ err => {
-    logger.error('Stream parsing error:', err)
-    reject(new Error(`Stream parsing error: ${err.message}`))
-  })
-
-  streamer.on('done', /** @param {Error|null} err */ err => {
-    try {
-      RetryableError.handleNetworkError(err)
-    } catch (e) {
-      reject(e)
-    }
-  })
-
-  streamer.on('end', () => {
-    logger.info(`Stream completed, processed ${rowCount} rows`)
-    resolve(undefined) // all work should be done in the stream
-  })
-
-  const req = method === 'GET'
-    ? needle.get(url, opts)
-    : needle.post(url, payload, 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()
-    }
-  })
-
-  req.on('error', err => {
-    logger.error('Network error during stream query:', err)
-    try {
-      RetryableError.handleNetworkError(err)
-    } catch (retryErr) {
-      reject(retryErr)
-      return
-    }
-    reject(err)
-  })
-
-  req.pipe(streamer)
-})

package/impl/sugar/lock.d.mts

@@ -1,5 +0,0 @@
-/** @type {import('../../schema/sugar/lock.mjs').CreateLockSchema} */
-export const createLock: import("../../schema/sugar/lock.mjs").CreateLockSchema;
-/** @type {import('../../schema/sugar/lock.mjs').RemoveLockSchema} */
-export const removeLock: import("../../schema/sugar/lock.mjs").RemoveLockSchema;
-//# sourceMappingURL=lock.d.mts.map

package/impl/sugar/lock.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lock.d.mts","sourceRoot":"","sources":["lock.mjs"],"names":[],"mappings":"AAIA,qEAAqE;AACrE,yBADW,OAAO,6BAA6B,EAAE,gBAAgB,CA8B/D;AAEF,qEAAqE;AACrE,yBADW,OAAO,6BAA6B,EAAE,gBAAgB,CAiC/D"}

package/impl/sugar/lock.mjs

@@ -1,70 +0,0 @@
-import { CreateLock, RemoveLock } from '../../schema/sugar/lock.mjs'
-import { put, get } from '../crud.mjs'
-import { createLogger } from '../logger.mjs'
-
-/** @type {import('../../schema/sugar/lock.mjs').CreateLockSchema} */
-export const createLock = CreateLock.implement(async (config, docId, options) => {
-  const logger = createLogger(config)
-
-  if (!options.enableLocking) {
-    logger.debug('Locking disabled, returning true')
-    return true
-  }
-
-  const _id = `lock-${docId}`
-  const lock = {
-    _id,
-    type: 'lock',
-    locks: docId,
-    lockedAt: new Date().toISOString(),
-    lockedBy: options.username
-  }
-
-  try {
-    const result = await put(config, lock)
-    logger.info(`Lock created for ${docId} by ${options.username}`)
-    return result.ok === true
-  } catch (error) {
-    if (error.status === 409) {
-      logger.warn(`Lock conflict for ${docId} - already locked`)
-    } else {
-      logger.error(`Error creating lock for ${docId}:`, error)
-    }
-    return false
-  }
-})
-
-/** @type {import('../../schema/sugar/lock.mjs').RemoveLockSchema} */
-export const removeLock = RemoveLock.implement(async (config, docId, options) => {
-  const logger = createLogger(config)
-
-  if (!options.enableLocking) {
-    logger.debug('Locking disabled, skipping unlock')
-    return
-  }
-
-  if (!docId) {
-    logger.warn('No docId provided for unlock')
-    return
-  }
-
-  const _id = `lock-${docId}`
-  const existingLock = await get(config, _id)
-
-  if (!existingLock) {
-    logger.debug(`No lock found for ${docId}`)
-    return
-  }
-
-  if (existingLock.lockedBy !== options.username) {
-    logger.warn(`Cannot remove lock for ${docId} - owned by ${existingLock.lockedBy}`)
-    return
-  }
-
-  try {
-    await put(config, { ...existingLock, _deleted: true })
-    logger.info(`Lock removed for ${docId}`)
-  } catch (error) {
-    logger.error(`Error removing lock for ${docId}:`, error)
-  }
-})