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

package/impl/put.test.mts

@@ -1,114 +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 { put } from './put.mts'
-import { RetryableError } from './utils/errors.mts'
-import { TEST_DB_URL } from '../test/setup-db.mts'
-
-const baseConfig: CouchConfigInput = {
-  couch: TEST_DB_URL
-}
-
-type DocBody = Record<string, unknown>
-
-async function getDoc(id: string) {
-  return needle('get', `${TEST_DB_URL}/${id}`, null, { json: true })
-}
-
-async function saveDoc(id: string, body: DocBody) {
-  const response = await needle('put', `${TEST_DB_URL}/${id}`, { _id: id, ...body }, { json: true })
-  if (response.statusCode !== 201 && response.statusCode !== 200) {
-    throw new Error(`Failed to save document ${id}: ${response.statusCode}`)
-  }
-
-  return response.body as { rev: string }
-}
-
-suite('put', () => {
-  test('rejects invalid config arguments', async () => {
-    await assert.rejects(async () => {
-      // @ts-expect-error testing invalid config
-      await put({ couch: DB_URL, unsupported: true }, { _id: 'bad-config-doc' })
-    })
-  })
-
-  test('propagates retryable network failures', async () => {
-    const offlineConfig: CouchConfigInput = {
-      couch: 'http://localhost:6555/offline-put-test'
-    }
-
-    await assert.rejects(
-      () => put(offlineConfig, { _id: 'offline-doc', kind: 'offline' }),
-      (err: unknown) => err instanceof RetryableError && err.statusCode === 503
-    )
-  })
-
-  test('integration with pouchdb-server', async t => {
-    let initialRev: string | undefined
-    const put_doc_id = `put-doc-${Date.now()}`
-
-    await t.test('creates documents via PUT', async () => {
-      const result = await put(baseConfig, {
-        _id: put_doc_id,
-        type: 'integration',
-        count: 1
-      })
-      assert.ok(result)
-      assert.strictEqual(result.ok, true)
-      assert.strictEqual(result.id, put_doc_id)
-      assert.strictEqual(result.statusCode, 201)
-      assert.ok(typeof result.rev === 'string')
-      initialRev = result.rev
-
-      const { statusCode, body } = await getDoc(put_doc_id)
-      assert.strictEqual(statusCode, 200)
-      assert.strictEqual(body?.type, 'integration')
-      assert.strictEqual(body?.count, 1)
-    })
-
-    await t.test('updates documents when revision supplied', async () => {
-      if (!initialRev) throw new Error('Expected initial revision to be captured')
-
-      const updateResult = await put(baseConfig, {
-        _id: put_doc_id,
-        _rev: initialRev,
-        type: 'integration',
-        count: 2
-      })
-      assert.ok(updateResult)
-      assert.strictEqual(updateResult.ok, true)
-      assert.strictEqual(updateResult.statusCode, 201)
-      assert.ok(typeof updateResult.rev === 'string')
-
-      const { body } = await getDoc(put_doc_id)
-      assert.strictEqual(body?.count, 2)
-      initialRev = updateResult.rev
-    })
-
-    await t.test('reports conflicts when revision is stale', async () => {
-      if (!initialRev) throw new Error('Expected revision to be captured')
-      const staleRev = initialRev
-      const latest = await saveDoc(put_doc_id, {
-        _rev: staleRev,
-        type: 'integration',
-        count: 3
-      })
-
-      const result = await put(baseConfig, {
-        _id: put_doc_id,
-        _rev: staleRev,
-        type: 'integration',
-        count: 4
-      })
-      assert.ok(result)
-      assert.strictEqual(result.ok, false)
-      assert.strictEqual(result.error, 'conflict')
-      assert.strictEqual(result.statusCode, 409)
-
-      const { body } = await getDoc(put_doc_id)
-      assert.strictEqual(body?.count, 3)
-      initialRev = latest.rev
-    })
-  })
-})

package/impl/query.test.mts

@@ -1,280 +0,0 @@
-import assert from 'node:assert/strict'
-import test, { suite } from 'node:test'
-import needle from 'needle'
-import { randomUUID } from 'node:crypto'
-import { setTimeout as delay } from 'node:timers/promises'
-import { z } from 'zod'
-
-import type { CouchConfigInput } from '../schema/config.mts'
-import { TEST_DB_URL } from '../test/setup-db.mts'
-import { query } from './query.mts'
-import { RetryableError } from './utils/errors.mts'
-
-const config: CouchConfigInput = {
-  couch: TEST_DB_URL
-}
-
-async function putDoc(doc: Record<string, unknown> & { _id: string }) {
-  await needle('put', `${TEST_DB_URL}/${doc._id}`, doc, { json: true })
-}
-
-async function putDesignDoc(id: string, viewName: string, mapFn: string) {
-  await needle(
-    'put',
-    `${TEST_DB_URL}/_design/${id}`,
-    {
-      views: {
-        [viewName]: {
-          map: mapFn
-        }
-      }
-    },
-    { json: true }
-  )
-}
-
-async function eventually<T>(
-  fn: () => Promise<T>,
-  predicate: (value: T) => boolean,
-  attempts = 10,
-  waitMs = 100
-): Promise<T> {
-  let lastValue: T | undefined
-  for (let attempt = 0; attempt < attempts; attempt++) {
-    lastValue = await fn()
-    if (predicate(lastValue)) return lastValue
-    await delay(waitMs)
-  }
-  return lastValue!
-}
-
-suite('query', () => {
-  test('returns rows with include_docs', async () => {
-    const designId = `query-view-${randomUUID()}`
-    const viewName = 'byCategory'
-    const tag = `query-suite-${randomUUID()}`
-    await putDesignDoc(
-      designId,
-      viewName,
-      `function(doc) { if (doc.tag !== '${tag}') return; emit(doc.category, doc.count); }`
-    )
-
-    const matchingDoc = {
-      _id: `doc-${randomUUID()}`,
-      tag,
-      category: 'keep',
-      count: 42
-    }
-    const otherDoc = {
-      _id: `doc-${randomUUID()}`,
-      tag,
-      category: 'skip',
-      count: 1
-    }
-    const unrelatedDoc = {
-      _id: `doc-${randomUUID()}`,
-      tag: 'other',
-      category: 'keep',
-      count: 100
-    }
-
-    await putDoc(matchingDoc)
-    await putDoc(otherDoc)
-    await putDoc(unrelatedDoc)
-
-    const response = await eventually(
-      () =>
-        query(config, `_design/${designId}/_view/${viewName}`, {
-          include_docs: true,
-          key: matchingDoc.category
-        }),
-      ({ rows }) => rows?.length === 1
-    )
-
-    if (!response.rows) {
-      throw new Error('Expected rows in response')
-    }
-
-    assert.strictEqual(response.rows[0].key, matchingDoc.category)
-    assert.strictEqual(response.rows[0].value, matchingDoc.count)
-    assert.strictEqual(response.rows[0].doc?._id, matchingDoc._id)
-  })
-
-  test('validates rows when schemas provided', async () => {
-    const designId = `query-validate-${randomUUID()}`
-    const viewName = 'byPlayer'
-    const tag = `query-suite-${randomUUID()}`
-    await putDesignDoc(
-      designId,
-      viewName,
-      `function(doc) { if (doc.tag !== '${tag}') return; emit(doc.player, doc.score); }`
-    )
-
-    const doc = { _id: `doc-${randomUUID()}`, tag, player: 'alpha', score: 7 }
-    await putDoc(doc)
-
-    const response = await eventually(
-      () =>
-        query(config, `_design/${designId}/_view/${viewName}`, {
-          include_docs: true,
-          key: doc.player,
-          validate: {
-            docSchema: z.looseObject({
-              _id: z.string(),
-              tag: z.string(),
-              player: z.string(),
-              score: z.number()
-            }),
-            keySchema: z.string(),
-            valueSchema: z.number()
-          }
-        }),
-      ({ rows }) => rows.length === 1
-    )
-
-    assert.strictEqual(response.rows[0]?.value, doc.score)
-    assert.strictEqual(response.rows[0]?.doc?.player, doc.player)
-  })
-
-  test('rejects when validation fails', async () => {
-    const designId = `query-invalid-${randomUUID()}`
-    const viewName = 'byPlayer'
-    const tag = `query-suite-${randomUUID()}`
-    await putDesignDoc(
-      designId,
-      viewName,
-      `function(doc) { if (doc.tag !== '${tag}') return; emit(doc.player, doc.score); }`
-    )
-
-    const validDoc = {
-      _id: `doc-${randomUUID()}`,
-      tag,
-      player: 'valid',
-      score: 3
-    }
-    const invalidDoc = {
-      _id: `doc-${randomUUID()}`,
-      tag,
-      player: 'invalid',
-      score: 'nope'
-    }
-
-    await putDoc(validDoc)
-    await putDoc(invalidDoc)
-
-    await eventually(
-      () =>
-        query(config, `_design/${designId}/_view/${viewName}`, {
-          key: validDoc.player
-        }),
-      ({ rows }) => rows?.length === 1
-    )
-
-    await assert.rejects(async () => {
-      return query(config, `_design/${designId}/_view/${viewName}`, {
-        validate: {
-          valueSchema: z.number()
-        }
-      })
-    })
-  })
-
-  test('skips invalid documents when onInvalidDoc=skip', async () => {
-    const designId = `query-skip-${randomUUID()}`
-    const viewName = 'byPlayer'
-    const tag = `query-suite-${randomUUID()}`
-    await putDesignDoc(
-      designId,
-      viewName,
-      `function(doc) { if (doc.tag !== '${tag}') return; emit(doc.player, doc.score); }`
-    )
-
-    const validDoc = {
-      _id: `doc-${randomUUID()}`,
-      tag,
-      player: 'valid',
-      score: 5
-    }
-    const invalidDoc = {
-      _id: `doc-${randomUUID()}`,
-      tag,
-      player: 'invalid',
-      score: 'nope'
-    }
-
-    await putDoc(validDoc)
-    await putDoc(invalidDoc)
-
-    const response = await eventually(
-      () =>
-        query(config, `_design/${designId}/_view/${viewName}`, {
-          include_docs: true,
-          validate: {
-            docSchema: z.looseObject({
-              _id: z.string(),
-              tag: z.string(),
-              player: z.string(),
-              score: z.number()
-            }),
-            keySchema: z.string(),
-            valueSchema: z.number(),
-            onInvalidDoc: 'skip'
-          }
-        }),
-      ({ rows }) => rows.length === 1
-    )
-
-    assert.strictEqual(response.rows[0]?.doc?.player, validDoc.player)
-  })
-
-  test('posts payload when keys exceed URL limit', async () => {
-    const designId = `query-post-${randomUUID()}`
-    const viewName = 'byPlayer'
-    const tag = `query-suite-${randomUUID()}`
-    await putDesignDoc(
-      designId,
-      viewName,
-      `function(doc) { if (doc.tag !== '${tag}') return; emit(doc.player, doc.score); }`
-    )
-
-    const targetDoc = {
-      _id: `doc-${randomUUID()}`,
-      tag,
-      player: 'target',
-      score: 11
-    }
-    await putDoc(targetDoc)
-
-    await eventually(
-      () =>
-        query(config, `_design/${designId}/_view/${viewName}`, {
-          key: targetDoc.player
-        }),
-      ({ rows }) => rows?.length === 1
-    )
-
-    const bulkKeys = Array.from({ length: 400 }, (_, index) => `missing-${index}-${randomUUID()}`)
-    bulkKeys.push(targetDoc.player)
-
-    const response = await query(config, `_design/${designId}/_view/${viewName}`, {
-      include_docs: true,
-      keys: bulkKeys
-    })
-
-    if (!response.rows) throw new Error('Expected rows in response')
-    assert.strictEqual(response.rows.length, 1)
-    assert.strictEqual(response.rows[0]?.key, targetDoc.player)
-    assert.strictEqual(response.rows[0]?.doc?._id, targetDoc._id)
-  })
-
-  test('throws RetryableError on network failure', async () => {
-    const offlineConfig: CouchConfigInput = {
-      couch: 'http://localhost:6553/offline-db'
-    }
-
-    await assert.rejects(
-      () => query(offlineConfig, '_all_docs', {}),
-      (err: unknown) => err instanceof RetryableError && err.statusCode === 503
-    )
-  })
-})

package/impl/remove.test.mts

@@ -1,82 +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 { remove } from './remove.mts'
-import { RetryableError } from './utils/errors.mts'
-import { TEST_DB_URL } from '../test/setup-db.mts'
-
-const baseConfig: CouchConfigInput = {
-  couch: TEST_DB_URL
-}
-
-type DocBody = Record<string, unknown>
-
-async function saveDoc(id: string, body: DocBody) {
-  const response = await needle(
-    'put',
-    `${TEST_DB_URL}/${id}`,
-    {
-      _id: id,
-      ...body
-    },
-    { json: true }
-  )
-
-  if (response.statusCode !== 201 && response.statusCode !== 200) {
-    throw new Error(`Failed to save document ${id}: ${response.statusCode}`)
-  }
-
-  return response.body as { rev: string }
-}
-
-async function getDoc(id: string) {
-  return needle('get', `${TEST_DB_URL}/${id}`, null, { json: true })
-}
-
-suite('remove', () => {
-  test('it should throw if provided config is invalid', async () => {
-    await assert.rejects(async () => {
-      await remove(
-        // @ts-expect-error testing invalid config
-        { couch: DB_URL, useConsoleLogger: true, unexpected: true },
-        'doc-invalid-config',
-        '1-invalid'
-      )
-    })
-  })
-
-  test('integration with pouchdb-server', async t => {
-    await t.test('removes an existing document', async () => {
-      const remove_doc_id = `remove-doc-1-${Date.now()}`
-      const { rev } = await saveDoc(remove_doc_id, { kind: 'test', count: 1 })
-
-      const result = await remove(baseConfig, remove_doc_id, rev)
-      assert.strictEqual(result.ok, true)
-      assert.strictEqual(result.id, remove_doc_id)
-      assert.strictEqual(result.statusCode, 200)
-
-      const { statusCode, body } = await getDoc(remove_doc_id)
-      assert.strictEqual(statusCode, 404)
-      assert.strictEqual(body?.error, 'not_found')
-    })
-
-    await t.test('returns not found metadata when document is missing', async () => {
-      const result = await remove(baseConfig, 'remove-doc-missing', '1-missing')
-      assert.strictEqual(result.ok, false)
-      assert.strictEqual(result.error, 'not_found')
-      assert.strictEqual(result.statusCode, 404)
-    })
-
-    await t.test('propagates retryable network errors', async () => {
-      const offlineConfig: CouchConfigInput = {
-        couch: 'http://localhost:6553/offline-remove-db'
-      }
-
-      await assert.rejects(
-        () => remove(offlineConfig, 'remove-doc-network', '1-offline'),
-        (err: unknown) => err instanceof RetryableError && err.statusCode === 503
-      )
-    })
-  })
-})

package/impl/retry.test.mts

@@ -1,77 +0,0 @@
-import assert from 'node:assert/strict'
-import test, { suite } from 'node:test'
-import { withRetry } from './retry.mts'
-import { RetryableError } from './utils/errors.mts'
-
-suite('withRetry', () => {
-  test('resolves when the wrapped function succeeds without retries', async () => {
-    let count = 0
-    const fn = async (value: string) => {
-      count += 1
-      return value
-    }
-
-    const wrapped = withRetry(fn)
-    const result = await wrapped('ok')
-
-    assert.strictEqual(result, 'ok')
-    assert.strictEqual(count, 1)
-  })
-
-  test('retries on RetryableError until success', async () => {
-    let attempts = 0
-    const fn = async () => {
-      attempts += 1
-      if (attempts < 3) {
-        throw new RetryableError('temporary', 503)
-      }
-      return 'done'
-    }
-
-    const wrapped = withRetry(fn, { initialDelay: 0, maxDelay: 0 })
-    const result = await wrapped()
-
-    assert.strictEqual(result, 'done')
-    assert.strictEqual(attempts, 3)
-  })
-
-  test('propagates non retryable errors immediately', async () => {
-    let attempts = 0
-    const fn = async () => {
-      attempts += 1
-      throw new Error('fatal')
-    }
-
-    const wrapped = withRetry(fn, { initialDelay: 0, maxDelay: 0 })
-
-    await assert.rejects(
-      () => wrapped(),
-      (err: unknown) => {
-        return err instanceof Error && !(err instanceof RetryableError) && err.message === 'fatal'
-      }
-    )
-    assert.strictEqual(attempts, 1)
-  })
-
-  test('throws after exceeding the maximum retries', async () => {
-    let attempts = 0
-    const fn = async () => {
-      attempts += 1
-      throw new RetryableError('still failing', 503)
-    }
-
-    const wrapped = withRetry(fn, {
-      maxRetries: 2,
-      initialDelay: 0,
-      maxDelay: 0
-    })
-
-    await assert.rejects(
-      () => wrapped(),
-      (err: unknown) => {
-        return err instanceof RetryableError && err.message === 'still failing'
-      }
-    )
-    assert.strictEqual(attempts, 3)
-  })
-})