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

package/impl/utils/parseRows.test.mts

@@ -1,183 +0,0 @@
-import assert from 'node:assert/strict'
-import test, { suite } from 'node:test'
-import { z } from 'zod'
-import { parseRows } from './parseRows.mts'
-
-const docSchema = z.looseObject({
-  _id: z.string(),
-  count: z.number()
-})
-
-const keySchema = z.number()
-
-const valueSchema = z.looseObject({
-  rev: z.string()
-})
-
-suite('parseRows', () => {
-  test('throws when rows is not an array', async () => {
-    await assert.rejects(
-      () =>
-        parseRows(
-          {},
-          {
-            docSchema,
-            keySchema,
-            valueSchema,
-            onInvalidDoc: 'throw'
-          }
-        ),
-      err => err instanceof Error && err.message === 'invalid rows format'
-    )
-  })
-
-  test('parses rows and validates documents', async () => {
-    const rows = [
-      {
-        id: 'doc-valid',
-        key: 1,
-        value: { rev: '1-abc' },
-        doc: {
-          _id: 'doc-valid',
-          count: 42
-        }
-      },
-      {
-        id: 'doc-missing',
-        key: 2,
-        error: 'not_found',
-        doc: null,
-        value: { rev: '1-missing' }
-      }
-    ]
-
-    const result = await parseRows(rows, {
-      docSchema,
-      keySchema,
-      valueSchema,
-      onInvalidDoc: 'throw'
-    })
-
-    assert.strictEqual(result.length, 2)
-    const [valid, missing] = result
-    assert.strictEqual(valid?.id, 'doc-valid')
-    assert.strictEqual(valid?.doc?.count, 42)
-    assert.strictEqual(valid?.key, 1)
-    assert.strictEqual(valid?.value?.rev, '1-abc')
-    assert.strictEqual(missing?.id, 'doc-missing')
-    assert.strictEqual(missing?.error, 'not_found')
-    assert.strictEqual(missing?.key, 2)
-    assert.strictEqual(missing?.value?.rev, '1-missing')
-    assert.strictEqual(missing?.doc, null)
-  })
-
-  test('skips invalid documents when requested', async () => {
-    const rows = [
-      {
-        id: 'doc-valid',
-        key: 1,
-        value: { rev: '1-valid' },
-        doc: {
-          _id: 'doc-valid',
-          count: 7
-        }
-      },
-      {
-        id: 'doc-invalid',
-        key: 2,
-        value: { rev: '1-invalid' },
-        doc: {
-          _id: 'doc-invalid',
-          count: 'nope'
-        }
-      }
-    ]
-
-    const result = await parseRows(rows, {
-      docSchema,
-      keySchema,
-      valueSchema,
-      onInvalidDoc: 'skip'
-    })
-
-    assert.strictEqual(result.length, 1)
-    assert.strictEqual(result[0]?.id, 'doc-valid')
-    assert.strictEqual(result[0]?.doc?.count, 7)
-    assert.strictEqual(result[0]?.key, 1)
-  })
-
-  test('throws when a document fails validation with onInvalidDoc=throw', async () => {
-    const rows = [
-      {
-        id: 'doc-invalid',
-        key: 1,
-        value: { rev: '1-invalid' },
-        doc: {
-          _id: 'doc-invalid',
-          count: 'nope'
-        }
-      }
-    ]
-
-    await assert.rejects(
-      () =>
-        parseRows(rows, {
-          docSchema,
-          keySchema,
-          valueSchema,
-          onInvalidDoc: 'throw'
-        }),
-      err => Array.isArray(err)
-    )
-  })
-
-  test('throws when key fails validation', async () => {
-    const rows = [
-      {
-        id: 'doc-valid',
-        key: 'invalid',
-        value: { rev: '1-valid' },
-        doc: {
-          _id: 'doc-valid',
-          count: 7
-        }
-      }
-    ]
-
-    await assert.rejects(
-      () =>
-        parseRows(rows, {
-          docSchema,
-          keySchema,
-          valueSchema,
-          onInvalidDoc: 'throw'
-        }),
-      err => Array.isArray(err)
-    )
-  })
-
-  test('throws when value fails validation', async () => {
-    const rows = [
-      {
-        id: 'doc-valid',
-        key: 1,
-        value: { rev: 123 },
-        doc: {
-          _id: 'doc-valid',
-          count: 7
-        }
-      }
-    ]
-
-    await assert.rejects(
-      () =>
-        parseRows(rows, {
-          docSchema,
-          keySchema,
-          valueSchema,
-          onInvalidDoc: 'throw'
-        }),
-      err => Array.isArray(err)
-    )
-  })
-})

package/impl/utils/queryBuilder.test.mts

@@ -1,83 +0,0 @@
-import assert from 'node:assert/strict'
-import test, { suite } from 'node:test'
-import { QueryBuilder, createQuery } from './queryBuilder.mts'
-
-suite('QueryBuilder', () => {
-  test('build returns populated options', () => {
-    const options = new QueryBuilder()
-      .descending(false)
-      .endkey_docid('end-doc')
-      .endkey(['range-end'])
-      .group(false)
-      .group_level(2)
-      .include_docs(true)
-      .inclusive_end(false)
-      .key('primary')
-      .keys(['k1', { foo: 'bar' }])
-      .limit(10)
-      .reduce(false)
-      .skip(5)
-      .sorted(false)
-      .stable(true)
-      .startkey(['range-start'])
-      .startkey_docid('start-doc')
-      .update('lazy')
-      .update_seq(true)
-      .build()
-
-    assert.deepStrictEqual(options, {
-      descending: false,
-      endkey_docid: 'end-doc',
-      endkey: ['range-end'],
-      group: false,
-      group_level: 2,
-      include_docs: true,
-      inclusive_end: false,
-      key: 'primary',
-      keys: ['k1', { foo: 'bar' }],
-      limit: 10,
-      reduce: false,
-      skip: 5,
-      sorted: false,
-      stable: true,
-      startkey: ['range-start'],
-      startkey_docid: 'start-doc',
-      update: 'lazy',
-      update_seq: true
-    })
-  })
-
-  test('alias methods map to canonical fields', () => {
-    const options = new QueryBuilder()
-      .endKey(['alias-end'])
-      .startKey(['alias-start'])
-      .end_key_doc_id('alias-end-doc')
-      .start_key_doc_id('alias-start-doc')
-      .end_key(['duplicate-end'])
-      .start_key(['duplicate-start'])
-      .build()
-
-    assert.deepStrictEqual(options, {
-      endkey: ['duplicate-end'],
-      startkey: ['duplicate-start'],
-      endkey_docid: 'alias-end-doc',
-      startkey_docid: 'alias-start-doc'
-    })
-  })
-
-  test('build returns a defensive copy', () => {
-    const builder = new QueryBuilder().limit(5)
-    const first = builder.build()
-    first.limit = 42
-
-    const second = builder.build()
-
-    assert.notStrictEqual(first, second)
-    assert.strictEqual(second.limit, 5)
-  })
-
-  test('createQuery returns a builder instance', () => {
-    const builder = createQuery()
-    assert.ok(builder instanceof QueryBuilder)
-  })
-})

package/impl/utils/queryString.test.mts

@@ -1,53 +0,0 @@
-import assert from 'node:assert/strict'
-import test, { suite } from 'node:test'
-import { queryString } from './queryString.mts'
-import type { ViewOptions } from '../../schema/couch/couch.input.schema.ts'
-
-const keysToQuote: Array<keyof ViewOptions> = [
-  'endkey_docid',
-  'endkey',
-  'key',
-  'keys',
-  'startkey',
-  'startkey_docid',
-  'update'
-]
-
-suite('queryString', () => {
-  test('queryString quotes string values for KEYS_TO_QUOTE except keys array', () => {
-    const encodedByKey = new Map<string, string | null>()
-
-    for (const key of keysToQuote) {
-      if (key === 'keys') continue
-      const optionValue: ViewOptions = {
-        [key]: key === 'update' ? 'lazy' : 'banana'
-      } as ViewOptions
-      const encoded = queryString(optionValue)
-      const params = new URLSearchParams(encoded)
-      encodedByKey.set(key as string, params.get(key as string))
-    }
-
-    assert.deepEqual(Object.fromEntries(encodedByKey), {
-      endkey_docid: '"banana"',
-      endkey: '"banana"',
-      key: '"banana"',
-      startkey: '"banana"',
-      startkey_docid: '"banana"',
-      update: '"lazy"'
-    })
-  })
-
-  test('queryString leaves primitive options outside KEYS_TO_QUOTE unchanged', () => {
-    const encoded = queryString({ descending: true })
-    const params = new URLSearchParams(encoded)
-    assert.equal(params.get('descending'), 'true')
-  })
-
-  test('queryString stringifies array values for keys option', () => {
-    const encoded = queryString({
-      keys: ['alpha', null, 42, {}, { foo: 'bar' }]
-    })
-    const params = new URLSearchParams(encoded)
-    assert.equal(params.get('keys'), '["alpha",null,42,{}, {"foo":"bar"}]'.replace(' ', ''))
-  })
-})