fix(versioning): clean architecture with index pollution prevention
v6.3.0 Versioning System Overhaul: - Rewrite VersionIndex to use pure key-value storage (not entities) - Fix restore() to use brain.update() - updates all indexes (HNSW, metadata, graph) - Remove 525 LOC dead code (versioningAugmentation.ts - untested, unused) - Fix branch isolation in tests (fork() vs checkout() semantics) Key improvements: - Versions no longer pollute find() results - restore() properly updates all indexes - 75 tests passing (60 unit + 15 integration) - Net reduction of ~290 lines while fixing bugs 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
parent
292be1b9cd
commit
f145fa1fc8
8 changed files with 712 additions and 1002 deletions
|
|
@ -1,36 +1,48 @@
|
|||
/**
|
||||
* VersionIndex - Fast Version Lookup Using Existing Index Infrastructure (v5.3.0)
|
||||
* VersionIndex - Pure Key-Value Version Storage (v6.3.0)
|
||||
*
|
||||
* Integrates with Brainy's existing index system:
|
||||
* - Uses MetadataIndexManager for field indexing
|
||||
* - Leverages UnifiedCache for memory management
|
||||
* - Uses EntityIdMapper for efficient ID handling
|
||||
* - Uses ChunkManager for adaptive chunking
|
||||
* - Leverages Roaring Bitmaps for fast set operations
|
||||
* Stores version metadata using simple key-value storage:
|
||||
* - Version list per entity: __version_meta_{entityId}_{branch}
|
||||
* - Content stored separately by VersionStorage
|
||||
*
|
||||
* Version metadata is stored as regular entities with type='_version'
|
||||
* This allows us to use existing index infrastructure without modification!
|
||||
*
|
||||
* Fields indexed:
|
||||
* - versionEntityId: Entity being versioned
|
||||
* - versionBranch: Branch version was created on
|
||||
* - versionNumber: Version number
|
||||
* - versionTag: Optional user tag
|
||||
* - versionTimestamp: Creation timestamp
|
||||
* - versionCommitHash: Commit hash
|
||||
* Key Design Decisions:
|
||||
* - Versions are NOT entities (no brain.add())
|
||||
* - Versions do NOT pollute find() results
|
||||
* - Simple O(1) lookups per entity
|
||||
* - Versions per entity is typically small (10-1000)
|
||||
*
|
||||
* NO MOCKS - Production implementation
|
||||
*/
|
||||
|
||||
import { BaseStorage } from '../storage/baseStorage.js'
|
||||
import type { EntityVersion } from './VersionManager.js'
|
||||
import type { VersionQuery } from './VersionManager.js'
|
||||
import type { EntityVersion, VersionQuery } from './VersionManager.js'
|
||||
|
||||
/**
|
||||
* VersionIndex - Version lookup and querying using existing indexes
|
||||
* Internal storage structure for version metadata
|
||||
*/
|
||||
interface VersionMetadataStore {
|
||||
entityId: string
|
||||
branch: string
|
||||
versions: VersionEntry[]
|
||||
}
|
||||
|
||||
/**
|
||||
* Individual version entry in the store
|
||||
*/
|
||||
interface VersionEntry {
|
||||
version: number
|
||||
timestamp: number
|
||||
contentHash: string
|
||||
commitHash?: string
|
||||
tag?: string
|
||||
description?: string
|
||||
author?: string
|
||||
}
|
||||
|
||||
/**
|
||||
* VersionIndex - Pure key-value version metadata storage
|
||||
*
|
||||
* Strategy: Store version metadata as special entities with type='_version'
|
||||
* This leverages ALL existing index infrastructure automatically!
|
||||
* Uses simple JSON storage instead of creating entities.
|
||||
* This ensures versions never appear in find() results.
|
||||
*/
|
||||
export class VersionIndex {
|
||||
private brain: any // Brainy instance
|
||||
|
|
@ -42,8 +54,6 @@ export class VersionIndex {
|
|||
|
||||
/**
|
||||
* Initialize version index
|
||||
*
|
||||
* No special setup needed - we use existing entity storage and indexes!
|
||||
*/
|
||||
async initialize(): Promise<void> {
|
||||
if (this.initialized) return
|
||||
|
|
@ -53,93 +63,98 @@ export class VersionIndex {
|
|||
/**
|
||||
* Add version to index
|
||||
*
|
||||
* Stores version metadata as a special entity with type='_version'
|
||||
* This automatically indexes it using existing MetadataIndexManager!
|
||||
* Stores version entry in key-value storage.
|
||||
* Handles deduplication by content hash.
|
||||
*
|
||||
* @param version Version metadata
|
||||
* @param version Version metadata to store
|
||||
*/
|
||||
async addVersion(version: EntityVersion): Promise<void> {
|
||||
await this.initialize()
|
||||
|
||||
// Generate unique ID for version entity
|
||||
const versionEntityId = this.getVersionEntityId(
|
||||
version.entityId,
|
||||
version.version,
|
||||
version.branch
|
||||
)
|
||||
const key = this.getMetaKey(version.entityId, version.branch)
|
||||
const store = await this.loadStore(key) || {
|
||||
entityId: version.entityId,
|
||||
branch: version.branch,
|
||||
versions: []
|
||||
}
|
||||
|
||||
// Store as special entity with type='state' (version is a snapshot/state)
|
||||
// This automatically gets indexed by MetadataIndexManager!
|
||||
await this.brain.saveNounMetadata(versionEntityId, {
|
||||
id: versionEntityId,
|
||||
type: 'state', // Use standard 'state' type (version = snapshot state)
|
||||
name: `Version ${version.version} of ${version.entityId}`,
|
||||
metadata: {
|
||||
// Flag to identify as version metadata
|
||||
_isVersion: true,
|
||||
|
||||
// These fields are automatically indexed by MetadataIndexManager
|
||||
versionEntityId: version.entityId, // Entity being versioned
|
||||
versionBranch: version.branch, // Branch
|
||||
versionNumber: version.version, // Version number
|
||||
versionTag: version.tag, // Optional tag
|
||||
versionTimestamp: version.timestamp, // Timestamp (indexed with bucketing)
|
||||
versionCommitHash: version.commitHash, // Commit hash
|
||||
versionContentHash: version.contentHash, // Content hash
|
||||
versionAuthor: version.author, // Author
|
||||
versionDescription: version.description, // Description
|
||||
versionMetadata: version.metadata // Additional metadata
|
||||
// Check for duplicate content hash (deduplication)
|
||||
const existing = store.versions.find(v => v.contentHash === version.contentHash)
|
||||
if (existing) {
|
||||
// Update tag/description if provided on duplicate save
|
||||
let updated = false
|
||||
if (version.tag && version.tag !== existing.tag) {
|
||||
existing.tag = version.tag
|
||||
updated = true
|
||||
}
|
||||
if (version.description && version.description !== existing.description) {
|
||||
existing.description = version.description
|
||||
updated = true
|
||||
}
|
||||
if (updated) {
|
||||
await this.saveStore(key, store)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Add new version entry
|
||||
store.versions.push({
|
||||
version: version.version,
|
||||
timestamp: version.timestamp,
|
||||
contentHash: version.contentHash,
|
||||
commitHash: version.commitHash,
|
||||
tag: version.tag,
|
||||
description: version.description,
|
||||
author: version.author
|
||||
})
|
||||
|
||||
await this.saveStore(key, store)
|
||||
}
|
||||
|
||||
/**
|
||||
* Get versions for an entity
|
||||
*
|
||||
* Uses existing MetadataIndexManager to query efficiently!
|
||||
*
|
||||
* @param query Version query
|
||||
* @param query Version query with filters
|
||||
* @returns List of versions (newest first)
|
||||
*/
|
||||
async getVersions(query: VersionQuery): Promise<EntityVersion[]> {
|
||||
await this.initialize()
|
||||
|
||||
// Build metadata filter using existing query system
|
||||
const filters: Record<string, any> = {
|
||||
type: 'state',
|
||||
_isVersion: true,
|
||||
versionEntityId: query.entityId,
|
||||
versionBranch: query.branch
|
||||
}
|
||||
const branch = query.branch || this.brain.currentBranch
|
||||
const key = this.getMetaKey(query.entityId, branch)
|
||||
const store = await this.loadStore(key)
|
||||
if (!store) return []
|
||||
|
||||
// Add optional filters
|
||||
// Convert entries to EntityVersion format
|
||||
let versions: EntityVersion[] = store.versions.map(entry => ({
|
||||
version: entry.version,
|
||||
entityId: store.entityId,
|
||||
branch: store.branch,
|
||||
timestamp: entry.timestamp,
|
||||
contentHash: entry.contentHash,
|
||||
commitHash: entry.commitHash || '',
|
||||
tag: entry.tag,
|
||||
description: entry.description,
|
||||
author: entry.author
|
||||
}))
|
||||
|
||||
// Apply filters
|
||||
if (query.tag) {
|
||||
filters.versionTag = query.tag
|
||||
versions = versions.filter(v => v.tag === query.tag)
|
||||
}
|
||||
if (query.startDate) {
|
||||
versions = versions.filter(v => v.timestamp >= query.startDate!)
|
||||
}
|
||||
if (query.endDate) {
|
||||
versions = versions.filter(v => v.timestamp <= query.endDate!)
|
||||
}
|
||||
|
||||
// Query using existing search infrastructure
|
||||
const results = await this.brain.searchByMetadata(filters)
|
||||
|
||||
// Convert entities back to EntityVersion format
|
||||
const versions: EntityVersion[] = []
|
||||
for (const entity of results) {
|
||||
const version = this.entityToVersion(entity)
|
||||
if (version) {
|
||||
// Filter by date range if specified
|
||||
if (query.startDate && version.timestamp < query.startDate) continue
|
||||
if (query.endDate && version.timestamp > query.endDate) continue
|
||||
|
||||
versions.push(version)
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by version number (newest first)
|
||||
// Sort newest first (highest version number first)
|
||||
versions.sort((a, b) => b.version - a.version)
|
||||
|
||||
// Apply pagination
|
||||
const start = query.offset || 0
|
||||
const end = query.limit ? start + query.limit : undefined
|
||||
|
||||
return versions.slice(start, end)
|
||||
}
|
||||
|
||||
|
|
@ -156,14 +171,8 @@ export class VersionIndex {
|
|||
version: number,
|
||||
branch: string
|
||||
): Promise<EntityVersion | null> {
|
||||
await this.initialize()
|
||||
|
||||
const versionEntityId = this.getVersionEntityId(entityId, version, branch)
|
||||
|
||||
const entity = await this.brain.getNounMetadata(versionEntityId)
|
||||
if (!entity) return null
|
||||
|
||||
return this.entityToVersion(entity)
|
||||
const versions = await this.getVersions({ entityId, branch })
|
||||
return versions.find(v => v.version === version) || null
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -179,21 +188,8 @@ export class VersionIndex {
|
|||
tag: string,
|
||||
branch: string
|
||||
): Promise<EntityVersion | null> {
|
||||
await this.initialize()
|
||||
|
||||
// Query using existing metadata index
|
||||
const results = await this.brain.searchByMetadata({
|
||||
type: 'state',
|
||||
_isVersion: true,
|
||||
versionEntityId: entityId,
|
||||
versionBranch: branch,
|
||||
versionTag: tag
|
||||
})
|
||||
|
||||
if (results.length === 0) return null
|
||||
|
||||
// Return first match (tags should be unique per entity/branch)
|
||||
return this.entityToVersion(results[0])
|
||||
const versions = await this.getVersions({ entityId, branch, tag })
|
||||
return versions[0] || null
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -204,17 +200,9 @@ export class VersionIndex {
|
|||
* @returns Number of versions
|
||||
*/
|
||||
async getVersionCount(entityId: string, branch: string): Promise<number> {
|
||||
await this.initialize()
|
||||
|
||||
// Use existing search infrastructure
|
||||
const results = await this.brain.searchByMetadata({
|
||||
type: 'state',
|
||||
_isVersion: true,
|
||||
versionEntityId: entityId,
|
||||
versionBranch: branch
|
||||
})
|
||||
|
||||
return results.length
|
||||
const key = this.getMetaKey(entityId, branch)
|
||||
const store = await this.loadStore(key)
|
||||
return store?.versions.length || 0
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -231,90 +219,17 @@ export class VersionIndex {
|
|||
): Promise<void> {
|
||||
await this.initialize()
|
||||
|
||||
const versionEntityId = this.getVersionEntityId(entityId, version, branch)
|
||||
const key = this.getMetaKey(entityId, branch)
|
||||
const store = await this.loadStore(key)
|
||||
if (!store) return
|
||||
|
||||
// Delete version entity (automatically removed from indexes)
|
||||
await this.brain.deleteNounMetadata(versionEntityId)
|
||||
}
|
||||
const initialLength = store.versions.length
|
||||
store.versions = store.versions.filter(v => v.version !== version)
|
||||
|
||||
/**
|
||||
* Convert entity to EntityVersion format
|
||||
*
|
||||
* @param entity Entity from storage
|
||||
* @returns EntityVersion or null if invalid
|
||||
*/
|
||||
private entityToVersion(entity: any): EntityVersion | null {
|
||||
if (!entity || !entity.metadata) return null
|
||||
|
||||
const m = entity.metadata
|
||||
|
||||
if (
|
||||
!m.versionEntityId ||
|
||||
!m.versionBranch ||
|
||||
m.versionNumber === undefined ||
|
||||
!m.versionCommitHash ||
|
||||
!m.versionContentHash ||
|
||||
!m.versionTimestamp
|
||||
) {
|
||||
return null
|
||||
// Only save if something was removed
|
||||
if (store.versions.length < initialLength) {
|
||||
await this.saveStore(key, store)
|
||||
}
|
||||
|
||||
return {
|
||||
version: m.versionNumber,
|
||||
entityId: m.versionEntityId,
|
||||
branch: m.versionBranch,
|
||||
commitHash: m.versionCommitHash,
|
||||
timestamp: m.versionTimestamp,
|
||||
contentHash: m.versionContentHash,
|
||||
tag: m.versionTag,
|
||||
description: m.versionDescription,
|
||||
author: m.versionAuthor,
|
||||
metadata: m.versionMetadata
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate unique ID for version entity
|
||||
*
|
||||
* Format: _version:{entityId}:{version}:{branch}
|
||||
*
|
||||
* @param entityId Entity ID
|
||||
* @param version Version number
|
||||
* @param branch Branch name
|
||||
* @returns Version entity ID
|
||||
*/
|
||||
private getVersionEntityId(
|
||||
entityId: string,
|
||||
version: number,
|
||||
branch: string
|
||||
): string {
|
||||
return `_version:${entityId}:${version}:${branch}`
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all versioned entities (for cleanup/debugging)
|
||||
*
|
||||
* @returns List of entity IDs that have versions
|
||||
*/
|
||||
async getVersionedEntities(): Promise<string[]> {
|
||||
await this.initialize()
|
||||
|
||||
// Query all version entities
|
||||
const results = await this.brain.searchByMetadata({
|
||||
type: 'state',
|
||||
_isVersion: true
|
||||
})
|
||||
|
||||
// Extract unique entity IDs
|
||||
const entityIds = new Set<string>()
|
||||
for (const entity of results) {
|
||||
const version = this.entityToVersion(entity)
|
||||
if (version) {
|
||||
entityIds.add(version.entityId)
|
||||
}
|
||||
}
|
||||
|
||||
return Array.from(entityIds)
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -325,14 +240,71 @@ export class VersionIndex {
|
|||
* @returns Number of versions deleted
|
||||
*/
|
||||
async clearVersions(entityId: string, branch: string): Promise<number> {
|
||||
await this.initialize()
|
||||
const key = this.getMetaKey(entityId, branch)
|
||||
const store = await this.loadStore(key)
|
||||
if (!store) return 0
|
||||
|
||||
const versions = await this.getVersions({ entityId, branch })
|
||||
const count = store.versions.length
|
||||
|
||||
for (const version of versions) {
|
||||
await this.removeVersion(entityId, version.version, branch)
|
||||
// Delete the store by saving null/empty
|
||||
await this.saveStore(key, { entityId, branch, versions: [] })
|
||||
|
||||
return count
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all versioned entities (for cleanup/debugging)
|
||||
*
|
||||
* Note: This is an expensive operation that requires scanning.
|
||||
* In the simple key-value approach, we don't maintain a global index.
|
||||
* This method returns an empty array - use storage-level scanning if needed.
|
||||
*
|
||||
* @returns Empty array (not supported in simple approach)
|
||||
*/
|
||||
async getVersionedEntities(): Promise<string[]> {
|
||||
// In the simple key-value approach, we don't maintain a global index
|
||||
// of all versioned entities. This would require scanning storage.
|
||||
// For most use cases, you know which entities you've versioned.
|
||||
return []
|
||||
}
|
||||
|
||||
// ============= Private Helpers =============
|
||||
|
||||
/**
|
||||
* Generate storage key for version metadata
|
||||
*
|
||||
* @param entityId Entity ID
|
||||
* @param branch Branch name
|
||||
* @returns Storage key
|
||||
*/
|
||||
private getMetaKey(entityId: string, branch: string): string {
|
||||
return `__version_meta_${entityId}_${branch}`
|
||||
}
|
||||
|
||||
/**
|
||||
* Load version store from storage
|
||||
*
|
||||
* @param key Storage key
|
||||
* @returns Version store or null
|
||||
*/
|
||||
private async loadStore(key: string): Promise<VersionMetadataStore | null> {
|
||||
try {
|
||||
const store = await this.brain.storageAdapter.getMetadata(key)
|
||||
// Handle empty store
|
||||
if (!store || !store.versions) return null
|
||||
return store as VersionMetadataStore
|
||||
} catch {
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
return versions.length
|
||||
/**
|
||||
* Save version store to storage
|
||||
*
|
||||
* @param key Storage key
|
||||
* @param store Version store
|
||||
*/
|
||||
private async saveStore(key: string, store: VersionMetadataStore): Promise<void> {
|
||||
await this.brain.storageAdapter.saveMetadata(key, store)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,20 +1,26 @@
|
|||
/**
|
||||
* VersionManager - Entity-Level Versioning Engine (v5.3.0)
|
||||
* VersionManager - Entity-Level Versioning Engine (v5.3.0, v6.3.0 fix)
|
||||
*
|
||||
* Provides entity-level version control with:
|
||||
* - save() - Create entity version
|
||||
* - restore() - Restore entity to specific version
|
||||
* - restore() - Restore entity to specific version (v6.3.0: now updates all indexes)
|
||||
* - list() - List all versions of an entity
|
||||
* - compare() - Deep diff between versions
|
||||
* - prune() - Remove old versions (retention policies)
|
||||
*
|
||||
* Architecture:
|
||||
* - Hybrid storage: COW commits for full snapshots + version index for fast queries
|
||||
* Architecture (v6.3.0 - Clean Key-Value Storage):
|
||||
* - Versions stored as key-value pairs, NOT as entities (no index pollution)
|
||||
* - Content-addressable: SHA-256 hashing for deduplication
|
||||
* - Space-efficient: Only stores changed data
|
||||
* - Space-efficient: Only stores unique content
|
||||
* - Branch-aware: Versions tied to current branch
|
||||
* - restore() uses brain.update() to refresh ALL indexes (HNSW, metadata, graph)
|
||||
*
|
||||
* NO MOCKS - Production implementation
|
||||
* Storage keys:
|
||||
* - Version metadata: __version_meta_{entityId}_{branch}
|
||||
* - Version content: __system_version_{entityId}_{contentHash}
|
||||
*
|
||||
* ZERO-CONFIG - Works automatically with existing storage infrastructure.
|
||||
* NO MOCKS - Production implementation.
|
||||
*/
|
||||
|
||||
import { BaseStorage } from '../storage/baseStorage.js'
|
||||
|
|
@ -352,8 +358,31 @@ export class VersionManager {
|
|||
)
|
||||
}
|
||||
|
||||
// Restore entity in storage
|
||||
await this.brain.saveNounMetadata(entityId, versionedEntity)
|
||||
// Extract standard fields vs custom metadata
|
||||
// NounMetadata has: noun, data, createdAt, updatedAt, createdBy, service, confidence, weight
|
||||
const {
|
||||
noun,
|
||||
data,
|
||||
createdAt,
|
||||
updatedAt,
|
||||
createdBy,
|
||||
service,
|
||||
confidence,
|
||||
weight,
|
||||
...customMetadata
|
||||
} = versionedEntity
|
||||
|
||||
// Use brain.update() to restore - this updates ALL indexes (HNSW, metadata, graph)
|
||||
// This is critical: saveNounMetadata() only saves to storage without updating indexes
|
||||
await this.brain.update({
|
||||
id: entityId,
|
||||
data: data,
|
||||
type: noun,
|
||||
metadata: customMetadata,
|
||||
confidence: confidence,
|
||||
weight: weight,
|
||||
merge: false // Replace entirely, don't merge with existing metadata
|
||||
})
|
||||
|
||||
return targetVersion
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,19 +1,18 @@
|
|||
/**
|
||||
* VersionStorage - Hybrid Storage for Entity Versions (v5.3.0)
|
||||
* VersionStorage - Hybrid Storage for Entity Versions (v5.3.0, v6.3.0 fix)
|
||||
*
|
||||
* Implements content-addressable storage for entity versions:
|
||||
* - SHA-256 content hashing for deduplication
|
||||
* - Stores versions in .brainy/versions/ directory
|
||||
* - Uses BaseStorage.saveMetadata/getMetadata for storage (v6.3.0)
|
||||
* - Integrates with COW commit system
|
||||
* - Space-efficient: Only stores unique content
|
||||
*
|
||||
* Storage structure:
|
||||
* .brainy/versions/
|
||||
* ├── entities/
|
||||
* │ └── {entityId}/
|
||||
* │ └── {contentHash}.json # Entity version data
|
||||
* └── index/
|
||||
* └── {entityId}.json # Version index (managed by VersionIndex)
|
||||
* Storage structure (v6.3.0):
|
||||
* Version content is stored using system metadata keys:
|
||||
* __system_version_{entityId}_{contentHash}
|
||||
*
|
||||
* This integrates with BaseStorage's routing which places system keys
|
||||
* in the _system/ directory, keeping version data separate from entities.
|
||||
*
|
||||
* NO MOCKS - Production implementation
|
||||
*/
|
||||
|
|
@ -151,33 +150,35 @@ export class VersionStorage {
|
|||
}
|
||||
|
||||
/**
|
||||
* Get version storage path
|
||||
* Get version storage key
|
||||
*
|
||||
* Uses __system_ prefix so BaseStorage routes to system storage (_system/ directory)
|
||||
* This keeps version data separate from entity data.
|
||||
*
|
||||
* @param entityId Entity ID
|
||||
* @param contentHash Content hash
|
||||
* @returns Storage path
|
||||
* @returns Storage key for version content
|
||||
*/
|
||||
private getVersionPath(entityId: string, contentHash: string): string {
|
||||
return `versions/entities/${entityId}/${contentHash}.json`
|
||||
// v6.3.0: Use system-prefixed key for BaseStorage.saveMetadata/getMetadata
|
||||
// BaseStorage recognizes __system_ prefix and routes to _system/ directory
|
||||
return `__system_version_${entityId}_${contentHash}`
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if content exists in storage
|
||||
*
|
||||
* @param path Storage path
|
||||
* @param key Storage key
|
||||
* @returns True if exists
|
||||
*/
|
||||
private async contentExists(path: string): Promise<boolean> {
|
||||
private async contentExists(key: string): Promise<boolean> {
|
||||
try {
|
||||
// Use storage adapter's exists check if available
|
||||
// v6.3.0: Use getMetadata to check existence
|
||||
const adapter = this.brain.storageAdapter
|
||||
if (adapter && typeof adapter.exists === 'function') {
|
||||
return await adapter.exists(path)
|
||||
}
|
||||
if (!adapter) return false
|
||||
|
||||
// Fallback: Try to read and catch error
|
||||
await this.readVersionData(path)
|
||||
return true
|
||||
const data = await adapter.getMetadata(key)
|
||||
return data !== null
|
||||
} catch {
|
||||
return false
|
||||
}
|
||||
|
|
@ -186,11 +187,11 @@ export class VersionStorage {
|
|||
/**
|
||||
* Write version data to storage
|
||||
*
|
||||
* @param path Storage path
|
||||
* @param key Storage key
|
||||
* @param entity Entity data
|
||||
*/
|
||||
private async writeVersionData(
|
||||
path: string,
|
||||
key: string,
|
||||
entity: NounMetadata
|
||||
): Promise<void> {
|
||||
const adapter = this.brain.storageAdapter
|
||||
|
|
@ -199,67 +200,51 @@ export class VersionStorage {
|
|||
throw new Error('Storage adapter not available')
|
||||
}
|
||||
|
||||
// Serialize entity data
|
||||
const data = JSON.stringify(entity, null, 2)
|
||||
|
||||
// Write to storage using adapter
|
||||
if (typeof adapter.writeFile === 'function') {
|
||||
await adapter.writeFile(path, data)
|
||||
} else if (typeof adapter.set === 'function') {
|
||||
await adapter.set(path, data)
|
||||
} else {
|
||||
throw new Error('Storage adapter does not support write operations')
|
||||
}
|
||||
// v6.3.0: Use saveMetadata for storing version content
|
||||
// The key is system-prefixed so it routes to _system/ directory
|
||||
await adapter.saveMetadata(key, entity)
|
||||
}
|
||||
|
||||
/**
|
||||
* Read version data from storage
|
||||
*
|
||||
* @param path Storage path
|
||||
* @param key Storage key
|
||||
* @returns Entity data
|
||||
*/
|
||||
private async readVersionData(path: string): Promise<NounMetadata> {
|
||||
private async readVersionData(key: string): Promise<NounMetadata> {
|
||||
const adapter = this.brain.storageAdapter
|
||||
|
||||
if (!adapter) {
|
||||
throw new Error('Storage adapter not available')
|
||||
}
|
||||
|
||||
// Read from storage using adapter
|
||||
let data: string
|
||||
|
||||
if (typeof adapter.readFile === 'function') {
|
||||
data = await adapter.readFile(path)
|
||||
} else if (typeof adapter.get === 'function') {
|
||||
data = await adapter.get(path)
|
||||
} else {
|
||||
throw new Error('Storage adapter does not support read operations')
|
||||
// v6.3.0: Use getMetadata for reading version content
|
||||
const entity = await adapter.getMetadata(key)
|
||||
if (!entity) {
|
||||
throw new Error(`Version data not found: ${key}`)
|
||||
}
|
||||
|
||||
// Parse entity data
|
||||
return JSON.parse(data)
|
||||
return entity
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete version data from storage
|
||||
*
|
||||
* @param path Storage path
|
||||
* Note: Version content is content-addressed and immutable.
|
||||
* Deleting the version index entry (via VersionIndex.removeVersion) is sufficient.
|
||||
* The content may be shared with other versions (same contentHash).
|
||||
*
|
||||
* v6.3.0: We don't actually delete version content to avoid breaking
|
||||
* other versions that may reference the same content hash.
|
||||
* A separate garbage collection process could clean up unreferenced content.
|
||||
*
|
||||
* @param key Storage key (unused - kept for API compatibility)
|
||||
*/
|
||||
private async deleteVersionData(path: string): Promise<void> {
|
||||
const adapter = this.brain.storageAdapter
|
||||
|
||||
if (!adapter) {
|
||||
throw new Error('Storage adapter not available')
|
||||
}
|
||||
|
||||
// Delete from storage using adapter
|
||||
if (typeof adapter.deleteFile === 'function') {
|
||||
await adapter.deleteFile(path)
|
||||
} else if (typeof adapter.delete === 'function') {
|
||||
await adapter.delete(path)
|
||||
} else {
|
||||
throw new Error('Storage adapter does not support delete operations')
|
||||
}
|
||||
private async deleteVersionData(_key: string): Promise<void> {
|
||||
// v6.3.0: Version content is content-addressed and may be shared.
|
||||
// We don't delete it here to prevent breaking other versions.
|
||||
// The version INDEX is deleted via VersionIndex.removeVersion().
|
||||
// A GC process could clean up unreferenced content in the future.
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue