libp2r2p 0.0.2 → 0.1.0

package/tests/idb-queue.test.js

@@ -1,153 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { IDBFactory, IDBKeyRange } from 'fake-indexeddb'
-import { createQueue } from '../idb-queue/index.js'
-
-function queueFor (factory, prefix, options = {}) {
-  return createQueue({ prefix, indexedDB: factory, ...options })
-}
-
-async function values (iterator) {
-  const out = []
-  for await (const item of iterator) out.push(item.value)
-  return out
-}
-
-test('idb queue supports ordered queue and positional operations', async () => {
-  const queue = await queueFor(new IDBFactory(), 'ordered')
-
-  await queue.push({ value: 'middle' })
-  await queue.unshift({ value: 'first' })
-  await queue.push({ value: 'last' })
-  assert.equal(await queue.setAt(1, { value: 'MIDDLE' }), 1)
-  assert.equal(await queue.insertAt(2, { value: 'between' }), 2)
-
-  assert.equal((await queue.shift()).value, 'first')
-  assert.equal((await queue.removeAt(1)).value, 'between')
-  assert.equal((await queue.shift()).value, 'MIDDLE')
-  assert.equal((await queue.pop()).value, 'last')
-  assert.equal(await queue.shift(), null)
-})
-
-test('idb queue keeps predicate parity and skips sparse removals', async () => {
-  const queue = await queueFor(new IDBFactory(), 'predicate')
-  await queue.push({ value: 'a' })
-  await queue.push({ value: 'c' })
-  assert.equal(await queue.insertWhere(item => item.value === 'c', { value: 'b' }), 1)
-  assert.equal(await queue.some(item => item.value === 'b'), true)
-  await queue.removeWhere(item => item.value === 'b')
-
-  assert.deepEqual(await values(queue.storedItems()), ['a', 'c'])
-  assert.equal((await queue.shift()).value, 'a')
-  assert.equal((await queue.shift()).value, 'c')
-  assert.equal(await queue.shift(), null)
-})
-
-test('idb queue streams live values and supports reverse snapshots', async () => {
-  const queue = await queueFor(new IDBFactory(), 'streams')
-  await queue.push({ value: 'first' })
-  await queue.push({ value: 'second' })
-
-  assert.deepEqual(await values(queue.reverseStoredItems()), ['second', 'first'])
-  const iterator = queue.items()
-  assert.equal((await iterator.next()).value.value, 'first')
-  assert.equal((await iterator.next()).value.value, 'second')
-  const pending = iterator.next()
-  await queue.push({ value: 'third' })
-  assert.equal((await pending).value.value, 'third')
-  await iterator.return()
-})
-
-test('idb queue enforces byte budgets and persists across queue instances', async () => {
-  const factory = new IDBFactory()
-  const queue = await queueFor(factory, 'capacity', { maxBytes: 450, evictionPolicy: 'fifo' })
-  await queue.push({ value: 'a'.repeat(120) })
-  await queue.push({ value: 'b'.repeat(120) })
-  await queue.push({ value: 'c'.repeat(120) })
-
-  assert.equal((await queue.shift()).value, 'b'.repeat(120))
-  assert.equal((await queue.shift()).value, 'c'.repeat(120))
-
-  const unbounded = await queueFor(factory, 'reopen')
-  await unbounded.push({ value: 'a'.repeat(120) })
-  await unbounded.push({ value: 'b'.repeat(120) })
-  await unbounded.push({ value: 'c'.repeat(120) })
-  const bounded = await queueFor(factory, 'reopen', { maxBytes: 450, evictionPolicy: 'fifo' })
-  assert.equal((await bounded.shift()).value, 'b'.repeat(120))
-  assert.equal((await bounded.shift()).value, 'c'.repeat(120))
-})
-
-test('idb queue exposes indexed equality, range, and deletion operations', async () => {
-  const queue = await queueFor(new IDBFactory(), 'indexed', {
-    indexes: {
-      byKind: 'kind',
-      byChannelTime: ['channel', 'time'],
-      byKey: { keyPath: 'key', unique: true }
-    }
-  })
-  await queue.push({ value: 'a', kind: 'message', channel: 'one', time: 10, key: 'a' })
-  await queue.push({ value: 'b', kind: 'message', channel: 'one', time: 20, key: 'b' })
-  await queue.push({ value: 'c', kind: 'seed', channel: 'two', time: 30, key: 'c' })
-
-  assert.equal((await queue.getBy('byKey', 'b')).value, 'b')
-  assert.equal(await queue.someBy('byKind', 'seed'), true)
-  assert.deepEqual(
-    await values(queue.storedItemsBy('byChannelTime', IDBKeyRange.bound(['one', 0], ['one', 20]))),
-    ['a', 'b']
-  )
-  assert.deepEqual((await queue.removeBy('byKind', 'message')).map(item => item.value), ['a', 'b'])
-  assert.deepEqual(await values(queue.storedItems()), ['c'])
-})
-
-test('idb queue evolves additive indexes and rejects incompatible definitions', async () => {
-  const factory = new IDBFactory()
-  const first = await queueFor(factory, 'schema', { indexes: { byKind: 'kind' } })
-  await first.push({ value: 'a', kind: 'message', channel: 'one' })
-  const second = await queueFor(factory, 'schema', {
-    indexes: { byKind: 'kind', byChannel: 'channel' }
-  })
-  assert.equal((await second.getBy('byChannel', 'one')).value, 'a')
-  await assert.rejects(
-    queueFor(factory, 'schema', { indexes: { byKind: 'channel' } }),
-    /QUEUE_INDEX_SCHEMA_MISMATCH/
-  )
-})
-
-test('idb queue supports unique compound indexes', async () => {
-  const queue = await queueFor(new IDBFactory(), 'compound', {
-    indexes: {
-      byChannelTypeEventId: {
-        keyPath: ['channel', 'type', 'event.id'],
-        unique: true
-      }
-    }
-  })
-  await queue.push({ value: 'first', channel: 'one', type: 'tell', event: { id: 'event' } })
-  await queue.push({ value: 'second', channel: 'one', type: 'reply', event: { id: 'event' } })
-  await queue.push({ value: 'third', channel: 'two', type: 'tell', event: { id: 'event' } })
-
-  assert.equal(await queue.someBy('byChannelTypeEventId', ['one', 'tell', 'event']), true)
-  await assert.rejects(
-    queue.push({ value: 'duplicate', channel: 'one', type: 'tell', event: { id: 'event' } }),
-    /ConstraintError/
-  )
-})
-
-test('idb queue rolls back failed writes without an operation journal', async () => {
-  const queue = await queueFor(new IDBFactory(), 'atomic')
-  await queue.push({ value: 'kept' })
-
-  await assert.rejects(queue.push({ value: 'bad', nonCloneable: () => {} }))
-  assert.equal((await queue.shift()).value, 'kept')
-  assert.equal(await queue.shift(), null)
-})
-
-test('idb queue rejects unavailable IndexedDB and clears atomically', async () => {
-  await assert.rejects(createQueue({ prefix: 'missing', indexedDB: null }), /IDB_UNAVAILABLE/)
-
-  const queue = await queueFor(new IDBFactory(), 'clear')
-  await queue.push({ value: 'first' })
-  await queue.push({ value: 'second' })
-  await queue.clear()
-  assert.equal(await queue.shift(), null)
-})

package/tests/idb.test.js

@@ -1,91 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { IDBFactory } from 'fake-indexeddb'
-import { run } from '../idb/index.js'
-
-function deferred () {
-  let resolve
-  let reject
-  const promise = new Promise((nextResolve, nextReject) => {
-    resolve = nextResolve
-    reject = nextReject
-  })
-  return { promise, resolve, reject }
-}
-
-function transactionDone (tx) {
-  return new Promise((resolve, reject) => {
-    tx.oncomplete = () => resolve()
-    tx.onabort = () => reject(tx.error || new Error('IDB_TRANSACTION_ABORTED'))
-    tx.onerror = () => reject(tx.error || new Error('IDB_TRANSACTION_FAILED'))
-  })
-}
-
-function openRowsDb () {
-  const indexedDB = new IDBFactory()
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open('idb-run-test', 1)
-    request.onerror = () => reject(request.error)
-    request.onupgradeneeded = () => {
-      const store = request.result.createObjectStore('rows', { keyPath: 'id' })
-      store.createIndex('byGroup', 'group')
-    }
-    request.onsuccess = () => resolve(request.result)
-  })
-}
-
-test('run performs store and index requests inside a shared transaction', async () => {
-  const db = await openRowsDb()
-  const tx = db.transaction(['rows'], 'readwrite')
-  const done = transactionDone(tx)
-
-  await run('put', [{ id: 'one', group: 'alpha', value: 1 }], 'rows', null, { db, tx })
-  await run('put', [{ id: 'two', group: 'beta', value: 2 }], 'rows', null, { db, tx })
-  const found = await run('get', ['alpha'], 'rows', 'byGroup', { db, tx })
-
-  assert.equal(found.result.id, 'one')
-  await done
-  db.close()
-})
-
-test('run supports the reusable deferred cursor pattern', async () => {
-  const db = await openRowsDb()
-  const setup = db.transaction(['rows'], 'readwrite')
-  const setupDone = transactionDone(setup)
-  await run('put', [{ id: 'one', group: 'alpha' }], 'rows', null, { db, tx: setup })
-  await run('put', [{ id: 'two', group: 'beta' }], 'rows', null, { db, tx: setup })
-  await setupDone
-
-  const tx = db.transaction(['rows'], 'readonly')
-  const done = transactionDone(tx)
-  const p = deferred()
-  let cursor = (await run('openCursor', [], 'rows', null, { db, tx, p })).result
-  const ids = []
-  while (cursor) {
-    ids.push(cursor.value.id)
-    Object.assign(p, deferred())
-    cursor.continue()
-    cursor = (await p.promise).result
-  }
-
-  assert.deepEqual(ids, ['one', 'two'])
-  await done
-  db.close()
-})
-
-test('run aborts a transaction when a request fails', async () => {
-  const db = await openRowsDb()
-  const tx = db.transaction(['rows'], 'readwrite')
-  const done = transactionDone(tx)
-
-  await run('add', [{ id: 'one', group: 'alpha' }], 'rows', null, { db, tx })
-  await assert.rejects(
-    run('add', [{ id: 'one', group: 'beta' }], 'rows', null, { db, tx })
-  )
-  await assert.rejects(done)
-
-  const read = db.transaction(['rows'], 'readonly')
-  const row = await run('get', ['one'], 'rows', null, { db, tx: read })
-  assert.equal(row.result, undefined)
-  db.close()
-})

package/tests/nip44-v3.test.js

@@ -1,73 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { getPublicKey } from 'nostr-tools'
-import { sha256 } from '@noble/hashes/sha2.js'
-
-import * as nip44v3 from '../nip44-v3/index.js'
-import { bytesToHex, hexToBytes } from '../base16/index.js'
-
-const vectors = JSON.parse(readFileSync(new URL('./fixtures/nip44v3-vectors.json', import.meta.url), 'utf8'))
-
-function pubOf (sec) {
-  return getPublicKey(hexToBytes(sec))
-}
-
-test('nip44-v3 passes the vendored upstream self-test vectors', () => {
-  const fails = []
-  const check = (section, name, cond, detail = '') => {
-    if (!cond) fails.push(`[${section}] ${name}${detail ? `: ${detail}` : ''}`)
-  }
-
-  for (const [i, v] of (vectors.encrypt_decrypt || []).entries()) {
-    const sec1 = hexToBytes(v.secret1)
-    const sec2 = hexToBytes(v.secret2)
-    const pub1 = pubOf(v.secret1)
-    const pub2 = pubOf(v.secret2)
-    const nonce = hexToBytes(v.nonce)
-    const scope = hexToBytes(v.scope_hex)
-    const plaintext = hexToBytes(v.plaintext_hex)
-    const keys = nip44v3.deriveKeys(sec1, pub2, nonce)
-    check('encrypt_decrypt', `ed[${i}] prk`, bytesToHex(keys.prk) === v.prk)
-    check('encrypt_decrypt', `ed[${i}] encryption_key`, bytesToHex(keys.encryption_key) === v.encryption_key)
-    check('encrypt_decrypt', `ed[${i}] mac_key`, bytesToHex(keys.mac_key) === v.mac_key)
-    check('encrypt_decrypt', `ed[${i}] encrypt party1`, nip44v3.encryptBytes(sec1, pub2, v.kind, scope, plaintext, nonce) === v.ciphertext)
-    check('encrypt_decrypt', `ed[${i}] encrypt party2`, nip44v3.encryptBytes(sec2, pub1, v.kind, scope, plaintext, nonce) === v.ciphertext)
-    check('encrypt_decrypt', `ed[${i}] decrypt party1`, bytesToHex(nip44v3.decryptBytes(sec1, pub2, v.kind, scope, v.ciphertext)) === v.plaintext_hex)
-    check('encrypt_decrypt', `ed[${i}] decrypt party2`, bytesToHex(nip44v3.decryptBytes(sec2, pub1, v.kind, scope, v.ciphertext)) === v.plaintext_hex)
-  }
-
-  for (const [i, v] of (vectors.decrypt_only || []).entries()) {
-    check('decrypt_only', `do[${i}]`, bytesToHex(nip44v3.decryptBytes(hexToBytes(v.secret1), pubOf(v.secret2), v.kind, hexToBytes(v.scope_hex), v.ciphertext)) === v.plaintext_hex)
-  }
-
-  for (const [i, v] of (vectors.long_encrypt_decrypt || []).entries()) {
-    const pattern = hexToBytes(v.pattern_hex)
-    const plaintext = new Uint8Array(pattern.length * v.repeat)
-    for (let r = 0; r < v.repeat; r++) plaintext.set(pattern, r * pattern.length)
-    const scope = hexToBytes(v.scope_hex)
-    const ciphertext = nip44v3.encryptBytes(hexToBytes(v.secret1), pubOf(v.secret2), v.kind, scope, plaintext, hexToBytes(v.nonce))
-    check('long_encrypt_decrypt', `long[${i}] sha256`, bytesToHex(sha256(nip44v3.toBytes(ciphertext))) === v.ciphertext_sha256)
-    check('long_encrypt_decrypt', `long[${i}] round-trip`, bytesToHex(nip44v3.decryptBytes(hexToBytes(v.secret1), pubOf(v.secret2), v.kind, scope, ciphertext)) === bytesToHex(plaintext))
-  }
-
-  for (const row of (vectors.padded_length || [])) {
-    check('padded_length', `pad[${row[0]}]`, nip44v3.targetSize(row[0]) === row[1])
-  }
-
-  for (const [i, v] of (vectors.invalid_decryption || []).entries()) {
-    assert.throws(() => nip44v3.decryptBytes(hexToBytes(v.secret), v.public, v.kind, hexToBytes(v.scope_hex), v.ciphertext), Error, `invalid vector ${i} should reject`)
-  }
-
-  assert.deepEqual(fails, [])
-})
-
-test('nip44-v3 byte payload helpers round-trip arbitrary bytes', () => {
-  const alice = hexToBytes('1'.repeat(64))
-  const bob = hexToBytes('2'.repeat(64))
-  const plaintext = nip44v3.b64encode(new Uint8Array([0, 1, 2, 127, 128, 255]))
-  const ciphertext = nip44v3.nip07Encrypt(alice, getPublicKey(bob), '30078', 'spec.nostr.land/nip44v3', plaintext)
-
-  assert.equal(nip44v3.nip07Decrypt(bob, getPublicKey(alice), 30078, 'spec.nostr.land/nip44v3', ciphertext), plaintext)
-  assert.throws(() => nip44v3.nip07Decrypt(bob, getPublicKey(alice), 1, 'spec.nostr.land/nip44v3', ciphertext), /kind mismatch/)
-})