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

package/impl/stream.test.mts

@@ -1,205 +0,0 @@
-import assert from 'node:assert/strict'
-import test, { suite } from 'node:test'
-import { createServer } from 'node:http'
-import type { AddressInfo } from 'node:net'
-import { queryStream } from './stream.mts'
-import { bindConfig } from './bindConfig.mts'
-
-const startServer = async (handler: Parameters<typeof createServer>[0]) => {
-  const server = createServer(handler)
-  await new Promise<void>(resolve => server.listen(0, resolve))
-  return server
-}
-
-suite('queryStream', () => {
-  test('queryStream streams rows from chunked response', async t => {
-    const expectedRows = [
-      { id: 'row-1', key: 'row-1', value: { count: 1 } },
-      { id: 'row-2', key: 'row-2', value: { count: 2 } }
-    ]
-
-    // @ts-expect-error testing server
-    const server = await startServer((req, res) => {
-      res.on('error', () => {})
-      const requestUrl = new URL(req.url ?? '/', `http://${req.headers.host}`)
-      assert.strictEqual(req.method, 'GET')
-      assert.strictEqual(requestUrl.pathname, '/_design/demo/_view/by-key')
-
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      const payload = JSON.stringify({
-        total_rows: expectedRows.length,
-        rows: expectedRows
-      })
-      const chunkSize = 7
-      for (let i = 0; i < payload.length; i += chunkSize) {
-        res.write(payload.slice(i, i + chunkSize))
-      }
-      res.end()
-    })
-
-    t.after(async () => {
-      await new Promise<void>(resolve => server.close(() => resolve()))
-    })
-
-    const { port } = server.address() as AddressInfo
-    const rows: unknown[] = []
-
-    await queryStream(
-      { couch: `http://127.0.0.1:${port}` },
-      '_design/demo/_view/by-key',
-      {},
-      row => {
-        const matchedRow = expectedRows.find(r => r.id === row.id)
-        assert.ok(matchedRow)
-        assert.deepStrictEqual(row, matchedRow)
-        rows.push(row)
-      }
-    )
-
-    assert.deepStrictEqual(rows, expectedRows)
-  })
-
-  test('queryStream works with bindConfig', async t => {
-    const expectedRows = [
-      { id: 'row-1', key: 'row-1', value: { count: 1 } },
-      { id: 'row-2', key: 'row-2', value: { count: 2 } }
-    ]
-
-    // @ts-expect-error testing server
-    const server = await startServer((req, res) => {
-      res.on('error', () => {})
-      const requestUrl = new URL(req.url ?? '/', `http://${req.headers.host}`)
-      assert.strictEqual(req.method, 'GET')
-      assert.strictEqual(requestUrl.pathname, '/_design/demo/_view/by-key')
-
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      const payload = JSON.stringify({
-        total_rows: expectedRows.length,
-        rows: expectedRows
-      })
-      const chunkSize = 7
-      for (let i = 0; i < payload.length; i += chunkSize) {
-        res.write(payload.slice(i, i + chunkSize))
-      }
-      res.end()
-    })
-
-    t.after(async () => {
-      await new Promise<void>(resolve => server.close(() => resolve()))
-    })
-
-    const { port } = server.address() as AddressInfo
-
-    const rows: unknown[] = []
-
-    const db = bindConfig({ couch: `http://127.0.0.1:${port}` })
-
-    await db.queryStream('_design/demo/_view/by-key', {}, row => {
-      const matchedRow = expectedRows.find(r => r.id === row.id)
-      assert.ok(matchedRow)
-      assert.deepStrictEqual(row, matchedRow)
-      rows.push(row)
-    })
-
-    assert.deepStrictEqual(rows, expectedRows)
-  })
-
-  test('queryStream works with options chaining', async t => {
-    const expectedRows = [
-      { id: 'row-1', key: 'row-1', value: { count: 1 } },
-      { id: 'row-2', key: 'row-2', value: { count: 2 } }
-    ]
-
-    // @ts-expect-error testing server
-    const server = await startServer((req, res) => {
-      res.on('error', () => {})
-      const requestUrl = new URL(req.url ?? '/', `http://${req.headers.host}`)
-      assert.strictEqual(req.method, 'GET')
-      assert.strictEqual(requestUrl.pathname, '/_design/demo/_view/by-key')
-
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      const payload = JSON.stringify({
-        total_rows: expectedRows.length,
-        rows: expectedRows
-      })
-      const chunkSize = 7
-      for (let i = 0; i < payload.length; i += chunkSize) {
-        res.write(payload.slice(i, i + chunkSize))
-      }
-      res.end()
-    })
-
-    t.after(async () => {
-      await new Promise<void>(resolve => server.close(() => resolve()))
-    })
-
-    const { port } = server.address() as AddressInfo
-    const rows: unknown[] = []
-
-    const db = bindConfig({ couch: `http://127.0.0.1:${port}` })
-
-    await db.options({ logger: console }).queryStream('_design/demo/_view/by-key', {}, row => {
-      const matchedRow = expectedRows.find(r => r.id === row.id)
-      assert.ok(matchedRow)
-      assert.deepStrictEqual(row, matchedRow)
-      rows.push(row)
-    })
-
-    assert.deepStrictEqual(rows, expectedRows)
-  })
-
-  test('queryStream handles empty result sets', async t => {
-    // @ts-expect-error testing server
-    const server = await startServer((_, res) => {
-      res.on('error', () => {})
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.write('{"rows":[]}')
-      res.end()
-    })
-
-    t.after(async () => {
-      await new Promise<void>(resolve => server.close(() => resolve()))
-    })
-
-    const { port } = server.address() as AddressInfo
-    let rowCount = 0
-
-    await queryStream(
-      { couch: `http://127.0.0.1:${port}` },
-      '_design/demo/_view/by-key',
-      {},
-      () => {
-        rowCount++
-      }
-    )
-
-    assert.strictEqual(rowCount, 0)
-  })
-
-  test('queryStream rejects when row handler throws', async t => {
-    // @ts-expect-error testing server
-    const server = await startServer((_, res) => {
-      res.on('error', () => {})
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.write('{"rows":[{"id":"broken","value":42}]}')
-      res.end()
-    })
-
-    t.after(async () => {
-      await new Promise<void>(resolve => server.close(() => resolve()))
-    })
-
-    const { port } = server.address() as AddressInfo
-    const handlerError = new Error('row-failure')
-
-    await assert.rejects(
-      queryStream({ couch: `http://127.0.0.1:${port}` }, '_design/demo/_view/error', {}, () => {
-        throw handlerError
-      }),
-      error => {
-        assert.strictEqual(error, handlerError)
-        return true
-      }
-    )
-  })
-})

package/impl/sugar/lock.test.mts

@@ -1,113 +0,0 @@
-import assert from 'node:assert/strict'
-import test, { suite } from 'node:test'
-import needle from 'needle'
-import type { CouchConfigInput } from '../../schema/config.mts'
-import { createLock, removeLock } from './lock.mts'
-import { TEST_DB_URL } from '../../test/setup-db.mts'
-
-const baseConfig: CouchConfigInput = {
-  couch: TEST_DB_URL,
-  useConsoleLogger: true
-}
-
-async function fetchLockDoc(docId: string) {
-  return await needle('get', `${TEST_DB_URL}/lock-${docId}`, null, {
-    json: true
-  })
-}
-
-suite('lock', () => {
-  test('integration with pouchdb-server', async t => {
-    await t.test('creates a lock document when enabled', async () => {
-      const docId = `lock-creates-${Date.now()}`
-      const created = await createLock(baseConfig, docId, {
-        enableLocking: true,
-        username: 'alice'
-      })
-      assert.strictEqual(created, true)
-
-      const response = await fetchLockDoc(docId)
-      assert.strictEqual(response.statusCode, 200)
-      const body = response.body as { lockedBy: string; locks: string }
-      assert.strictEqual(body.lockedBy, 'alice')
-      assert.strictEqual(body.locks, docId)
-    })
-
-    await t.test('returns true without writing when locking disabled', async () => {
-      const docId = `lock-disabled-${Date.now()}`
-      const created = await createLock(baseConfig, docId, {
-        enableLocking: false,
-        username: 'anyone'
-      })
-      assert.strictEqual(created, true)
-
-      const response = await fetchLockDoc(docId)
-      assert.strictEqual(response.statusCode, 404)
-    })
-
-    await t.test('returns false on conflict and keeps existing lock', async () => {
-      const docId = `lock-conflict-${Date.now()}`
-      await createLock(baseConfig, docId, {
-        enableLocking: true,
-        username: 'alice'
-      })
-      const created = await createLock(baseConfig, docId, {
-        enableLocking: true,
-        username: 'bob'
-      })
-      assert.strictEqual(created, false)
-
-      const response = await fetchLockDoc(docId)
-      assert.strictEqual(response.statusCode, 200)
-      const body = response.body as { lockedBy: string }
-      assert.strictEqual(body.lockedBy, 'alice')
-    })
-
-    await t.test('removes lock when owned by caller', async () => {
-      const docId = `lock-remove-${Date.now()}`
-      await createLock(baseConfig, docId, {
-        enableLocking: true,
-        username: 'alice'
-      })
-      await removeLock(baseConfig, docId, {
-        enableLocking: true,
-        username: 'alice'
-      })
-
-      const response = await fetchLockDoc(docId)
-      assert.strictEqual(response.statusCode, 404)
-    })
-
-    await t.test('skips removal when lock owned by someone else', async () => {
-      const docId = `lock-remove-others-${Date.now()}`
-      await createLock(baseConfig, docId, {
-        enableLocking: true,
-        username: 'alice'
-      })
-      await removeLock(baseConfig, docId, {
-        enableLocking: true,
-        username: 'bob'
-      })
-
-      const response = await fetchLockDoc(docId)
-      assert.strictEqual(response.statusCode, 200)
-      const body = response.body as { lockedBy: string }
-      assert.strictEqual(body.lockedBy, 'alice')
-    })
-
-    await t.test('respects disabled removal', async () => {
-      const docId = `lock-disabled-remove-${Date.now()}`
-      await createLock(baseConfig, docId, {
-        enableLocking: true,
-        username: 'alice'
-      })
-      await removeLock(baseConfig, docId, {
-        enableLocking: false,
-        username: 'alice'
-      })
-
-      const response = await fetchLockDoc(docId)
-      assert.strictEqual(response.statusCode, 200)
-    })
-  })
-})

package/impl/sugar/watch.test.mts

@@ -1,155 +0,0 @@
-import assert from 'node:assert/strict'
-import test, { suite } from 'node:test'
-import { EventEmitter } from 'node:events'
-import needle from 'needle'
-import type { CouchConfigInput } from '../../schema/config.mts'
-import { watchDocs } from './watch.mts'
-
-class FakeRequest extends EventEmitter {
-  destroyed = false
-
-  destroy() {
-    this.destroyed = true
-    this.emit('close')
-  }
-}
-
-type NeedleRequest = ReturnType<typeof needle.get>
-
-const baseConfig = (): CouchConfigInput => ({
-  couch: 'http://localhost:5984/watch-test'
-})
-
-const waitFor = async (predicate: () => boolean, timeoutMs = 2000, intervalMs = 10) => {
-  const startedAt = Date.now()
-  while (Date.now() - startedAt <= timeoutMs) {
-    if (predicate()) return
-    await new Promise(resolve => {
-      setTimeout(resolve, intervalMs)
-    })
-  }
-  throw new Error('waitFor timed out')
-}
-
-suite('watchDocs', () => {
-  test('requires at least one document id', () => {
-    assert.throws(() => {
-      watchDocs(baseConfig(), [], () => {})
-    }, /non-empty array/)
-  })
-
-  test('rejects more than 100 document ids', () => {
-    const ids = Array.from({ length: 101 }, (_, index) => `doc-${index}`)
-    assert.throws(() => {
-      watchDocs(baseConfig(), ids, () => {})
-    }, /100 or fewer elements/)
-  })
-
-  test('emits change events for streamed chunks', async t => {
-    const requests: FakeRequest[] = []
-    const getMock = t.mock.method(needle, 'get', () => {
-      const request = new FakeRequest()
-      requests.push(request)
-      return request as unknown as NeedleRequest
-    })
-    t.after(() => {
-      getMock.mock.restore()
-    })
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const changes: any[] = []
-    const watcher = watchDocs(
-      baseConfig(),
-      ['doc-a', 'doc-b'],
-      change => {
-        changes.push(change)
-      },
-      { include_docs: true }
-    )
-
-    await waitFor(() => requests.length === 1)
-    const firstRequest = requests[0]
-
-    firstRequest.emit('data', Buffer.from('{"id":"doc-a","seq":"1"}\n{"id":"doc-b","seq":"2"}\n'))
-
-    await waitFor(() => changes.length === 2)
-
-    assert.deepStrictEqual(
-      changes.map(change => change.id),
-      ['doc-a', 'doc-b']
-    )
-    const firstArg = getMock.mock.calls[0].arguments[0]
-    if (typeof firstArg !== 'string') {
-      throw new Error('Expected first argument to be a string')
-    }
-    assert.match(firstArg, /include_docs=true/)
-    assert.match(firstArg, /doc_ids=\["doc-a","doc-b"\]/)
-
-    watcher.stop()
-  })
-
-  test('reconnects after retryable response status', async t => {
-    const requests: FakeRequest[] = []
-    const getMock = t.mock.method(needle, 'get', () => {
-      const request = new FakeRequest()
-      requests.push(request)
-      return request as unknown as NeedleRequest
-    })
-    t.after(() => {
-      getMock.mock.restore()
-    })
-
-    const watcher = watchDocs(baseConfig(), 'doc-retry', () => {}, {
-      initialDelay: 1,
-      maxDelay: 1,
-      maxRetries: 3
-    })
-
-    await waitFor(() => requests.length === 1)
-    const firstRequest = requests[0]
-    firstRequest.emit('response', { statusCode: 503 })
-
-    await waitFor(() => requests.length === 2)
-
-    assert.ok(firstRequest.destroyed)
-    assert.strictEqual(getMock.mock.callCount(), 2)
-
-    watcher.stop()
-  })
-
-  test('emits error after exhausting retries', async t => {
-    const requests: FakeRequest[] = []
-    const getMock = t.mock.method(needle, 'get', () => {
-      const request = new FakeRequest()
-      requests.push(request)
-      return request as unknown as NeedleRequest
-    })
-    t.after(() => {
-      getMock.mock.restore()
-    })
-
-    const errors: Error[] = []
-    const watcher = watchDocs(baseConfig(), 'doc-max', () => {}, {
-      maxRetries: 2,
-      initialDelay: 1,
-      maxDelay: 1
-    })
-    watcher.on('error', err => {
-      errors.push(err as unknown as Error)
-    })
-
-    await waitFor(() => requests.length === 1)
-    requests[0].emit('error', { code: 'ECONNRESET' })
-
-    await waitFor(() => requests.length === 2)
-    requests[1].emit('error', { code: 'ECONNRESET' })
-
-    await waitFor(() => requests.length === 3)
-    requests[2].emit('error', { code: 'ECONNRESET' })
-
-    await waitFor(() => errors.length === 1)
-    assert.strictEqual(errors[0].message, 'Max retries reached')
-
-    watcher.stop()
-  })
-})

package/impl/utils/errors.test.mts

@@ -1,58 +0,0 @@
-import assert from 'node:assert/strict'
-import test, { suite } from 'node:test'
-import { NotFoundError, RetryableError, isConflictError } from './errors.mts'
-
-suite('errors', () => {
-  test('NotFoundError exposes docId and message', () => {
-    const err = new NotFoundError('doc-123')
-    assert.strictEqual(err.name, 'NotFoundError')
-    assert.strictEqual(err.message, 'Document not found')
-    assert.strictEqual(err.docId, 'doc-123')
-  })
-
-  test('NotFoundError accepts custom message', () => {
-    const err = new NotFoundError('doc-456', 'missing doc')
-    assert.strictEqual(err.message, 'missing doc')
-  })
-
-  test('RetryableError.isRetryableStatusCode identifies retryable statuses', () => {
-    const retryable = [408, 429, 500, 502, 503, 504]
-    for (const status of retryable) {
-      assert.strictEqual(RetryableError.isRetryableStatusCode(status), true)
-    }
-    assert.strictEqual(RetryableError.isRetryableStatusCode(404), false)
-    assert.strictEqual(RetryableError.isRetryableStatusCode(undefined), false)
-  })
-
-  test('handleNetworkError wraps known network failures', () => {
-    assert.throws(
-      () => RetryableError.handleNetworkError({ code: 'ECONNRESET' }),
-      (err: unknown) =>
-        err instanceof RetryableError &&
-        err.statusCode === 503 &&
-        err.message.includes('ECONNRESET')
-    )
-  })
-
-  test('handleNetworkError rethrows unknown errors', () => {
-    const original = new Error('boom')
-    assert.throws(
-      () => RetryableError.handleNetworkError(original),
-      (err: unknown) => err === original
-    )
-  })
-
-  test('handleNetworkError rethrows unrecognized network codes', () => {
-    const networkErr = { code: 'UNKNOWN' }
-    assert.throws(
-      () => RetryableError.handleNetworkError(networkErr),
-      (err: unknown) => err === networkErr
-    )
-  })
-
-  test('isConflictError detects statusCode 409', () => {
-    assert.strictEqual(isConflictError({ statusCode: 409 }), true)
-    assert.strictEqual(isConflictError({ statusCode: 412 }), false)
-    assert.strictEqual(isConflictError(null), false)
-  })
-})

package/impl/utils/logger.test.mts

@@ -1,129 +0,0 @@
-import assert from 'node:assert/strict'
-import test, { suite } from 'node:test'
-import type { CouchConfigInput } from '../../schema/config.mts'
-import { createLogger, type Logger } from './logger.mts'
-
-const baseConfig = (): CouchConfigInput => ({
-  couch: 'http://localhost:5984'
-})
-
-suite('createLogger', () => {
-  test('returns cached logger when present', () => {
-    const cached: Logger = {
-      error: () => {},
-      warn: () => {},
-      info: () => {},
-      debug: () => {}
-    }
-    const config: CouchConfigInput = {
-      ...baseConfig(),
-      '~normalizedLogger': cached
-    }
-
-    const logger = createLogger(config)
-
-    assert.strictEqual(logger, cached)
-  })
-
-  test('uses console logger when requested', () => {
-    const errorCalls: unknown[][] = []
-    const warnCalls: unknown[][] = []
-    const infoCalls: unknown[][] = []
-    const debugCalls: unknown[][] = []
-
-    const originalError = console.error
-    const originalWarn = console.warn
-    const originalInfo = console.info
-    const originalDebug = console.debug
-
-    console.error = (...args: unknown[]) => {
-      errorCalls.push(args)
-    }
-    console.warn = (...args: unknown[]) => {
-      warnCalls.push(args)
-    }
-    console.info = (...args: unknown[]) => {
-      infoCalls.push(args)
-    }
-    console.debug = (...args: unknown[]) => {
-      debugCalls.push(args)
-    }
-
-    try {
-      const config: CouchConfigInput = {
-        ...baseConfig(),
-        useConsoleLogger: true
-      }
-
-      const logger = createLogger(config)
-
-      logger.error('boom')
-      logger.warn('warn', 123)
-      logger.info('info')
-      logger.debug('debug')
-
-      assert.strictEqual(config['~normalizedLogger'], logger)
-      assert.deepStrictEqual(errorCalls, [['boom']])
-      assert.deepStrictEqual(warnCalls, [['warn', 123]])
-      assert.deepStrictEqual(infoCalls, [['info']])
-      assert.deepStrictEqual(debugCalls, [['debug']])
-    } finally {
-      console.error = originalError
-      console.warn = originalWarn
-      console.info = originalInfo
-      console.debug = originalDebug
-    }
-  })
-
-  test('creates no-op logger when none provided', () => {
-    const config = baseConfig()
-    const logger = createLogger(config)
-
-    assert.strictEqual(config['~normalizedLogger'], logger)
-    assert.doesNotThrow(() => logger.error('noop'))
-    assert.doesNotThrow(() => logger.warn('noop'))
-    assert.doesNotThrow(() => logger.info('noop'))
-    assert.doesNotThrow(() => logger.debug('noop'))
-  })
-
-  test('wraps function logger', () => {
-    const calls: Array<{ level: string; args: unknown[] }> = []
-    const fnLogger = (level: string, ...args: unknown[]) => {
-      calls.push({ level, args })
-    }
-
-    const config: CouchConfigInput = {
-      ...baseConfig(),
-      logger: fnLogger
-    }
-
-    const logger = createLogger(config)
-    logger.info('hello', 42)
-    logger.error('problem')
-
-    assert.deepStrictEqual(calls, [
-      { level: 'info', args: ['hello', 42] },
-      { level: 'error', args: ['problem'] }
-    ])
-  })
-
-  test('fills missing methods on object logger', () => {
-    let warnCount = 0
-    const config: CouchConfigInput = {
-      ...baseConfig(),
-      logger: {
-        warn: () => {
-          warnCount++
-        }
-      }
-    }
-
-    const logger = createLogger(config)
-    logger.warn('watch out')
-
-    assert.strictEqual(warnCount, 1)
-    assert.doesNotThrow(() => logger.error('ignored'))
-    assert.doesNotThrow(() => logger.info('ignored'))
-    assert.doesNotThrow(() => logger.debug('ignored'))
-  })
-})