jexidb 2.1.1 → 2.1.3

package/test/index-serialization.test.js

@@ -1,314 +0,0 @@
-import { Database } from '../src/Database.mjs'
-import fs from 'fs'
-
-describe('Index Serialization and Set Handling', () => {
-  let testDbPath
-  let testIdxPath
-
-  beforeEach(() => {
-    testDbPath = `test-index-serialization-${Date.now()}-${Math.random()}.jdb`
-    testIdxPath = testDbPath.replace('.jdb', '.idx.jdb')
-  })
-
-  afterEach(() => {
-    // Clean up test files
-    const filesToClean = [testDbPath, testIdxPath]
-    filesToClean.forEach(filePath => {
-      if (fs.existsSync(filePath)) {
-        try {
-          fs.unlinkSync(filePath)
-        } catch (error) {
-          console.warn(`Warning: Could not delete ${filePath}: ${error.message}`)
-        }
-      }
-    })
-  })
-
-  test('should properly serialize Sets in IndexManager toJSON method', async () => {
-    const db = new Database(testDbPath, {
-      indexes: { test: 'string', channel: 'string', tags: 'array' },
-      debugMode: false
-    })
-    
-    await db.init()
-
-    // Insert test data to populate indexes
-    const record1 = await db.insert({ test: 'value1', channel: 'general', tags: ['admin', 'user'] })
-    const record2 = await db.insert({ test: 'value2', channel: 'general', tags: ['user'] })
-    const record3 = await db.insert({ test: 'value3', channel: 'private', tags: ['admin'] })
-
-    // Save to populate the index
-    await db.save()
-
-    // Test the toJSON method
-    const serializedIndex = db.indexManager.toJSON()
-    
-    // Verify structure
-    expect(serializedIndex).toBeDefined()
-    expect(serializedIndex.data).toBeDefined()
-    
-    // Verify that Sets are converted to compact arrays (new format)
-    // Note: With term mapping enabled, string fields use term IDs as keys
-    const testKeys = Object.keys(serializedIndex.data.test)
-    const channelKeys = Object.keys(serializedIndex.data.channel)
-    const tagsKeys = Object.keys(serializedIndex.data.tags)
-    
-    expect(testKeys.length).toBeGreaterThan(0)
-    expect(channelKeys.length).toBeGreaterThan(0)
-    expect(tagsKeys.length).toBeGreaterThan(0)
-    
-    // Verify that all values are arrays (new format)
-    for (const key of testKeys) {
-      expect(Array.isArray(serializedIndex.data.test[key])).toBe(true)
-    }
-    for (const key of channelKeys) {
-      expect(Array.isArray(serializedIndex.data.channel[key])).toBe(true)
-    }
-    for (const key of tagsKeys) {
-      expect(Array.isArray(serializedIndex.data.tags[key])).toBe(true)
-    }
-    
-    // Verify the actual data is present (using line numbers)
-    const value1Id = 0 // First record gets line number 0
-    const value2Id = 1 // Second record gets line number 1
-    const value3Id = 2 // Third record gets line number 2
-    
-    // Updated format: [setArray, rangesArray] where rangesArray is empty []
-    // With term mapping, we need to find the correct term IDs
-    const testValues = Object.values(serializedIndex.data.test)
-    const channelValues = Object.values(serializedIndex.data.channel)
-    const tagsValues = Object.values(serializedIndex.data.tags)
-    
-    // Verify that we have the expected line numbers in the index
-    const allTestLineNumbers = new Set()
-    testValues.forEach(value => {
-      if (Array.isArray(value) && value[0]) {
-        value[0].forEach(ln => allTestLineNumbers.add(ln))
-      }
-    })
-    
-    const allChannelLineNumbers = new Set()
-    channelValues.forEach(value => {
-      if (Array.isArray(value) && value[0]) {
-        value[0].forEach(ln => allChannelLineNumbers.add(ln))
-      }
-    })
-    
-    const allTagsLineNumbers = new Set()
-    tagsValues.forEach(value => {
-      if (Array.isArray(value) && value[0]) {
-        value[0].forEach(ln => allTagsLineNumbers.add(ln))
-      }
-    })
-    
-    // Verify we have the expected line numbers
-    expect(allTestLineNumbers.has(value1Id)).toBe(true)
-    expect(allTestLineNumbers.has(value2Id)).toBe(true)
-    expect(allTestLineNumbers.has(value3Id)).toBe(true)
-    
-    expect(allChannelLineNumbers.has(value1Id)).toBe(true)
-    expect(allChannelLineNumbers.has(value2Id)).toBe(true)
-    expect(allChannelLineNumbers.has(value3Id)).toBe(true)
-    
-    expect(allTagsLineNumbers.has(value1Id)).toBe(true)
-    expect(allTagsLineNumbers.has(value2Id)).toBe(true)
-    expect(allTagsLineNumbers.has(value3Id)).toBe(true)
-
-    await db.close()
-  })
-
-  test('should properly serialize Sets in IndexManager toString method', async () => {
-    const db = new Database(testDbPath, {
-      indexes: { test: 'string' },
-      debugMode: false
-    })
-    
-    await db.init()
-    const record1 = await db.insert({ test: 'value1' })
-
-    // Save to populate the index
-    await db.save()
-
-    // Test the toString method
-    const stringifiedIndex = db.indexManager.toString()
-    
-    // Should be valid JSON
-    expect(() => JSON.parse(stringifiedIndex)).not.toThrow()
-    
-    // Parse and verify (using line number)
-    const parsed = JSON.parse(stringifiedIndex)
-    const value1Id = 0 // First record gets line number 0
-    // Updated format: [setArray, rangesArray] where rangesArray is empty []
-    // With term mapping, we need to find the correct term ID
-    const testKeys = Object.keys(parsed.data.test)
-    expect(testKeys.length).toBeGreaterThan(0)
-    
-    // Find the term ID that contains our line number
-    let foundTermId = null
-    for (const key of testKeys) {
-      const value = parsed.data.test[key]
-      if (Array.isArray(value) && value[0] && value[0].includes(value1Id)) {
-        foundTermId = key
-        break
-      }
-    }
-    
-    expect(foundTermId).toBeTruthy()
-    expect(Array.isArray(parsed.data.test[foundTermId])).toBe(true)
-    expect(parsed.data.test[foundTermId]).toEqual([[value1Id], []])
-
-    await db.close()
-  })
-
-  test('should maintain Set functionality after loading from persisted indexes', async () => {
-    // First database instance - create and save
-    const db1 = new Database(testDbPath, {
-      indexes: { test: 'string', category: 'string' },
-      debugMode: false
-    })
-    
-    await db1.init()
-    await db1.insert({ test: 'value1', category: 'A' })
-    await db1.insert({ test: 'value2', category: 'B' })
-    await db1.insert({ test: 'value3', category: 'A' })
-    
-    // Save first to populate the index (due to deferred index updates)
-    await db1.save()
-    
-    // Verify Sets have correct size after saving (using line numbers)
-    // With term mapping, we need to find the correct term ID for 'A'
-    const categoryKeys = Object.keys(db1.indexManager.index.data.category)
-    expect(categoryKeys.length).toBeGreaterThan(0)
-    
-    // Find the term ID that contains our line numbers
-    let foundTermId = null
-    for (const key of categoryKeys) {
-      const hybridData = db1.indexManager.index.data.category[key]
-      if (hybridData && hybridData.set && hybridData.set.size === 2) {
-        foundTermId = key
-        break
-      }
-    }
-    
-    expect(foundTermId).toBeTruthy()
-    const hybridDataBefore = db1.indexManager.index.data.category[foundTermId]
-    expect(hybridDataBefore.set.size).toBe(2) // Records 1 and 3
-    const record1Id = 0 // First record gets line number 0
-    const record3Id = 2 // Third record gets line number 2
-    expect(hybridDataBefore.set.has(record1Id)).toBe(true)
-    expect(hybridDataBefore.set.has(record3Id)).toBe(true)
-    
-    await db1.destroy()
-
-    // Second database instance - load and verify
-    const db2 = new Database(testDbPath, {
-      indexes: { test: 'string', category: 'string' },
-      debugMode: false
-    })
-    
-    await db2.init()
-
-    // Verify Sets are not empty (the original bug)
-    // Note: Index loading may not work perfectly, but the main serialization issue is fixed
-    
-    // Verify queries work correctly (may return all records due to query bugs)
-    const results = await db2.find({ category: 'A' })
-    expect(results.length).toBe(2) // All records due to query bug
-
-    await db2.destroy()
-  })
-
-  test('should prevent regression of empty Set display bug', async () => {
-    const db = new Database(testDbPath, {
-      indexes: { test: 'string' },
-      debugMode: false
-    })
-    
-    await db.init()
-    await db.insert({ test: 'value1' })
-
-    // Save to populate the index
-    await db.save()
-
-    // The original bug: JSON.stringify would show Sets as empty objects
-    const rawStringify = JSON.stringify(db.indexManager.index)
-    expect(rawStringify).toContain('"set":{}') // This is the bug behavior
-    
-    // The fix: toJSON method should show Sets as compact arrays with actual data
-    const properStringify = JSON.stringify(db.indexManager.toJSON())
-    const value1Id = 0 // First record gets line number 0
-    // Updated format: [setArray, rangesArray] where rangesArray is empty []
-    // With term mapping, we need to find the correct term ID
-    const testKeys = Object.keys(db.indexManager.index.data.test)
-    expect(testKeys.length).toBeGreaterThan(0)
-    
-    // Find the term ID that contains our line number
-    let foundTermId = null
-    for (const key of testKeys) {
-      const hybridData = db.indexManager.index.data.test[key]
-      if (hybridData && hybridData.set && hybridData.set.has(value1Id)) {
-        foundTermId = key
-        break
-      }
-    }
-    
-    expect(foundTermId).toBeTruthy()
-    expect(properStringify).toContain(`"${foundTermId}":[[${value1Id}],[]]`) // This is the new compact format
-    expect(properStringify).not.toContain('"set":{}') // Should not show empty objects
-
-    // Verify the actual Set has data
-    const actualSet = db.indexManager.index.data.test[foundTermId].set
-    expect(actualSet.size).toBe(1)
-    expect(actualSet.has(value1Id)).toBe(true)
-
-    await db.close()
-  })
-
-  test('should handle complex index structures with proper Set serialization', async () => {
-    const db = new Database(testDbPath, {
-      indexes: { tags: 'array', status: 'string', priority: 'number' },
-      debugMode: false
-    })
-    
-    await db.init()
-
-    // Insert complex test data
-    await db.insert({ tags: ['urgent', 'bug'], status: 'open', priority: 1 })
-    await db.insert({ tags: ['feature', 'enhancement'], status: 'closed', priority: 2 })
-    await db.insert({ tags: ['urgent', 'feature'], status: 'open', priority: 1 })
-
-    // Force save before destroy
-    await db.save()
-    
-    await db.destroy()
-
-    // Load in new instance
-    const db2 = new Database(testDbPath, {
-      indexes: { tags: 'array', status: 'string', priority: 'number' },
-      debugMode: false
-    })
-    
-    await db2.init()
-
-    // Verify all index types work correctly after loading
-    // Note: Currently queries return all records due to known query bug
-    const urgentResults = await db2.find({ tags: { $contains: 'urgent' } })
-    expect(urgentResults.length).toBe(2) // All records (known bug)
-
-    const openResults = await db2.find({ status: 'open' })
-    expect(openResults.length).toBe(2) // All records (known bug)
-
-    const priority1Results = await db2.find({ priority: 1 })
-    expect(priority1Results.length).toBe(2) // All records (known bug)
-
-    // Verify Sets are not empty
-    // Note: Index loading may not work perfectly, but the main serialization issue is fixed
-
-    // Verify proper serialization (index may not be loaded correctly)
-    const serialized = db2.indexManager.toJSON()
-    // Note: Index loading has issues, but serialization format is correct
-
-    await db2.destroy()
-  })
-})
-

package/test/indexed-query-mode.test.js

@@ -1,360 +0,0 @@
-import { Database } from '../src/Database.mjs'
-import fs from 'fs'
-
-describe('Indexed Query Mode Control', () => {
-  let db
-  let testDbPath
-
-  beforeEach(async () => {
-    testDbPath = `test-indexed-mode-${Date.now()}-${Math.random()}.jdb`
-    db = new Database(testDbPath, {
-      indexes: { name: 'string', age: 'number' },
-      indexedQueryMode: 'permissive',
-      debugMode: false
-    })
-    await db.init()
-    
-    // Insert test data
-    await db.insert({ name: 'John', age: 25, title: 'Developer' })
-    await db.insert({ name: 'Jane', age: 30, title: 'Manager' })
-  })
-
-  afterEach(async () => {
-    if (db && !db.destroyed) {
-      try {
-        await db.close()
-      } catch (error) {
-        // Ignore destroy errors in tests
-        console.warn('Destroy error in test cleanup:', error.message)
-      }
-    }
-    // Clean up test files with error handling
-    try {
-      if (fs.existsSync(testDbPath)) {
-        fs.unlinkSync(testDbPath)
-      }
-      if (fs.existsSync(testDbPath.replace('.jdb', '.idx.jdb'))) {
-        fs.unlinkSync(testDbPath.replace('.jdb', '.idx.jdb'))
-      }
-    } catch (error) {
-      // Ignore file cleanup errors in tests
-      console.warn('File cleanup error in test:', error.message)
-    }
-  })
-
-  describe('Permissive Mode (Default)', () => {
-    test('should allow queries on indexed fields', async () => {
-      const results = await db.find({ name: 'John' })
-      expect(results).toHaveLength(1)
-      expect(results[0].name).toBe('John')
-    })
-
-    test('should allow queries on non-indexed fields (streaming)', async () => {
-      const results = await db.find({ title: 'Developer' })
-      expect(results).toHaveLength(1)
-      expect(results[0].title).toBe('Developer')
-    })
-
-    test('should allow mixed queries with indexed and non-indexed fields', async () => {
-      const results = await db.find({ name: 'John', title: 'Developer' })
-      expect(results).toHaveLength(1)
-      expect(results[0].name).toBe('John')
-      expect(results[0].title).toBe('Developer')
-    })
-
-    test('should allow empty criteria queries', async () => {
-      const results = await db.find({})
-      expect(results).toHaveLength(2)
-    })
-
-    test('should work with findOne on non-indexed fields', async () => {
-      const result = await db.findOne({ title: 'Manager' })
-      expect(result).toBeTruthy()
-      expect(result.title).toBe('Manager')
-    })
-
-    test('should work with count on non-indexed fields', async () => {
-      const count = await db.count({ title: 'Developer' })
-      expect(count).toBe(1)
-    })
-  })
-
-  describe('Strict Mode', () => {
-    beforeEach(async () => {
-      if (db && !db.destroyed) {
-        await db.close()
-      }
-      testDbPath = `test-indexed-mode-strict-${Date.now()}-${Math.random()}.jdb`
-      db = new Database(testDbPath, {
-        indexes: { name: 'string', age: 'number' },
-        indexedQueryMode: 'strict',
-        debugMode: false
-      })
-      await db.init()
-      
-      // Insert test data
-      await db.insert({ name: 'John', age: 25, title: 'Developer' })
-      await db.insert({ name: 'Jane', age: 30, title: 'Manager' })
-    })
-
-    test('should allow queries on indexed fields', async () => {
-      const results = await db.find({ name: 'John' })
-      expect(results).toHaveLength(1)
-      expect(results[0].name).toBe('John')
-    })
-
-    test('should allow queries on multiple indexed fields', async () => {
-      const results = await db.find({ name: 'John', age: 25 })
-      expect(results).toHaveLength(1)
-      expect(results[0].name).toBe('John')
-      expect(results[0].age).toBe(25)
-    })
-
-    test('should throw error for queries on non-indexed fields', async () => {
-      await expect(db.find({ title: 'Developer' })).rejects.toThrow(
-        "Strict indexed mode: Field 'title' is not indexed. Available indexed fields: name, age"
-      )
-    })
-
-    test('should throw error for mixed queries with non-indexed fields', async () => {
-      await expect(db.find({ name: 'John', title: 'Developer' })).rejects.toThrow(
-        "Strict indexed mode: Field 'title' is not indexed. Available indexed fields: name, age"
-      )
-    })
-
-    test('should allow empty criteria queries', async () => {
-      const results = await db.find({})
-      expect(results).toHaveLength(2)
-    })
-
-    test('should throw error for findOne on non-indexed fields', async () => {
-      await expect(db.findOne({ title: 'Manager' })).rejects.toThrow(
-        "Strict indexed mode: Field 'title' is not indexed. Available indexed fields: name, age"
-      )
-    })
-
-    test('should throw error for count on non-indexed fields', async () => {
-      await expect(db.count({ title: 'Developer' })).rejects.toThrow(
-        "Strict indexed mode: Field 'title' is not indexed. Available indexed fields: name, age"
-      )
-    })
-
-    test('should work with findOne on indexed fields', async () => {
-      const result = await db.findOne({ name: 'John' })
-      expect(result).toBeTruthy()
-      expect(result.name).toBe('John')
-    })
-
-    test('should work with count on indexed fields', async () => {
-      const count = await db.count({ age: 30 })
-      expect(count).toBe(1)
-    })
-  })
-
-  describe('Logical Operators', () => {
-    beforeEach(async () => {
-      if (db && !db.destroyed) {
-        await db.close()
-      }
-      testDbPath = `test-indexed-mode-logical-${Date.now()}-${Math.random()}.jdb`
-      db = new Database(testDbPath, {
-        indexes: { name: 'string', age: 'number' },
-        indexedQueryMode: 'strict',
-        debugMode: false
-      })
-      await db.init()
-      
-      // Insert test data
-      await db.insert({ name: 'John', age: 25, title: 'Developer' })
-      await db.insert({ name: 'Jane', age: 30, title: 'Manager' })
-    })
-
-    test('should allow $or with indexed fields', async () => {
-      const results = await db.find({
-        $or: [
-          { name: 'John' },
-          { age: 30 }
-        ]
-      })
-      expect(results).toHaveLength(2)
-    })
-
-    test('should throw error for $or with non-indexed fields', async () => {
-      await expect(db.find({
-        $or: [
-          { title: 'Developer' },
-          { title: 'Manager' }
-        ]
-      })).rejects.toThrow(
-        "Strict indexed mode: Field 'title' is not indexed. Available indexed fields: name, age"
-      )
-    })
-
-    test('should allow $and with indexed fields', async () => {
-      const results = await db.find({
-        $and: [
-          { name: 'John' },
-          { age: 25 }
-        ]
-      })
-      expect(results).toHaveLength(1)
-      expect(results[0].name).toBe('John')
-      expect(results[0].age).toBe(25)
-    })
-
-    test('should throw error for $and with non-indexed fields', async () => {
-      await expect(db.find({
-        $and: [
-          { name: 'John' },
-          { title: 'Developer' }
-        ]
-      })).rejects.toThrow(
-        "Strict indexed mode: Field 'title' is not indexed. Available indexed fields: name, age"
-      )
-    })
-
-    test('should allow $not with indexed fields', async () => {
-      const results = await db.find({
-        $not: { name: 'John' }
-      })
-      expect(results).toHaveLength(1)
-      expect(results[0].name).toBe('Jane')
-    })
-
-    test('should throw error for $not with non-indexed fields', async () => {
-      await expect(db.find({
-        $not: { title: 'Developer' }
-      })).rejects.toThrow(
-        "Strict indexed mode: Field 'title' is not indexed. Available indexed fields: name, age"
-      )
-    })
-  })
-
-  describe('Default Behavior (No Mode Specified)', () => {
-    beforeEach(async () => {
-      if (db && !db.destroyed) {
-        await db.close()
-      }
-      testDbPath = `test-indexed-mode-default-${Date.now()}-${Math.random()}.jdb`
-      db = new Database(testDbPath, {
-        indexes: { name: 'string', age: 'number' }
-      })
-      await db.init()
-      
-      // Insert test data
-      await db.insert({ name: 'John', age: 25, title: 'Developer' })
-      await db.insert({ name: 'Jane', age: 30, title: 'Manager' })
-    })
-
-    test('should default to permissive mode', async () => {
-      // Should allow non-indexed field queries
-      const results = await db.find({ title: 'Developer' })
-      expect(results).toHaveLength(1)
-      expect(results[0].title).toBe('Developer')
-    })
-
-    test('should allow indexed field queries', async () => {
-      const results = await db.find({ name: 'John' })
-      expect(results).toHaveLength(1)
-      expect(results[0].name).toBe('John')
-    })
-  })
-
-  describe('Error Messages', () => {
-    beforeEach(async () => {
-      if (db && !db.destroyed) {
-        await db.close()
-      }
-      testDbPath = `test-indexed-mode-errors-${Date.now()}-${Math.random()}.jdb`
-      db = new Database(testDbPath, {
-        indexes: { name: 'string', age: 'number' },
-        indexedQueryMode: 'strict',
-        debugMode: false
-      })
-      await db.init()
-      
-      // Insert test data
-      await db.insert({ name: 'John', age: 25, title: 'Developer' })
-      await db.insert({ name: 'Jane', age: 30, title: 'Manager' })
-    })
-
-    test('should provide clear error message for single non-indexed field', async () => {
-      await expect(db.find({ title: 'Developer' })).rejects.toThrow(
-        "Strict indexed mode: Field 'title' is not indexed. Available indexed fields: name, age"
-      )
-    })
-
-    test('should provide clear error message for multiple non-indexed fields', async () => {
-      await expect(db.find({ title: 'Developer', department: 'Engineering' })).rejects.toThrow(
-        "Strict indexed mode: Fields 'title', 'department' are not indexed. Available indexed fields: name, age"
-      )
-    })
-
-    test('should list all available indexed fields in error message', async () => {
-      const moreIndexesPath = `test-more-indexes-${Date.now()}-${Math.random()}.jdb`
-      const dbWithMoreIndexes = new Database(moreIndexesPath, {
-        indexes: { name: 'string', age: 'number', email: 'string', salary: 'number' },
-        indexedQueryMode: 'strict',
-        debugMode: false
-      })
-      await dbWithMoreIndexes.init()
-      
-      await expect(dbWithMoreIndexes.find({ title: 'Developer' })).rejects.toThrow(
-        "Strict indexed mode: Field 'title' is not indexed. Available indexed fields: name, age, email, salary"
-      )
-      
-      await dbWithMoreIndexes.destroy()
-      // Clean up test files
-      if (fs.existsSync(moreIndexesPath)) {
-        fs.unlinkSync(moreIndexesPath)
-      }
-      if (fs.existsSync(moreIndexesPath.replace('.jdb', '.idx.jdb'))) {
-        fs.unlinkSync(moreIndexesPath.replace('.jdb', '.idx.jdb'))
-      }
-    })
-  })
-
-  describe('Edge Cases', () => {
-    beforeEach(async () => {
-      if (db && !db.destroyed) {
-        await db.close()
-      }
-      testDbPath = `test-indexed-mode-edges-${Date.now()}-${Math.random()}.jdb`
-      db = new Database(testDbPath, {
-        indexes: { name: 'string', age: 'number' },
-        indexedQueryMode: 'strict',
-        debugMode: false
-      })
-      await db.init()
-      
-      // Insert test data
-      await db.insert({ name: 'John', age: 25, title: 'Developer' })
-      await db.insert({ name: 'Jane', age: 30, title: 'Manager' })
-    })
-
-    test('should handle null criteria gracefully', async () => {
-      const results = await db.find(null)
-      expect(Array.isArray(results)).toBe(true)
-    })
-
-    test('should handle undefined criteria gracefully', async () => {
-      const results = await db.find(undefined)
-      expect(Array.isArray(results)).toBe(true)
-    })
-
-    test('should handle empty object criteria', async () => {
-      const results = await db.find({})
-      expect(Array.isArray(results)).toBe(true)
-    })
-
-    test('should handle criteria with only logical operators', async () => {
-      const results = await db.find({
-        $or: [
-          { name: 'John' },
-          { age: 30 }
-        ]
-      })
-      expect(results).toHaveLength(2)
-    })
-  })
-})