jexidb 2.0.2 → 2.1.0

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

@@ -0,0 +1,360 @@
+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)
+    })
+  })
+})

package/test/iterate-method.test.js

@@ -0,0 +1,272 @@
+/**
+ * Test suite for the new iterate() method
+ * Tests bulk update capabilities with streaming performance
+ */
+
+import { Database } from '../src/Database.mjs'
+import fs from 'fs'
+import path from 'path'
+
+describe('Database.iterate() Method', () => {
+  let db
+  const testFile = 'test-iterate.jdb'
+  const testIdxFile = 'test-iterate.idx.jdb'
+
+  beforeEach(async () => {
+    // Clean up any existing test files
+    if (fs.existsSync(testFile)) fs.unlinkSync(testFile)
+    if (fs.existsSync(testIdxFile)) fs.unlinkSync(testIdxFile)
+    
+    db = new Database(testFile, {
+      debugMode: false,
+      termMapping: true,
+      indexedFields: ['category', 'name', 'price']
+    })
+    await db.init()
+  })
+
+  afterEach(async () => {
+    if (db && !db.destroyed) {
+      await db.close()
+    }
+    // Clean up test files
+    if (fs.existsSync(testFile)) fs.unlinkSync(testFile)
+    if (fs.existsSync(testIdxFile)) fs.unlinkSync(testIdxFile)
+  })
+
+  describe('Basic Functionality', () => {
+    test('should iterate through records without modifications', async () => {
+      // Insert test data
+      await db.insert({ id: 1, name: 'Apple', category: 'fruits', price: 1.50 })
+      await db.insert({ id: 2, name: 'Banana', category: 'fruits', price: 0.80 })
+      await db.insert({ id: 3, name: 'Carrot', category: 'vegetables', price: 0.60 })
+      
+      const results = []
+      for await (const entry of db.iterate({ category: 'fruits' })) {
+        results.push(entry)
+      }
+      
+      expect(results).toHaveLength(2)
+      expect(results.map(r => r.name)).toEqual(['Apple', 'Banana'])
+    })
+
+    test('should detect and process modifications', async () => {
+      // Insert test data
+      await db.insert({ id: 1, name: 'Apple', category: 'fruits', price: 1.50 })
+      await db.insert({ id: 2, name: 'Banana', category: 'fruits', price: 0.80 })
+      
+      // Iterate and modify records
+      for await (const entry of db.iterate({ category: 'fruits' })) {
+        if (entry.name === 'Apple') {
+          entry.price = 2.00 // Modify price
+        }
+      }
+      
+      // Verify changes were applied
+      const apple = await db.findOne({ name: 'Apple' })
+      expect(apple.price).toBe(2.00)
+      
+      const banana = await db.findOne({ name: 'Banana' })
+      expect(banana.price).toBe(0.80) // Unchanged
+    })
+
+    test('should handle deletions by setting entry to null', async () => {
+      // Insert test data
+      await db.insert({ id: 1, name: 'Apple', category: 'fruits', price: 1.50 })
+      await db.insert({ id: 2, name: 'Banana', category: 'fruits', price: 0.80 })
+      await db.insert({ id: 3, name: 'Carrot', category: 'vegetables', price: 0.60 })
+      
+      // Iterate and delete some records
+      for await (const entry of db.iterate({ category: 'fruits' })) {
+        if (entry.name === 'Apple') {
+          // Delete the record using the delete method
+          entry.delete()
+        }
+      }
+      
+      // Verify deletion
+      const fruits = await db.find({ category: 'fruits' })
+      expect(fruits).toHaveLength(1)
+      expect(fruits[0].name).toBe('Banana')
+      
+      // Verify other categories unaffected
+      const vegetables = await db.find({ category: 'vegetables' })
+      expect(vegetables).toHaveLength(1)
+    })
+  })
+
+  describe('Performance Features', () => {
+    test('should process records in batches', async () => {
+      // Insert many records
+      const records = []
+      for (let i = 1; i <= 2500; i++) {
+        records.push({ 
+          id: i, 
+          name: `Item${i}`, 
+          category: i % 2 === 0 ? 'even' : 'odd',
+          price: i * 0.1
+        })
+      }
+      
+      // Insert all records
+      for (const record of records) {
+        await db.insert(record)
+      }
+      
+      let processedCount = 0
+      let modifiedCount = 0
+      
+      // Iterate with progress callback
+      for await (const entry of db.iterate(
+        { category: 'even' }, 
+        { 
+          chunkSize: 500,
+          progressCallback: (progress) => {
+            processedCount = progress.processed
+            modifiedCount = progress.modified
+          }
+        }
+      )) {
+        // Modify every 20th record (to get exactly 125 from 1250)
+        if (entry.id % 20 === 0) {
+          entry.price = entry.price * 2
+        }
+      }
+      
+      expect(processedCount).toBe(1250) // Half of 2500
+      expect(modifiedCount).toBe(125) // Every 20th of 1250 (20, 40, 60, ..., 2500)
+    })
+
+    test('should handle large datasets efficiently', async () => {
+      // Insert test data
+      const records = []
+      for (let i = 1; i <= 1000; i++) {
+        records.push({ 
+          id: i, 
+          name: `Product${i}`, 
+          category: 'electronics',
+          price: Math.random() * 100
+        })
+      }
+      
+      // Insert all records
+      for (const record of records) {
+        await db.insert(record)
+      }
+      
+      const startTime = Date.now()
+      let count = 0
+      
+      // Iterate through all records
+      for await (const entry of db.iterate({ category: 'electronics' })) {
+        count++
+        // Simple modification
+        entry.lastProcessed = Date.now()
+      }
+      
+      const elapsed = Date.now() - startTime
+      
+      expect(count).toBe(1000)
+      expect(elapsed).toBeLessThan(5000) // Should complete in under 5 seconds
+      
+      // Verify modifications were applied
+      const sample = await db.findOne({ id: 1 })
+      expect(sample.lastProcessed).toBeDefined()
+    })
+  })
+
+  describe('Options and Configuration', () => {
+    test('should respect chunkSize option', async () => {
+      // Insert test data
+      for (let i = 1; i <= 100; i++) {
+        await db.insert({ id: i, name: `Item${i}`, category: 'test' })
+      }
+      
+      let batchCount = 0
+      const chunkSize = 25
+      
+      for await (const entry of db.iterate(
+        { category: 'test' }, 
+        { 
+          chunkSize,
+          progressCallback: (progress) => {
+            if (progress.processed > 0 && progress.processed % chunkSize === 0) {
+              batchCount++
+            }
+          }
+        }
+      )) {
+        entry.processed = true
+      }
+      
+      // Should have processed in 4-5 batches (100 / 25)
+      expect(batchCount).toBeGreaterThanOrEqual(4)
+      expect(batchCount).toBeLessThanOrEqual(5)
+    })
+
+    test('should work with manual change detection', async () => {
+      await db.insert({ id: 1, name: 'Test', category: 'test', value: 1 })
+      
+      for await (const entry of db.iterate(
+        { category: 'test' }, 
+        { detectChanges: false }
+      )) {
+        entry.value = 2
+        entry._modified = true // Manual flag
+      }
+      
+      const result = await db.findOne({ id: 1 })
+      expect(result.value).toBe(2)
+    })
+
+    test('should handle autoSave option', async () => {
+      await db.insert({ id: 1, name: 'Test', category: 'test' })
+      
+      for await (const entry of db.iterate(
+        { category: 'test' }, 
+        { autoSave: true, chunkSize: 1 }
+      )) {
+        entry.name = 'Modified'
+      }
+      
+      // Verify changes were saved
+      const result = await db.findOne({ id: 1 })
+      expect(result.name).toBe('Modified')
+    })
+  })
+
+  describe('Error Handling', () => {
+    test('should handle errors gracefully', async () => {
+      await db.insert({ id: 1, name: 'Test', category: 'test' })
+      
+      let errorCaught = false
+      try {
+        for await (const entry of db.iterate({ category: 'test' })) {
+          // Simulate an error
+          throw new Error('Test error')
+        }
+      } catch (error) {
+        errorCaught = true
+        expect(error.message).toBe('Test error')
+      }
+      
+      expect(errorCaught).toBe(true)
+    })
+
+    test('should validate state before iteration', async () => {
+      await db.destroy()
+      
+      let errorCaught = false
+      try {
+        for await (const entry of db.iterate({})) {
+          // This should not execute
+        }
+      } catch (error) {
+        errorCaught = true
+        expect(error.message).toContain('destroyed')
+      }
+      
+      expect(errorCaught).toBe(true)
+    })
+  })
+})