jexidb 2.1.0 → 2.1.2

package/scripts/run-tests.js

@@ -1,80 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from 'child_process'
-import { fileURLToPath } from 'url'
-import { dirname, join } from 'path'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-
-async function runTests() {
-  const startTime = Date.now()
-  
-  console.log('🧪 Running JexiDB tests...')
-  
-  // Run Jest tests
-  const jestProcess = spawn('npx', ['jest', ...process.argv.slice(2)], {
-    stdio: 'inherit',
-    shell: true
-  })
-  
-  jestProcess.on('close', async (code) => {
-    if (code !== 0) {
-      console.error(`❌ Tests failed with exit code ${code}`)
-      process.exit(code)
-    }
-    
-    // Run cleanup
-    const cleanupProcess = spawn('npm', ['run', 'clean:test-files'], {
-      stdio: 'inherit',
-      shell: true
-    })
-    
-    cleanupProcess.on('close', (cleanupCode) => {
-      const endTime = Date.now()
-      const duration = Math.round((endTime - startTime) / 1000)
-  
-      // Display completion time
-      const completionTime = new Date().toLocaleString('en-US', {
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-        hour12: true
-      });
-      
-      console.log(`✅ Tests completed at: ${completionTime}`);
-      console.log(`📦 Total execution time: ${duration}s`)
-      
-      if (cleanupCode !== 0) {
-        console.warn(`⚠️  Cleanup completed with warnings (exit code: ${cleanupCode})`)
-      }
-      
-      process.exit(0)
-    })
-  })
-  
-  jestProcess.on('error', (error) => {
-    console.error('❌ Failed to start Jest:', error.message)
-    process.exit(1)
-  })
-}
-
-// Handle process termination
-process.on('SIGINT', () => {
-  console.log('\n🛑 Test execution interrupted by user')
-  process.exit(0)
-})
-
-process.on('SIGTERM', () => {
-  console.log('\n🛑 Test execution terminated')
-  process.exit(0)
-})
-
-// Run the tests
-runTests().catch(error => {
-  console.error('❌ Fatal error:', error.message)
-  process.exit(1)
-})

package/test/$not-operator-with-and.test.js

@@ -1,282 +0,0 @@
-/**
- * $not Operator with $and on Array Fields Test
- * 
- * Bug Report: https://github.com/yourrepo/jexidb/issues/XXX
- * 
- * Issue: When using $not with $and on array fields in strict mode,
- * queries return empty results even when matching documents exist.
- * 
- * Root Cause: IndexManager.query() did not handle the $not operator,
- * treating it as an unknown field and returning an empty set.
- * Additionally, when fields existed at both root level and inside $and,
- * only the $and conditions were being processed.
- * 
- * Fix: Added proper $not handling in IndexManager.query() that:
- * 1. Gets all possible line numbers from database offsets
- * 2. Queries for the $not condition
- * 3. Returns the complement (all lines except those matching $not)
- * 4. Intersects with other root-level conditions if present
- * Also fixed $and to properly intersect with root-level fields.
- */
-
-import { Database } from '../src/Database.mjs'
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals'
-import fs from 'fs'
-
-describe('$not Operator with $and on Array Fields', () => {
-  let db
-  const testFile = './test-files/not-operator-test.jdb'
-  const testIdxFile = './test-files/not-operator-test.idx.jdb'
-
-  beforeEach(async () => {
-    // Clean up test files
-    try {
-      if (fs.existsSync(testFile)) fs.unlinkSync(testFile)
-      if (fs.existsSync(testIdxFile)) fs.unlinkSync(testIdxFile)
-    } catch (err) {
-      // Ignore cleanup errors
-    }
-
-    // Create database with array field
-    db = new Database(testFile, {
-      clear: true,
-      create: true,
-      integrityCheck: 'none',
-      indexedQueryMode: 'strict',
-      fields: {
-        name: 'string',
-        nameTerms: 'array:string',
-      },
-      indexes: ['name', 'nameTerms']
-    })
-
-    await db.init()
-
-    // Insert test data
-    const testData = [
-      { name: 'SBT Nacional', nameTerms: ['sbt'] },
-      { name: 'SBT HD', nameTerms: ['sbt'] },
-      { name: 'SBT Radio', nameTerms: ['sbt', 'radio'] },
-      { name: 'SBT FM', nameTerms: ['sbt', 'fm'] },
-      { name: 'Radio FM', nameTerms: ['radio', 'fm'] },
-      { name: 'Globo', nameTerms: ['globo'] },
-    ]
-
-    for (const doc of testData) {
-      await db.insert(doc)
-    }
-
-    await db.flush()
-    await db.close()
-
-    // Re-open database
-    db = new Database(testFile, {
-      create: false,
-      integrityCheck: 'none',
-      indexedQueryMode: 'strict',
-      fields: {
-        name: 'string',
-        nameTerms: 'array:string',
-      },
-      indexes: ['name', 'nameTerms']
-    })
-    
-    await db.init()
-  })
-
-  afterEach(async () => {
-    if (db && !db.destroyed) {
-      try {
-        await db.destroy()
-      } catch (err) {
-        // Ignore destroy errors
-      }
-    }
-
-    // Clean up test files
-    try {
-      if (fs.existsSync(testFile)) fs.unlinkSync(testFile)
-      if (fs.existsSync(testIdxFile)) fs.unlinkSync(testIdxFile)
-    } catch (err) {
-      // Ignore cleanup errors
-    }
-  })
-
-  it('should handle $not with $and (positive condition first)', async () => {
-    const query = {
-      $and: [
-        { nameTerms: { $in: ['sbt'] } },
-        { $not: { nameTerms: { $in: ['radio', 'fm'] } } }
-      ]
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(2)
-    expect(results[0].name).toBe('SBT Nacional')
-    expect(results[1].name).toBe('SBT HD')
-  })
-
-  it('should handle $not with $and (negative condition first)', async () => {
-    const query = {
-      $and: [
-        { $not: { nameTerms: { $in: ['radio', 'fm'] } } },
-        { nameTerms: { $in: ['sbt'] } }
-      ]
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(2)
-    expect(results[0].name).toBe('SBT Nacional')
-    expect(results[1].name).toBe('SBT HD')
-  })
-
-  it('should handle $not WITHOUT $and (root level)', async () => {
-    const query = {
-      nameTerms: { $in: ['sbt'] },
-      $not: { nameTerms: { $in: ['radio', 'fm'] } }
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(2)
-    expect(results[0].name).toBe('SBT Nacional')
-    expect(results[1].name).toBe('SBT HD')
-  })
-
-  it('should handle multiple $not in $and with root-level field', async () => {
-    const query = {
-      nameTerms: { $in: ['sbt'] },
-      $and: [
-        { $not: { nameTerms: 'radio' } },
-        { $not: { nameTerms: 'fm' } }
-      ]
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(2)
-    expect(results[0].name).toBe('SBT Nacional')
-    expect(results[1].name).toBe('SBT HD')
-  })
-
-  it('should handle $not with single value', async () => {
-    const query = {
-      $and: [
-        { nameTerms: { $in: ['sbt'] } },
-        { $not: { nameTerms: 'radio' } }
-      ]
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(3)
-    const names = results.map(r => r.name).sort()
-    expect(names).toEqual(['SBT FM', 'SBT HD', 'SBT Nacional'])
-  })
-
-  it('should handle complex $not queries with multiple conditions', async () => {
-    const query = {
-      $and: [
-        { nameTerms: { $in: ['sbt', 'globo'] } },
-        { $not: { nameTerms: { $in: ['radio', 'fm'] } } }
-      ]
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(3)
-    const names = results.map(r => r.name).sort()
-    expect(names).toEqual(['Globo', 'SBT HD', 'SBT Nacional'])
-  })
-
-  it('should handle $not that excludes all results', async () => {
-    const query = {
-      $and: [
-        { nameTerms: { $in: ['sbt'] } },
-        { $not: { nameTerms: 'sbt' } }
-      ]
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(0)
-  })
-
-  it('should handle $not with non-existent values', async () => {
-    const query = {
-      $and: [
-        { nameTerms: { $in: ['sbt'] } },
-        { $not: { nameTerms: { $in: ['nonexistent', 'invalid'] } } }
-      ]
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(4)
-    const names = results.map(r => r.name).sort()
-    expect(names).toEqual(['SBT FM', 'SBT HD', 'SBT Nacional', 'SBT Radio'])
-  })
-
-  it('should handle $nin operator in strict mode', async () => {
-    const query = {
-      nameTerms: { $nin: ['radio', 'fm'] }
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(3)
-    const names = results.map(r => r.name).sort()
-    expect(names).toEqual(['Globo', 'SBT HD', 'SBT Nacional'])
-  })
-
-  it('should handle $nin with $in in strict mode', async () => {
-    const query = {
-      $and: [
-        { nameTerms: { $in: ['sbt'] } },
-        { nameTerms: { $nin: ['radio', 'fm'] } }
-      ]
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(2)
-    expect(results[0].name).toBe('SBT Nacional')
-    expect(results[1].name).toBe('SBT HD')
-  })
-
-  it('should handle $nin with single value', async () => {
-    const query = {
-      nameTerms: { $nin: ['radio'] }
-    }
-
-    const results = await db.find(query)
-    
-    expect(results).toHaveLength(4)
-    const names = results.map(r => r.name).sort()
-    expect(names).toEqual(['Globo', 'SBT FM', 'SBT HD', 'SBT Nacional'])
-  })
-
-  it('should produce same results for $nin and $not+$in', async () => {
-    // Query with $nin
-    const ninQuery = {
-      nameTerms: { $nin: ['radio', 'fm'] }
-    }
-    
-    // Equivalent query with $not + $in
-    const notQuery = {
-      $not: { nameTerms: { $in: ['radio', 'fm'] } }
-    }
-
-    const ninResults = await db.find(ninQuery)
-    const notResults = await db.find(notQuery)
-    
-    expect(ninResults).toHaveLength(notResults.length)
-    
-    const ninNames = ninResults.map(r => r.name).sort()
-    const notNames = notResults.map(r => r.name).sort()
-    expect(ninNames).toEqual(notNames)
-  })
-})
-

package/test/README.md

@@ -1,8 +0,0 @@
-## Test Results
-The following are the results of the automated tests conducted on my PC for JSON format.
-
-| Format                         | Size (bytes) | Time elapsed (ms) |
-|-------------------------------|--------------|--------------------|
-| JSON                          | 1117         | 21                 |
-
-JSON format provides universal compatibility across all environments and Node.js versions.

package/test/close-init-cycle.test.js

@@ -1,256 +0,0 @@
-/**
- * Close → Init Cycle Tests
- * 
- * Tests the ability to call init() after close() to reopen a database
- * This addresses the bug where databases couldn't be reopened after closing
- */
-
-import Database from '../src/Database.mjs'
-import fs from 'fs'
-
-describe('Close → Init Cycle', () => {
-  let db
-  const testFile = 'test-close-init-cycle.jdb'
-
-  beforeEach(() => {
-    // Clean up any existing test files
-    if (fs.existsSync(testFile)) fs.unlinkSync(testFile)
-    if (fs.existsSync(testFile.replace('.jdb', '.idx.jdb'))) fs.unlinkSync(testFile.replace('.jdb', '.idx.jdb'))
-    
-    db = new Database(testFile, {
-      create: true,
-      debugMode: false
-    })
-  })
-
-  afterEach(async () => {
-    if (db && !db.destroyed) {
-      try {
-        // Save any pending data before destroying
-        if (!db.closed && db.writeBuffer && db.writeBuffer.length > 0) {
-          await db.save()
-        }
-        await db.destroy()
-      } catch (error) {
-        // Ignore destroy errors for this test
-        console.warn('Destroy error ignored:', error.message)
-      }
-    }
-  })
-
-  describe('Basic Close → Init Cycle', () => {
-    it('should allow init() after close()', async () => {
-      // Initialize database
-      await db.init()
-      expect(db.initialized).toBe(true)
-      expect(db.closed).toBe(false)
-
-      // Insert some data
-      await db.insert({ name: 'Test1', value: 100 })
-      await db.insert({ name: 'Test2', value: 200 })
-
-      // Close database
-      await db.close()
-      expect(db.closed).toBe(true)
-      expect(db.initialized).toBe(false)
-      expect(db.destroyed).toBe(false) // Should not be destroyed
-
-      // Reinitialize database
-      await db.init()
-      expect(db.initialized).toBe(true)
-      expect(db.closed).toBe(false)
-
-      // Verify data is still accessible
-      const results = await db.find({})
-      expect(results).toHaveLength(2)
-      expect(results.some(r => r.name === 'Test1')).toBe(true)
-      expect(results.some(r => r.name === 'Test2')).toBe(true)
-    })
-
-    it('should support multiple close → init cycles', async () => {
-      await db.init()
-      await db.insert({ name: 'Test', value: 123 })
-
-      // First cycle
-      await db.close()
-      await db.init()
-      let results = await db.find({})
-      expect(results).toHaveLength(1)
-
-      // Second cycle
-      await db.close()
-      await db.init()
-      results = await db.find({})
-      expect(results).toHaveLength(1)
-
-      // Third cycle
-      await db.close()
-      await db.init()
-      results = await db.find({})
-      expect(results).toHaveLength(1)
-    })
-
-    it('should preserve data across close → init cycles', async () => {
-      await db.init()
-      
-      // Insert initial data
-      await db.insert({ name: 'Initial', value: 1 })
-      await db.close()
-      await db.init()
-
-      // Add more data
-      await db.insert({ name: 'AfterReopen', value: 2 })
-      await db.close()
-      await db.init()
-
-      // Verify all data is preserved
-      const results = await db.find({})
-      expect(results).toHaveLength(2)
-      expect(results.some(r => r.name === 'Initial')).toBe(true)
-      expect(results.some(r => r.name === 'AfterReopen')).toBe(true)
-    })
-  })
-
-  describe('Operations After Reinit', () => {
-    it('should support basic operations after reinit', async () => {
-      await db.init()
-      await db.insert({ name: 'Test1', value: 100 })
-      await db.save() // Ensure data is saved
-      await db.close()
-      await db.init()
-      
-      // Should be able to query existing data
-      const results = await db.find({})
-      expect(results).toHaveLength(1)
-      expect(results[0].name).toBe('Test1')
-    })
-
-    it('should support insert operations after reinit', async () => {
-      await db.init()
-      await db.close()
-      await db.init()
-      
-      await db.insert({ name: 'Test2', value: 200 })
-      const results = await db.find({})
-      expect(results).toHaveLength(1)
-      expect(results[0].name).toBe('Test2')
-    })
-  })
-
-  describe('Error Handling', () => {
-    it('should throw error for operations on closed database', async () => {
-      await db.init()
-      await db.insert({ name: 'Test', value: 123 })
-      await db.close()
-
-      // Operations on closed database should throw error
-      await expect(db.find({})).rejects.toThrow('Database is closed')
-      await expect(db.insert({ name: 'Test2', value: 456 })).rejects.toThrow('Database is closed')
-      await expect(db.update({ name: 'Test' }, { value: 999 })).rejects.toThrow('Database is closed')
-      await expect(db.delete({ name: 'Test' })).rejects.toThrow('Database is closed')
-    })
-
-    it('should allow reinit after operations on closed database', async () => {
-      await db.init()
-      await db.insert({ name: 'Test', value: 123 })
-      await db.close()
-
-      // Try operation on closed database (should fail)
-      await expect(db.find({})).rejects.toThrow('Database is closed')
-
-      // Reinit should work
-      await db.init()
-      const results = await db.find({})
-      expect(results).toHaveLength(1)
-    })
-
-    it('should not allow init() on destroyed database', async () => {
-      await db.init()
-      
-      // Skip this test due to writeBuffer bug in destroy()
-      // TODO: Fix writeBuffer bug and re-enable this test
-      console.log('⚠️ Skipping destroyed database test due to writeBuffer bug')
-    })
-  })
-
-  describe('State Management', () => {
-    it('should have correct state flags during close → init cycle', async () => {
-      // Initial state
-      expect(db.initialized).toBe(false)
-      expect(db.closed).toBe(false)
-      expect(db.destroyed).toBe(false)
-
-      // After init
-      await db.init()
-      expect(db.initialized).toBe(true)
-      expect(db.closed).toBe(false)
-      expect(db.destroyed).toBe(false)
-
-      // After close
-      await db.close()
-      expect(db.initialized).toBe(false)
-      expect(db.closed).toBe(true)
-      expect(db.destroyed).toBe(false)
-
-      // After reinit
-      await db.init()
-      expect(db.initialized).toBe(true)
-      expect(db.closed).toBe(false)
-      expect(db.destroyed).toBe(false)
-    })
-
-    it('should reset write buffer state after close', async () => {
-      await db.init()
-      await db.insert({ name: 'Test', value: 123 })
-      
-      // Write buffer should have data
-      expect(db.writeBuffer.length).toBeGreaterThan(0)
-      
-      await db.close()
-      
-      // Write buffer should be cleared after close
-      expect(db.writeBuffer.length).toBe(0)
-      expect(db.shouldSave).toBe(false)
-      expect(db.isSaving).toBe(false)
-    })
-  })
-
-  describe('Performance and Memory', () => {
-    it('should not leak memory during multiple close → init cycles', async () => {
-      const initialMemory = process.memoryUsage().heapUsed
-      
-      for (let i = 0; i < 10; i++) {
-        await db.init()
-        await db.insert({ name: `Test${i}`, value: i })
-        await db.close()
-      }
-      
-      const finalMemory = process.memoryUsage().heapUsed
-      const memoryIncrease = finalMemory - initialMemory
-      
-      // Memory increase should be reasonable (less than 10MB)
-      expect(memoryIncrease).toBeLessThan(10 * 1024 * 1024)
-    })
-
-    it('should handle large datasets across close → init cycles', async () => {
-      await db.init()
-      
-      // Insert large dataset
-      for (let i = 0; i < 1000; i++) {
-        await db.insert({ name: `Record${i}`, value: i, data: 'x'.repeat(100) })
-      }
-      
-      await db.close()
-      await db.init()
-      
-      // Verify all data is accessible
-      const results = await db.find({})
-      expect(results).toHaveLength(1000)
-      
-      // Verify specific records
-      const specific = await db.find({ name: 'Record500' })
-      expect(specific).toHaveLength(1)
-      expect(specific[0].value).toBe(500)
-    })
-  })
-})