David Snelling
780fb6444b
Brainy 8.0 makes subtype required by default on every public write path
(`add`, `addMany`, `update`, `relate`, `relateMany`, `updateRelation`,
import). Per the locked C-1 contract, every entity and relation gets a
non-empty subtype string by the time the storage layer sees it.
OPT-OUT REMAINS FULLY SUPPORTED
The runtime flag is still consumer-controlled. Three opt-out paths
cover migration / legacy fixtures / typed escape:
- `new Brainy({ requireSubtype: false })` — last-resort: turn off the
contract entirely. Recommended only for migration windows or test
fixtures that legitimately can't supply a subtype.
- `new Brainy({ requireSubtype: { except: [NounType.Thing, ...] } })` —
per-type allowlist: strict everywhere except the listed types.
- `brain.requireSubtype(type, options)` — per-type registration with
optional vocabulary. Composes with the brain-wide flag.
Default is now `true`. Opt-out is explicit and documented; nothing
silently degrades.
TEST SWEEP
Bulk-applied `requireSubtype: false` to every `new Brainy({...})` call
site across 120 test files. Three sed patterns covered the shapes:
- `new Brainy({` → `new Brainy({ requireSubtype: false,`
- `new Brainy<T>({` → `new Brainy<T>({ requireSubtype: false,`
- `new Brainy()` → `new Brainy({ requireSubtype: false })`
tests/helpers/test-factory.ts → createTestConfig() defaults
`requireSubtype: false` so test files using the helper inherit the
opt-out without per-site edits.
The test sites that DO exercise subtype semantics (the
subtype-and-facets suite, the strict-mode-self-test suite, the verb-
subtype-and-enforcement suite, etc.) already pass real subtypes — they
were the 7.30.x acceptance tests for this contract. Those tests
continue to pass unchanged.
CHANGES
src/brainy.ts
- normalizeConfig() — `requireSubtype` default `false` → `true`.
Comment refreshed to document the three opt-out paths.
tests/* (120 files)
- Bulk-edited brain construction sites. No functional test changes; the
opt-out preserves the test author's original intent.
tests/helpers/test-factory.ts
- createTestConfig() base config gains `requireSubtype: false`.
NO-OP for consumers who were already passing subtype on every write.
For consumers who weren't, the upgrade path is one of the three opt-out
forms above. Migration recipe documented in 8.0 release notes (next
commit).
VERIFICATION
- npx tsc --noEmit: clean
- npm test: 1408 / 1409 (same pre-existing race-condition outstanding;
no other regressions from the flip)
114 lines
3.5 KiB
TypeScript
114 lines
3.5 KiB
TypeScript
import { describe, it, expect, beforeEach, afterEach } from 'vitest'
|
|
import { Brainy } from '../../../src/brainy.js'
|
|
import * as fs from 'fs'
|
|
import * as path from 'path'
|
|
import * as os from 'os'
|
|
|
|
/**
|
|
* Test for v5.1.2 fix: preserveSource now works with file paths
|
|
*
|
|
* Bug: sourceBuffer was undefined for file paths because normalizeSource
|
|
* returned type='path', but code checked for type='buffer'
|
|
*
|
|
* Fix: Changed to Buffer.isBuffer(normalizedSource.data)
|
|
*/
|
|
|
|
describe('Import preserveSource Fix (v5.1.2)', () => {
|
|
let brain: Brainy
|
|
let tempDir: string
|
|
let testFilePath: string
|
|
|
|
beforeEach(async () => {
|
|
brain = new Brainy({ requireSubtype: false,
|
|
storage: { type: 'memory' },
|
|
silent: true
|
|
})
|
|
await brain.init()
|
|
|
|
// Create temp directory and test file
|
|
tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'brainy-test-'))
|
|
testFilePath = path.join(tempDir, 'test-data.csv')
|
|
|
|
// Create a test CSV (simple text content that won't fail parsing)
|
|
const csvContent = 'name,value\ntest1,100\ntest2,200'
|
|
fs.writeFileSync(testFilePath, csvContent)
|
|
})
|
|
|
|
afterEach(async () => {
|
|
await brain.close()
|
|
|
|
// Cleanup temp files (recursive)
|
|
if (fs.existsSync(tempDir)) {
|
|
const files = fs.readdirSync(tempDir)
|
|
for (const file of files) {
|
|
fs.unlinkSync(path.join(tempDir, file))
|
|
}
|
|
fs.rmdirSync(tempDir)
|
|
}
|
|
})
|
|
|
|
it('should preserve source file when importing from file path with preserveSource: true', async () => {
|
|
// Import CSV from file path
|
|
await brain.import(testFilePath, {
|
|
format: 'csv',
|
|
vfsPath: '/imported',
|
|
preserveSource: true,
|
|
enableNeuralExtraction: false, // Disable to speed up test
|
|
createEntities: true
|
|
})
|
|
|
|
// Verify source file was preserved in VFS
|
|
const sourceFilePath = '/imported/_source.csv'
|
|
const exists = await brain.vfs.exists(sourceFilePath)
|
|
expect(exists).toBe(true)
|
|
|
|
// Verify we can read the file back
|
|
const content = await brain.vfs.readFile(sourceFilePath)
|
|
expect(Buffer.isBuffer(content)).toBe(true)
|
|
expect(content.length).toBeGreaterThan(0)
|
|
|
|
// Verify content matches original
|
|
const originalContent = fs.readFileSync(testFilePath)
|
|
expect(Buffer.compare(content, originalContent)).toBe(0)
|
|
})
|
|
|
|
it('should NOT preserve source file when preserveSource: false', async () => {
|
|
// Import CSV without preserving source
|
|
await brain.import(testFilePath, {
|
|
format: 'csv',
|
|
vfsPath: '/imported-no-source',
|
|
preserveSource: false,
|
|
enableNeuralExtraction: false,
|
|
createEntities: true
|
|
})
|
|
|
|
// Verify source file was NOT preserved
|
|
const sourceFilePath = '/imported-no-source/_source.csv'
|
|
const exists = await brain.vfs.exists(sourceFilePath)
|
|
expect(exists).toBe(false)
|
|
})
|
|
|
|
it('should handle binary files correctly (no corruption)', async () => {
|
|
// Create a simple JSON file to test without parsing errors
|
|
const jsonContent = JSON.stringify({ test: 'data', binary: [0xFF, 0xFE, 0xFD] })
|
|
const jsonFilePath = path.join(tempDir, 'test.json')
|
|
fs.writeFileSync(jsonFilePath, jsonContent)
|
|
|
|
// Import JSON
|
|
await brain.import(jsonFilePath, {
|
|
format: 'json',
|
|
vfsPath: '/json-test',
|
|
preserveSource: true,
|
|
enableNeuralExtraction: false,
|
|
createEntities: true
|
|
})
|
|
|
|
// Read back and verify no corruption
|
|
const content = await brain.vfs.readFile('/json-test/_source.json')
|
|
expect(content.toString('utf-8')).toBe(jsonContent)
|
|
|
|
// Cleanup
|
|
fs.unlinkSync(jsonFilePath)
|
|
})
|
|
|
|
})
|