fix: resolve getRelations() empty array bug and add string ID shorthand
**Problem**: brain.getRelations() returned empty array when called without
parameters, making 524 imported relationships inaccessible for Workshop team.
**Root Cause**: Method only queried storage when `from` or `to` parameters
were provided. Without params, it returned empty array.
**Solution**:
- Add support for "get all" via storage.getVerbs() when no from/to provided
- Add string ID shorthand: getRelations(id) → getRelations({ from: id })
- Default limit: 100 (matching storage layer pattern)
- Production safety: warn for >10k queries without filters
- Fix broken improvedNeuralAPI.ts calls (getVerbsForNoun → getRelations)
- Fix property bugs: verb.target → verb.to, verb.verb → verb.type
**Testing**:
- 14 new integration tests covering all query patterns
- All critical tests passing (25/25)
- Backward compatible - no breaking changes
**Impact**: Resolves Workshop bug where imported relationships were invisible
This commit is contained in:
parent
0a9d7ffa65
commit
8d217f3b84
5 changed files with 605 additions and 28 deletions
424
tests/integration/get-relations-fix.test.ts
Normal file
424
tests/integration/get-relations-fix.test.ts
Normal file
|
|
@ -0,0 +1,424 @@
|
|||
/**
|
||||
* Integration Tests for getRelations() Fix (v4.1.3)
|
||||
*
|
||||
* Tests for Bug: getRelations() returns empty array when called without parameters
|
||||
* This validates that the fix allows retrieving all relationships with proper pagination
|
||||
*
|
||||
* NO MOCKS - Real integration tests with actual storage
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach } from 'vitest'
|
||||
import { Brainy } from '../../src/brainy.js'
|
||||
import { NounType, VerbType } from '../../src/types/graphTypes.js'
|
||||
import * as fs from 'fs/promises'
|
||||
|
||||
describe('getRelations() Fix (v4.1.3)', () => {
|
||||
let brain: Brainy
|
||||
const testPath = './test-brainy-get-relations-fix'
|
||||
|
||||
beforeEach(async () => {
|
||||
// Clean up test directory
|
||||
try {
|
||||
await fs.rm(testPath, { recursive: true, force: true })
|
||||
} catch {
|
||||
// Ignore if doesn't exist
|
||||
}
|
||||
|
||||
// Create fresh Brainy instance
|
||||
brain = new Brainy({
|
||||
storage: { type: 'filesystem', path: testPath }
|
||||
})
|
||||
await brain.init()
|
||||
})
|
||||
|
||||
afterEach(async () => {
|
||||
// Clean up test directory
|
||||
try {
|
||||
await fs.rm(testPath, { recursive: true, force: true })
|
||||
} catch {
|
||||
// Ignore cleanup errors
|
||||
}
|
||||
})
|
||||
|
||||
describe('Get All Relationships (No Parameters)', () => {
|
||||
it('should return all relationships when called with no parameters', async () => {
|
||||
// Create entities
|
||||
const person1 = await brain.add({ data: 'Alice', type: NounType.Person })
|
||||
const person2 = await brain.add({ data: 'Bob', type: NounType.Person })
|
||||
const person3 = await brain.add({ data: 'Charlie', type: NounType.Person })
|
||||
|
||||
// Create relationships
|
||||
await brain.relate({ from: person1, to: person2, type: VerbType.FriendOf })
|
||||
await brain.relate({ from: person2, to: person3, type: VerbType.FriendOf })
|
||||
await brain.relate({ from: person1, to: person3, type: VerbType.WorksWith })
|
||||
|
||||
// Flush to storage
|
||||
await brain.flush()
|
||||
|
||||
// Get all relationships - THIS IS THE BUG FIX!
|
||||
const relations = await brain.getRelations()
|
||||
|
||||
// Should return all 3 relationships
|
||||
expect(relations).toHaveLength(3)
|
||||
expect(relations.every(r => r.id && r.from && r.to && r.type)).toBe(true)
|
||||
})
|
||||
|
||||
it('should return empty array when no relationships exist', async () => {
|
||||
// Create entities but no relationships
|
||||
await brain.add({ data: 'Entity 1', type: NounType.Document })
|
||||
await brain.add({ data: 'Entity 2', type: NounType.Document })
|
||||
await brain.flush()
|
||||
|
||||
// Get all relationships
|
||||
const relations = await brain.getRelations()
|
||||
|
||||
// Should return empty array
|
||||
expect(relations).toHaveLength(0)
|
||||
})
|
||||
|
||||
it('should support pagination for large relationship sets', async () => {
|
||||
// Create entities
|
||||
const entities = []
|
||||
for (let i = 0; i < 10; i++) {
|
||||
entities.push(await brain.add({ data: `Entity ${i}`, type: NounType.Document }))
|
||||
}
|
||||
|
||||
// Create 20 relationships
|
||||
for (let i = 0; i < 10; i++) {
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 1) % 10],
|
||||
type: VerbType.RelatedTo
|
||||
})
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 2) % 10],
|
||||
type: VerbType.ChildOf
|
||||
})
|
||||
}
|
||||
|
||||
await brain.flush()
|
||||
|
||||
// Get first page (limit: 10)
|
||||
const page1 = await brain.getRelations({ limit: 10 })
|
||||
expect(page1).toHaveLength(10)
|
||||
|
||||
// Get second page (offset: 10, limit: 10)
|
||||
const page2 = await brain.getRelations({ offset: 10, limit: 10 })
|
||||
expect(page2).toHaveLength(10)
|
||||
|
||||
// Ensure no duplicates between pages
|
||||
const page1Ids = new Set(page1.map(r => r.id))
|
||||
const page2Ids = new Set(page2.map(r => r.id))
|
||||
const intersection = [...page1Ids].filter(id => page2Ids.has(id))
|
||||
expect(intersection).toHaveLength(0)
|
||||
})
|
||||
|
||||
it('should filter by type when getting all relationships', async () => {
|
||||
// Create entities
|
||||
const person1 = await brain.add({ data: 'Alice', type: NounType.Person })
|
||||
const person2 = await brain.add({ data: 'Bob', type: NounType.Person })
|
||||
const person3 = await brain.add({ data: 'Charlie', type: NounType.Person })
|
||||
|
||||
// Create different types of relationships
|
||||
await brain.relate({ from: person1, to: person2, type: VerbType.FriendOf })
|
||||
await brain.relate({ from: person2, to: person3, type: VerbType.FriendOf })
|
||||
await brain.relate({ from: person1, to: person3, type: VerbType.WorksWith })
|
||||
await brain.flush()
|
||||
|
||||
// Get only FriendOf relationships
|
||||
const friendRelations = await brain.getRelations({ type: VerbType.FriendOf })
|
||||
expect(friendRelations).toHaveLength(2)
|
||||
expect(friendRelations.every(r => r.type === VerbType.FriendOf)).toBe(true)
|
||||
|
||||
// Get only WorksWith relationships
|
||||
const workRelations = await brain.getRelations({ type: VerbType.WorksWith })
|
||||
expect(workRelations).toHaveLength(1)
|
||||
expect(workRelations[0].type).toBe(VerbType.WorksWith)
|
||||
})
|
||||
|
||||
it('should filter by multiple types when getting all relationships', async () => {
|
||||
// Create entities
|
||||
const entities = []
|
||||
for (let i = 0; i < 5; i++) {
|
||||
entities.push(await brain.add({ data: `Entity ${i}`, type: NounType.Person }))
|
||||
}
|
||||
|
||||
// Create relationships of different types
|
||||
await brain.relate({ from: entities[0], to: entities[1], type: VerbType.FriendOf })
|
||||
await brain.relate({ from: entities[1], to: entities[2], type: VerbType.WorksWith })
|
||||
await brain.relate({ from: entities[2], to: entities[3], type: VerbType.ChildOf })
|
||||
await brain.relate({ from: entities[3], to: entities[4], type: VerbType.FriendOf })
|
||||
await brain.flush()
|
||||
|
||||
// Get all relationships first to verify total count
|
||||
const allRelations = await brain.getRelations()
|
||||
expect(allRelations).toHaveLength(4)
|
||||
|
||||
// Get FriendOf and WorksWith relationships using type array filter
|
||||
// NOTE: Current storage layer may not support array filters directly
|
||||
// So we test each type separately and combine
|
||||
const friendRelations = await brain.getRelations({ type: VerbType.FriendOf })
|
||||
const workRelations = await brain.getRelations({ type: VerbType.WorksWith })
|
||||
|
||||
expect(friendRelations).toHaveLength(2)
|
||||
expect(workRelations).toHaveLength(1)
|
||||
expect(friendRelations.every(r => r.type === VerbType.FriendOf)).toBe(true)
|
||||
expect(workRelations.every(r => r.type === VerbType.WorksWith)).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('String ID Shorthand Syntax', () => {
|
||||
it('should support string ID shorthand: getRelations(id)', async () => {
|
||||
// Create entities
|
||||
const person1 = await brain.add({ data: 'Alice', type: NounType.Person })
|
||||
const person2 = await brain.add({ data: 'Bob', type: NounType.Person })
|
||||
const person3 = await brain.add({ data: 'Charlie', type: NounType.Person })
|
||||
|
||||
// Create relationships
|
||||
await brain.relate({ from: person1, to: person2, type: VerbType.FriendOf })
|
||||
await brain.relate({ from: person1, to: person3, type: VerbType.WorksWith })
|
||||
await brain.flush()
|
||||
|
||||
// Use string shorthand - THIS IS THE NEW SIGNATURE!
|
||||
const relations = await brain.getRelations(person1)
|
||||
|
||||
// Should return both relationships from person1
|
||||
expect(relations).toHaveLength(2)
|
||||
expect(relations.every(r => r.from === person1)).toBe(true)
|
||||
})
|
||||
|
||||
it('should be equivalent to getRelations({ from: id })', async () => {
|
||||
// Create entities and relationships
|
||||
const person1 = await brain.add({ data: 'Alice', type: NounType.Person })
|
||||
const person2 = await brain.add({ data: 'Bob', type: NounType.Person })
|
||||
await brain.relate({ from: person1, to: person2, type: VerbType.FriendOf })
|
||||
await brain.flush()
|
||||
|
||||
// Both syntaxes should return the same results
|
||||
const shorthand = await brain.getRelations(person1)
|
||||
const explicit = await brain.getRelations({ from: person1 })
|
||||
|
||||
expect(shorthand).toEqual(explicit)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Backward Compatibility', () => {
|
||||
it('should maintain existing behavior for from parameter', async () => {
|
||||
// Create entities
|
||||
const person1 = await brain.add({ data: 'Alice', type: NounType.Person })
|
||||
const person2 = await brain.add({ data: 'Bob', type: NounType.Person })
|
||||
const person3 = await brain.add({ data: 'Charlie', type: NounType.Person })
|
||||
|
||||
// Create relationships
|
||||
await brain.relate({ from: person1, to: person2, type: VerbType.FriendOf })
|
||||
await brain.relate({ from: person1, to: person3, type: VerbType.WorksWith })
|
||||
await brain.relate({ from: person2, to: person3, type: VerbType.FriendOf })
|
||||
await brain.flush()
|
||||
|
||||
// Get relationships from person1
|
||||
const relations = await brain.getRelations({ from: person1 })
|
||||
|
||||
expect(relations).toHaveLength(2)
|
||||
expect(relations.every(r => r.from === person1)).toBe(true)
|
||||
})
|
||||
|
||||
it('should maintain existing behavior for to parameter', async () => {
|
||||
// Create entities
|
||||
const person1 = await brain.add({ data: 'Alice', type: NounType.Person })
|
||||
const person2 = await brain.add({ data: 'Bob', type: NounType.Person })
|
||||
const person3 = await brain.add({ data: 'Charlie', type: NounType.Person })
|
||||
|
||||
// Create relationships
|
||||
await brain.relate({ from: person1, to: person3, type: VerbType.FriendOf })
|
||||
await brain.relate({ from: person2, to: person3, type: VerbType.WorksWith })
|
||||
await brain.flush()
|
||||
|
||||
// Get relationships to person3
|
||||
const relations = await brain.getRelations({ to: person3 })
|
||||
|
||||
expect(relations).toHaveLength(2)
|
||||
expect(relations.every(r => r.to === person3)).toBe(true)
|
||||
})
|
||||
|
||||
it('should maintain existing behavior for type filtering with from', async () => {
|
||||
// Create entities
|
||||
const person1 = await brain.add({ data: 'Alice', type: NounType.Person })
|
||||
const person2 = await brain.add({ data: 'Bob', type: NounType.Person })
|
||||
const person3 = await brain.add({ data: 'Charlie', type: NounType.Person })
|
||||
|
||||
// Create relationships
|
||||
await brain.relate({ from: person1, to: person2, type: VerbType.FriendOf })
|
||||
await brain.relate({ from: person1, to: person3, type: VerbType.WorksWith })
|
||||
await brain.flush()
|
||||
|
||||
// Get only FriendOf relationships from person1
|
||||
const relations = await brain.getRelations({
|
||||
from: person1,
|
||||
type: VerbType.FriendOf
|
||||
})
|
||||
|
||||
expect(relations).toHaveLength(1)
|
||||
expect(relations[0].type).toBe(VerbType.FriendOf)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Production Safety', () => {
|
||||
it('should handle large relationship queries efficiently', async () => {
|
||||
// Create entities for 100 unique relationships
|
||||
const entities = []
|
||||
for (let i = 0; i < 50; i++) {
|
||||
entities.push(await brain.add({ data: `Entity ${i}`, type: NounType.Document }))
|
||||
}
|
||||
|
||||
// Create 100 unique relationships (each entity connects to 2+ others)
|
||||
for (let i = 0; i < 50; i++) {
|
||||
// First connection: i -> (i+1)
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 1) % 50],
|
||||
type: VerbType.RelatedTo
|
||||
})
|
||||
// Second connection: i -> (i+2) with different type to ensure uniqueness
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 2) % 50],
|
||||
type: VerbType.ChildOf
|
||||
})
|
||||
}
|
||||
await brain.flush()
|
||||
|
||||
// Should handle query without issues
|
||||
const startTime = Date.now()
|
||||
const relations = await brain.getRelations({ limit: 100 })
|
||||
const duration = Date.now() - startTime
|
||||
|
||||
expect(relations).toHaveLength(100)
|
||||
// Should complete reasonably fast (< 1 second)
|
||||
expect(duration).toBeLessThan(1000)
|
||||
})
|
||||
|
||||
it('should respect default limit of 100', async () => {
|
||||
// Create many unique relationships (more than default limit)
|
||||
const entities = []
|
||||
for (let i = 0; i < 60; i++) {
|
||||
entities.push(await brain.add({ data: `Entity ${i}`, type: NounType.Document }))
|
||||
}
|
||||
|
||||
// Create 150 unique relationships (each entity gets 2-3 connections)
|
||||
for (let i = 0; i < 60; i++) {
|
||||
// Connection 1: i -> (i+1)
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 1) % 60],
|
||||
type: VerbType.RelatedTo
|
||||
})
|
||||
// Connection 2: i -> (i+2) with different type
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 2) % 60],
|
||||
type: VerbType.ChildOf
|
||||
})
|
||||
// Connection 3: for first 30 entities, add third connection
|
||||
if (i < 30) {
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 3) % 60],
|
||||
type: VerbType.WorksWith
|
||||
})
|
||||
}
|
||||
}
|
||||
await brain.flush()
|
||||
|
||||
// Verify we have 150 total relationships
|
||||
const allRelations = await brain.getRelations({ limit: 200 })
|
||||
expect(allRelations.length).toBe(150)
|
||||
|
||||
// Call without limit - should default to 100
|
||||
const relations = await brain.getRelations()
|
||||
|
||||
// Should return exactly 100 (default limit)
|
||||
expect(relations).toHaveLength(100)
|
||||
})
|
||||
|
||||
it('should support custom limits', async () => {
|
||||
// Create entities for 50 unique relationships
|
||||
const entities = []
|
||||
for (let i = 0; i < 25; i++) {
|
||||
entities.push(await brain.add({ data: `Entity ${i}`, type: NounType.Document }))
|
||||
}
|
||||
|
||||
// Create 50 unique relationships (2 per entity to different targets)
|
||||
for (let i = 0; i < 25; i++) {
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 1) % 25],
|
||||
type: VerbType.RelatedTo
|
||||
})
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 2) % 25],
|
||||
type: VerbType.ChildOf
|
||||
})
|
||||
}
|
||||
await brain.flush()
|
||||
|
||||
// Verify we have 50 total
|
||||
const all = await brain.getRelations({ limit: 100 })
|
||||
expect(all.length).toBe(50)
|
||||
|
||||
// Custom limit of 25
|
||||
const relations = await brain.getRelations({ limit: 25 })
|
||||
expect(relations).toHaveLength(25)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Comparison with Workshop Bug Report', () => {
|
||||
it('should reproduce and fix the Workshop team bug scenario', async () => {
|
||||
// Reproduce the exact scenario from the bug report:
|
||||
// - 524 relationships exist in GraphAdjacencyIndex
|
||||
// - brain.getRelations() was returning empty array
|
||||
|
||||
// Create entities similar to Workshop import
|
||||
const entities = []
|
||||
for (let i = 0; i < 50; i++) {
|
||||
entities.push(await brain.add({
|
||||
data: `Workshop Entity ${i}`,
|
||||
type: NounType.Document
|
||||
}))
|
||||
}
|
||||
|
||||
// Create multiple relationships (simulating import)
|
||||
for (let i = 0; i < 50; i++) {
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 1) % 50],
|
||||
type: VerbType.RelatedTo
|
||||
})
|
||||
if (i % 5 === 0) {
|
||||
await brain.relate({
|
||||
from: entities[i],
|
||||
to: entities[(i + 3) % 50],
|
||||
type: VerbType.ChildOf
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
await brain.flush()
|
||||
|
||||
// BUG FIX TEST: This should now return relationships, not empty array!
|
||||
const relations = await brain.getRelations()
|
||||
|
||||
// CRITICAL: Should NOT be empty
|
||||
expect(relations.length).toBeGreaterThan(0)
|
||||
|
||||
// Should have at least the relationships we created
|
||||
expect(relations.length).toBeGreaterThanOrEqual(50)
|
||||
|
||||
// All relations should be valid
|
||||
expect(relations.every(r =>
|
||||
r.id && r.from && r.to && r.type
|
||||
)).toBe(true)
|
||||
})
|
||||
})
|
||||
})
|
||||
Loading…
Add table
Add a link
Reference in a new issue