David Snelling
6a89adc468
related() with a verb-type ARRAY returned edges for only the first type — the storage fast paths collapsed `verbType` (and, in their sibling blocks, `sourceId` and `targetId`) arrays to their first element, silently dropping the rest of the ask. Every consumer passing a verb list under-traversed with no error and no narration: the same quiet-loss class as the graph-first paging defect, one seam over. All four fast paths now union over the full requested set, deduped by edge id, before the metadata filters and pagination run. Pinned in tests/integration/related-verb-array.test.ts: the second requested type's edge returns in both array orders, on the anchor side, the target side, and the type-only path; a one-element array equals the scalar; no duplicates on overlap; pagination walks the union consistently.
89 lines
3.8 KiB
TypeScript
89 lines
3.8 KiB
TypeScript
/**
|
|
* @module tests/integration/related-verb-array
|
|
* @description related() honours EVERY verb type in an array (10.4.9).
|
|
*
|
|
* The storage fast paths for `sourceId + verbType` and `verbType` collapsed a
|
|
* verb-type ARRAY to its first element — `related({ from, type: [a, b] })`
|
|
* silently returned only `a` edges, whichever order the array came in. The
|
|
* same quiet-loss class as the graph-first paging defect, one seam over.
|
|
* These pins seed a store where the SECOND requested type's edge must come
|
|
* back, on every path the collapse lived in.
|
|
*/
|
|
import { describe, it, expect, beforeAll, afterAll } from 'vitest'
|
|
import { Brainy } from '../../src/brainy'
|
|
import { NounType, VerbType } from '../../src/types/graphTypes'
|
|
import { v5 } from '../../src/universal/uuid'
|
|
|
|
describe('related() with a verb-type array returns every requested type', () => {
|
|
let brain: Brainy<any>
|
|
|
|
beforeAll(async () => {
|
|
brain = new Brainy({ requireSubtype: false, storage: { type: 'memory' } })
|
|
await brain.init()
|
|
for (const id of ['a', 'b', 'c', 'd']) {
|
|
await brain.add({ id, data: `node ${id}`, type: NounType.Person })
|
|
}
|
|
await brain.relate({ from: 'a', to: 'b', type: VerbType.Supports })
|
|
await brain.relate({ from: 'a', to: 'c', type: VerbType.RelatedTo })
|
|
await brain.relate({ from: 'a', to: 'd', type: VerbType.Knows })
|
|
await brain.relate({ from: 'b', to: 'c', type: VerbType.RelatedTo })
|
|
})
|
|
|
|
afterAll(async () => {
|
|
brain = null as any
|
|
})
|
|
|
|
it('from + type array: the second type\'s edge comes back, both orders', async () => {
|
|
for (const types of [
|
|
[VerbType.Supports, VerbType.RelatedTo],
|
|
[VerbType.RelatedTo, VerbType.Supports]
|
|
]) {
|
|
const edges = await brain.related({ from: 'a', type: types })
|
|
const targets = new Set(edges.map((e) => e.to))
|
|
expect(targets.has(v5('b')), `types [${types}] missing Supports edge`).toBe(true)
|
|
expect(targets.has(v5('c')), `types [${types}] missing RelatedTo edge`).toBe(true)
|
|
expect(targets.has(v5('d'))).toBe(false)
|
|
expect(edges).toHaveLength(2)
|
|
}
|
|
})
|
|
|
|
it('a single-element array behaves exactly like the scalar', async () => {
|
|
const scalar = await brain.related({ from: 'a', type: VerbType.Supports })
|
|
const array = await brain.related({ from: 'a', type: [VerbType.Supports] })
|
|
expect(array.map((e) => e.id).sort()).toEqual(scalar.map((e) => e.id).sort())
|
|
expect(array).toHaveLength(1)
|
|
})
|
|
|
|
it('no duplicate edges when types overlap the same edge set', async () => {
|
|
const edges = await brain.related({
|
|
from: 'a',
|
|
type: [VerbType.Supports, VerbType.RelatedTo, VerbType.Knows]
|
|
})
|
|
const ids = edges.map((e) => e.id)
|
|
expect(new Set(ids).size).toBe(ids.length)
|
|
expect(edges).toHaveLength(3)
|
|
})
|
|
|
|
it('type-only asks (no anchor) honour the whole array too', async () => {
|
|
const edges = await brain.related({ type: [VerbType.Supports, VerbType.Knows] })
|
|
const verbs = new Set(edges.map((e) => e.type))
|
|
expect(verbs.has(VerbType.Supports)).toBe(true)
|
|
expect(verbs.has(VerbType.Knows)).toBe(true)
|
|
expect(edges).toHaveLength(2)
|
|
})
|
|
|
|
it('to + type array: the target side honours every type too', async () => {
|
|
const edges = await brain.related({ to: 'c', type: [VerbType.RelatedTo, VerbType.Supports] })
|
|
const froms = new Set(edges.map((e) => e.from))
|
|
expect(froms.has(v5('a'))).toBe(true)
|
|
expect(froms.has(v5('b'))).toBe(true)
|
|
expect(edges).toHaveLength(2)
|
|
})
|
|
|
|
it('pagination stays consistent across the union', async () => {
|
|
const page1 = await brain.related({ from: 'a', type: [VerbType.Supports, VerbType.RelatedTo, VerbType.Knows], limit: 2 })
|
|
const page2 = await brain.related({ from: 'a', type: [VerbType.Supports, VerbType.RelatedTo, VerbType.Knows], limit: 2, offset: 2 })
|
|
const all = [...page1, ...page2].map((e) => e.id)
|
|
expect(new Set(all).size).toBe(3)
|
|
})
|
|
})
|