Batch Operations

import { Brainy, NounType } from '@soulcraft/brainy'

const brain = new Brainy()
await brain.init()

// Add multiple entities
const result = await brain.addMany({
  items: [
    { data: 'Alice Smith', type: NounType.Person, metadata: { dept: 'Engineering' } },
    { data: 'Bob Jones', type: NounType.Person, metadata: { dept: 'Marketing' } },
    { data: 'Project Alpha', type: NounType.Project, metadata: { status: 'active' } }
  ]
})

console.log(`Added ${result.successful.length} entities`)
console.log(`IDs: ${result.successful}`)

const result = await brain.addMany({
  items: largeDataset,
  chunkSize: 100,          // Process in chunks of 100
  parallel: true,           // Parallel processing
  continueOnError: true,    // Don't stop on errors

  onProgress: (completed, total) => {
    const percent = ((completed / total) * 100).toFixed(1)
    console.log(`${percent}% complete (${completed}/${total})`)
  }
})

// Check for errors
if (result.failed.length > 0) {
  console.log(`${result.failed.length} items failed`)
  result.failed.forEach(f => console.log(f.error))
}

// Get multiple entities at once
const ids = ['user-1', 'user-2', 'user-3', 'user-4']
const entityMap = await brain.batchGet(ids)

// entityMap is a Map<string, Entity>
ids.forEach(id => {
  const entity = entityMap.get(id)
  if (entity) {
    console.log(`${id}: ${entity.data}`)
  } else {
    console.log(`${id}: not found`)
  }
})

// With vectors (when you need them)
const withVectors = await brain.batchGet(ids, { includeVectors: true })

// Instead of N calls for N children:
const relations = await brain.getRelations({ from: parentId })
const childIds = relations.map(r => r.to)

// Single batch call
const children = await brain.batchGet(childIds)
// 20 children on GCS: 6s -> 300ms (20x faster)

// Delete by IDs
const result = await brain.deleteMany({
  ids: ['old-1', 'old-2', 'old-3']
})

console.log(`Deleted ${result.successful.length} entities`)

// With error handling
const result2 = await brain.deleteMany({
  ids: idsToDelete,
  continueOnError: true
})

if (result2.failed.length > 0) {
  console.log('Some deletions failed:', result2.failed)
}

const result = await brain.updateMany({
  items: [
    { id: 'user-1', metadata: { status: 'active' } },
    { id: 'user-2', metadata: { status: 'active' } },
    { id: 'user-3', data: 'Updated content' }
  ],
  chunkSize: 50,
  parallel: true,

  onProgress: (completed, total) => {
    console.log(`Updated ${completed}/${total}`)
  }
})

console.log(`Updated ${result.successful.length} entities`)

import { VerbType } from '@soulcraft/brainy'

const relationIds = await brain.relateMany({
  items: [
    { from: 'alice', to: 'project-1', type: VerbType.WorksOn },
    { from: 'bob', to: 'project-1', type: VerbType.WorksOn },
    { from: 'alice', to: 'bob', type: VerbType.Mentors },
    { from: 'project-1', to: 'team-1', type: VerbType.PartOf }
  ]
})

console.log(`Created ${relationIds.length} relationships`)

{
  successful: ['id-1', 'id-2', 'id-3'],  // IDs of successful operations
  failed: [
    { id: 'id-4', error: 'Entity not found' },
    { id: 'id-5', error: 'Invalid data' }
  ]
}