jexidb 2.1.1 → 2.1.2

package/test/legacy-operator-compat.test.js

@@ -1,154 +0,0 @@
-import { Database } from '../src/Database.mjs'
-import fs from 'fs'
-
-describe('Legacy operator compatibility', () => {
-  let testDbPath
-  let testIdxPath
-
-  beforeEach(() => {
-    const uniqueSuffix = `${Date.now()}-${Math.random().toString(36).slice(2)}`
-    testDbPath = `test-legacy-operators-${uniqueSuffix}.jdb`
-    testIdxPath = testDbPath.replace('.jdb', '.idx.jdb')
-  })
-
-  afterEach(() => {
-    for (const filePath of [testDbPath, testIdxPath]) {
-      if (filePath && fs.existsSync(filePath)) {
-        try {
-          fs.unlinkSync(filePath)
-        } catch (error) {
-          console.warn(`⚠️  Failed to delete ${filePath}: ${error.message}`)
-        }
-      }
-    }
-  })
-
-  test('should support string comparison operators for find/count', async () => {
-    const db = new Database(testDbPath, {
-      indexes: {
-        start: 'number',
-        end: 'number'
-      },
-      termMapping: true,
-      debugMode: false
-    })
-    await db.init()
-
-    const now = Math.floor(Date.now() / 1000)
-
-    await db.insert({
-      id: '1',
-      start: now - 60,
-      end: now + 60
-    })
-
-    await db.insert({
-      id: '2',
-      start: now - 3600,
-      end: now - 300
-    })
-
-    const legacyCount = await db.count({ end: { '>': now } })
-    const mongoCount = await db.count({ end: { $gt: now } })
-    expect(legacyCount).toBe(1)
-    expect(legacyCount).toBe(mongoCount)
-
-    const legacyResults = await db.find({
-      start: { '<=': now },
-      end: { '>': now }
-    })
-    const canonicalResults = await db.find({
-      start: { $lte: now },
-      end: { $gt: now }
-    })
-    const mongoResults = await db.find({
-      start: { $lte: now },
-      end: { $gt: now }
-    })
-
-    expect(legacyResults.map(record => record.id)).toEqual(['1'])
-    expect(canonicalResults.map(record => record.id)).toEqual(['1'])
-    expect(mongoResults.map(record => record.id)).toEqual(['1'])
-
-    await db.save()
-    await db.destroy()
-  })
-
-  test('should support string inequality operator', async () => {
-    const db = new Database(testDbPath, {
-      indexes: {
-        end: 'number'
-      },
-      termMapping: true,
-      debugMode: false
-    })
-    await db.init()
-
-    const now = Math.floor(Date.now() / 1000)
-
-    await db.insert({
-      id: 'A',
-      end: now + 120
-    })
-
-    await db.insert({
-      id: 'B',
-      end: now + 240
-    })
-
-    const legacyResults = await db.find({
-      end: { '!=': now + 120 }
-    })
-
-    expect(legacyResults.map(record => record.id)).toEqual(['B'])
-
-    await db.save()
-    await db.destroy()
-  })
-
-  test('should support mongo-style comparison operators when using indexes', async () => {
-    const db = new Database(testDbPath, {
-      indexes: {
-        numericField: 'number'
-      },
-      debugMode: false
-    })
-    await db.init()
-
-    await db.insert({ id: '10', numericField: 100 })
-    await db.insert({ id: '20', numericField: 200 })
-
-    await db.save()
-    await db.close()
-
-    const reopenedDb = new Database(testDbPath, {
-      create: false,
-      indexes: {
-        numericField: 'number'
-      },
-      debugMode: false
-    })
-    await reopenedDb.init()
-
-    const greaterThanResults = await reopenedDb.find({ numericField: { $gt: 150 } })
-    expect(greaterThanResults.map(record => record.id)).toEqual(['20'])
-
-    const greaterOrEqualResults = await reopenedDb.find({ numericField: { $gte: 200 } })
-    expect(greaterOrEqualResults.map(record => record.id)).toEqual(['20'])
-
-    const lessThanResults = await reopenedDb.find({ numericField: { $lt: 150 } })
-    expect(lessThanResults.map(record => record.id)).toEqual(['10'])
-
-    const lessOrEqualResults = await reopenedDb.find({ numericField: { $lte: 100 } })
-    expect(lessOrEqualResults.map(record => record.id)).toEqual(['10'])
-
-    const notEqualResults = await reopenedDb.find({ numericField: { $ne: 100 } })
-    expect(notEqualResults.map(record => record.id)).toEqual(['20'])
-
-    const countResults = await reopenedDb.count({ numericField: { $gt: 50, $lt: 250 } })
-    expect(countResults).toBe(2)
-
-    await reopenedDb.destroy()
-  })
-})
-

package/test/query-operators.test.js

@@ -1,238 +0,0 @@
-/**
- * Comprehensive tests for query operators
- * Tests the fixes for the $not operator and default operator behavior bugs
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import Database from '../src/Database.mjs';
-import fs from 'fs';
-import path from 'path';
-
-describe('Query Operators', () => {
-  let db;
-  const testDbPath = 'test-query-operators-comprehensive';
-
-  beforeEach(async () => {
-    // Clean up any existing test database
-    if (fs.existsSync(testDbPath + '.jdb')) {
-      fs.unlinkSync(testDbPath + '.jdb');
-    }
-    if (fs.existsSync(testDbPath + '.terms.jdb')) {
-      fs.unlinkSync(testDbPath + '.terms.jdb');
-    }
-
-    db = new Database(testDbPath, {
-      debugMode: false,
-      termMapping: true,
-      termMappingFields: ['nameTerms', 'tags']
-    });
-
-    await db.init();
-
-    // Insert comprehensive test data
-    const testData = [
-      { id: 1, name: 'TV Câmara', nameTerms: ['tv', 'câmara'], tags: ['news', 'politics'], group: 'Brazil', rating: 4.5 },
-      { id: 2, name: 'TV Cultura', nameTerms: ['tv', 'cultura'], tags: ['culture', 'education'], group: 'Brazil', rating: 4.2 },
-      { id: 3, name: 'SBT', nameTerms: ['sbt'], tags: ['entertainment'], group: 'Brazil', rating: 3.8 },
-      { id: 4, name: 'Record News', nameTerms: ['record', 'news'], tags: ['news'], group: 'Brazil', rating: 4.0 },
-      { id: 5, name: 'CNN', nameTerms: ['cnn'], tags: ['news', 'international'], group: 'International', rating: 4.7 },
-      { id: 6, name: 'BBC', nameTerms: ['bbc'], tags: ['news', 'international'], group: 'International', rating: 4.6 },
-      { id: 7, name: 'TV Globo', nameTerms: ['tv', 'globo'], tags: ['entertainment', 'news'], group: 'Brazil', rating: 4.3 },
-      { id: 8, name: 'TV Record', nameTerms: ['tv', 'record'], tags: ['entertainment'], group: 'Brazil', rating: 3.9 },
-      { id: 9, name: 'Discovery', nameTerms: ['discovery'], tags: ['documentary', 'education'], group: 'International', rating: 4.4 },
-      { id: 10, name: 'National Geographic', nameTerms: ['national', 'geographic'], tags: ['documentary', 'nature'], group: 'International', rating: 4.8 }
-    ];
-
-    for (const record of testData) {
-      await db.insert(record);
-    }
-  });
-
-  afterEach(async () => {
-    if (db) {
-      await db.close();
-    }
-    
-    // Clean up test files
-    const files = [testDbPath + '.jdb', testDbPath + '.terms.jdb'];
-    for (const file of files) {
-      if (fs.existsSync(file)) {
-        fs.unlinkSync(file);
-      }
-    }
-  });
-
-  describe('$not Operator Fixes', () => {
-    it('should handle $not operator consistently with or without explicit $and', async () => {
-      // Test 1: $not without explicit $and (the bug case)
-      const result1 = await db.find({nameTerms: 'tv', $not: {nameTerms: { $in: ['cultura'] }}});
-      expect(result1).toHaveLength(3); // TV Câmara, TV Globo, TV Record
-      expect(result1.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Globo', 'TV Record']));
-      expect(result1.map(r => r.name)).not.toContain('TV Cultura');
-
-      // Test 2: $not with explicit $and (should give same result)
-      const result2 = await db.find({"$and": [{nameTerms: 'tv'}, {$not: {nameTerms: { $in: ['cultura'] }}}]});
-      expect(result2).toHaveLength(3);
-      expect(result2.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Globo', 'TV Record']));
-      expect(result2.map(r => r.name)).not.toContain('TV Cultura');
-
-      // Both results should be identical
-      expect(result1.map(r => r.id).sort()).toEqual(result2.map(r => r.id).sort());
-    });
-
-    it('should handle $not with different fields', async () => {
-      const result = await db.find({group: 'Brazil', $not: {nameTerms: { $in: ['globo'] }}});
-      expect(result).toHaveLength(5); // All Brazil channels except TV Globo
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Cultura', 'SBT', 'Record News', 'TV Record']));
-      expect(result.map(r => r.name)).not.toContain('TV Globo');
-    });
-
-    it('should handle complex $not queries', async () => {
-      const result = await db.find({nameTerms: 'tv', $not: {nameTerms: { $in: ['cultura', 'globo'] }}});
-      expect(result).toHaveLength(2); // TV Câmara, TV Record
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Record']));
-      expect(result.map(r => r.name)).not.toContain('TV Cultura');
-      expect(result.map(r => r.name)).not.toContain('TV Globo');
-    });
-
-    it('should handle $not with numeric comparisons', async () => {
-      const result = await db.find({group: 'Brazil', $not: {rating: { $gte: 4.0 }}});
-      expect(result).toHaveLength(2); // SBT (3.8), TV Record (3.9)
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['SBT', 'TV Record']));
-    });
-
-    it('should handle nested $not operators', async () => {
-      const result = await db.find({$not: {nameTerms: { $in: ['tv'] }}});
-      expect(result).toHaveLength(6); // All channels without 'tv' in nameTerms
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['SBT', 'Record News', 'CNN', 'BBC', 'Discovery', 'National Geographic']));
-      expect(result.map(r => r.name)).not.toContain('TV Câmara');
-      expect(result.map(r => r.name)).not.toContain('TV Cultura');
-      expect(result.map(r => r.name)).not.toContain('TV Globo');
-      expect(result.map(r => r.name)).not.toContain('TV Record');
-    });
-  });
-
-  describe('Default Operator Behavior (AND Logic)', () => {
-    it('should use AND logic for multiple conditions at root level', async () => {
-      const result = await db.find({nameTerms: 'tv', group: 'Brazil'});
-      expect(result).toHaveLength(4); // All TV channels in Brazil
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Cultura', 'TV Globo', 'TV Record']));
-    });
-
-    it('should use AND logic for multiple field conditions', async () => {
-      const result = await db.find({group: 'International', rating: { $gte: 4.5 }});
-      expect(result).toHaveLength(3); // CNN, BBC, National Geographic
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['CNN', 'BBC', 'National Geographic']));
-    });
-
-    it('should use AND logic with array field conditions', async () => {
-      const result = await db.find({tags: { $in: ['news'] }, group: 'Brazil'});
-      expect(result).toHaveLength(3); // TV Câmara, Record News, TV Globo
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'Record News', 'TV Globo']));
-    });
-
-    it('should use AND logic with mixed operators', async () => {
-      const result = await db.find({
-        nameTerms: 'tv',
-        group: 'Brazil',
-        rating: { $gte: 4.0 },
-        tags: { $in: ['news'] }
-      });
-      expect(result).toHaveLength(2); // TV Câmara, TV Globo
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Globo']));
-    });
-  });
-
-  describe('Complex Query Combinations', () => {
-    it('should handle $and with $not', async () => {
-      const result = await db.find({
-        "$and": [
-          {group: 'Brazil'},
-          {$not: {nameTerms: { $in: ['cultura', 'globo'] }}}
-        ]
-      });
-      expect(result).toHaveLength(4); // All Brazil channels except TV Cultura and TV Globo
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'SBT', 'Record News', 'TV Record']));
-    });
-
-    it('should handle $or with $not', async () => {
-      const result = await db.find({
-        "$or": [
-          {nameTerms: 'tv'},
-          {group: 'International'}
-        ],
-        $not: {rating: { $lt: 4.0 }}
-      });
-      // Should include TV channels with rating >= 4.0 OR International channels with rating >= 4.0
-      expect(result.length).toBeGreaterThan(0);
-      result.forEach(record => {
-        expect(record.rating).toBeGreaterThanOrEqual(4.0);
-      });
-    });
-
-    it('should handle multiple $not conditions', async () => {
-      // Note: Multiple $not conditions with the same key will overwrite each other
-      // This is expected JavaScript behavior. For multiple conditions, use $and
-      const result = await db.find({
-        "$and": [
-          {group: 'Brazil'},
-          {$not: {nameTerms: { $in: ['cultura'] }}},
-          {$not: {rating: { $lt: 4.0 }}}
-        ]
-      });
-      // This should be equivalent to: Brazil AND NOT cultura AND NOT rating < 4.0
-      expect(result.length).toBeGreaterThan(0);
-      result.forEach(record => {
-        expect(record.group).toBe('Brazil');
-        expect(record.nameTerms).not.toContain('cultura');
-        expect(record.rating).toBeGreaterThanOrEqual(4.0);
-      });
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle empty $not condition', async () => {
-      const result = await db.find({nameTerms: 'tv', $not: {}});
-      expect(result).toHaveLength(4); // All TV channels (empty $not matches nothing, so excludes nothing)
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Cultura', 'TV Globo', 'TV Record']));
-    });
-
-    it('should handle $not with non-existent field', async () => {
-      const result = await db.find({nameTerms: 'tv', $not: {nonExistentField: 'value'}});
-      expect(result).toHaveLength(4); // All TV channels (non-existent field never matches)
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Cultura', 'TV Globo', 'TV Record']));
-    });
-
-    it('should handle $not with null values', async () => {
-      // Insert a record with null value
-      await db.insert({ id: 99, name: 'Test Channel', nameTerms: null, group: 'Test' });
-      
-      const result = await db.find({group: 'Test', $not: {nameTerms: null}});
-      expect(result).toHaveLength(0); // No records match (the only Test record has null nameTerms)
-    });
-  });
-
-  describe('Performance and Consistency', () => {
-    it('should produce consistent results across multiple queries', async () => {
-      const query = {nameTerms: 'tv', $not: {nameTerms: { $in: ['cultura'] }}};
-      
-      // Run the same query multiple times
-      const results = [];
-      for (let i = 0; i < 5; i++) {
-        const result = await db.find(query);
-        results.push(result.map(r => r.id).sort());
-      }
-      
-      // All results should be identical
-      for (let i = 1; i < results.length; i++) {
-        expect(results[i]).toEqual(results[0]);
-      }
-    });
-
-    it('should handle large result sets with $not', async () => {
-      // This test ensures the fix works with larger datasets
-      const result = await db.find({$not: {group: 'NonExistent'}});
-      expect(result).toHaveLength(10); // All records (since no records have group 'NonExistent')
-    });
-  });
-});

package/test/regex-array-fields.test.js

@@ -1,129 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from '@jest/globals'
-import { Database } from '../src/Database.mjs'
-import path from 'path'
-
-describe('RegExp Queries on Array Fields', () => {
-  let testDir
-  let db
-
-  beforeEach(async () => {
-    testDir = path.join(process.cwd(), 'test-dbs')
-  })
-
-  afterEach(async () => {
-    if (db) {
-      await db.save()
-      await db.destroy()
-      db = null
-    }
-  })
-
-  describe('Bug Fix: RegExp on Array Fields', () => {
-    test('should correctly filter array fields with RegExp queries', async () => {
-      const dbPath = path.join(testDir, 'regex-array-fields.jdb')
-      
-      db = new Database(dbPath, {
-        clear: true,
-        create: true,
-        debugMode: false
-      })
-
-      await db.init()
-
-      // Insert test data
-      await db.insert({ name: 'Globo', nameTerms: ['globo'] })
-      await db.insert({ name: 'FlixHD', nameTerms: ['flixhd'] })
-      await db.insert({ name: 'Netflix', nameTerms: ['netflix'] })
-      await db.insert({ name: 'Global News', nameTerms: ['global', 'news'] })
-
-      // Test 1: RegExp query that should match multiple records
-      const results1 = await db.find({ nameTerms: new RegExp('glob', 'i') })
-      expect(results1.length).toBe(2)
-      expect(results1.some(r => r.name === 'Globo')).toBe(true)
-      expect(results1.some(r => r.name === 'Global News')).toBe(true)
-
-      // Test 2: RegExp query with impossible pattern
-      const results2 = await db.find({ nameTerms: new RegExp('IMPOSSIBLE_PATTERN_12345', 'i') })
-      expect(results2.length).toBe(0)
-
-      // Test 3: RegExp query that matches multiple records with "flix"
-      const results3 = await db.find({ nameTerms: new RegExp('flix', 'i') })
-      expect(results3.length).toBe(2)
-      expect(results3.some(r => r.name === 'FlixHD')).toBe(true)
-      expect(results3.some(r => r.name === 'Netflix')).toBe(true)
-
-      // Test 4: RegExp query with anchor (start of string)
-      const results4 = await db.find({ nameTerms: new RegExp('^flix', 'i') })
-      expect(results4.length).toBe(1)
-      expect(results4[0].name).toBe('FlixHD')
-
-      // Test 5: RegExp query with case sensitivity
-      const results5 = await db.find({ nameTerms: new RegExp('GLOBO') })
-      expect(results5.length).toBe(0) // Should not match because it's case-sensitive
-
-      const results6 = await db.find({ nameTerms: new RegExp('GLOBO', 'i') })
-      expect(results6.length).toBe(1) // Should match because it's case-insensitive
-      expect(results6[0].name).toBe('Globo')
-    })
-
-    test('should correctly handle RegExp queries with multi-element arrays', async () => {
-      const dbPath = path.join(testDir, 'regex-multi-array.jdb')
-      
-      db = new Database(dbPath, {
-        clear: true,
-        create: true,
-        debugMode: false
-      })
-
-      await db.init()
-
-      // Insert test data with multi-element arrays
-      await db.insert({ name: 'Test 1', tags: ['javascript', 'nodejs', 'backend'] })
-      await db.insert({ name: 'Test 2', tags: ['python', 'django', 'backend'] })
-      await db.insert({ name: 'Test 3', tags: ['javascript', 'react', 'frontend'] })
-      await db.insert({ name: 'Test 4', tags: ['ruby', 'rails', 'backend'] })
-
-      // Test: RegExp query that matches first element
-      const results1 = await db.find({ tags: new RegExp('java', 'i') })
-      expect(results1.length).toBe(2)
-      expect(results1.some(r => r.name === 'Test 1')).toBe(true)
-      expect(results1.some(r => r.name === 'Test 3')).toBe(true)
-
-      // Test: RegExp query that matches middle element
-      const results2 = await db.find({ tags: new RegExp('react', 'i') })
-      expect(results2.length).toBe(1)
-      expect(results2[0].name).toBe('Test 3')
-
-      // Test: RegExp query that matches last element
-      const results3 = await db.find({ tags: new RegExp('backend', 'i') })
-      expect(results3.length).toBe(3)
-      expect(results3.some(r => r.name === 'Test 1')).toBe(true)
-      expect(results3.some(r => r.name === 'Test 2')).toBe(true)
-      expect(results3.some(r => r.name === 'Test 4')).toBe(true)
-    })
-
-    test('should correctly handle $regex operator on array fields', async () => {
-      const dbPath = path.join(testDir, 'regex-operator-array.jdb')
-      
-      db = new Database(dbPath, {
-        clear: true,
-        create: true,
-        debugMode: false
-      })
-
-      await db.init()
-
-      // Insert test data
-      await db.insert({ name: 'Globo', nameTerms: ['globo'] })
-      await db.insert({ name: 'FlixHD', nameTerms: ['flixhd'] })
-      await db.insert({ name: 'Netflix', nameTerms: ['netflix'] })
-      await db.insert({ name: 'Global News', nameTerms: ['global', 'news'] })
-
-      // Test: $regex operator query
-      const results = await db.find({ nameTerms: { $regex: 'glob' } })
-      expect(results.length).toBe(2)
-      expect(results.some(r => r.name === 'Globo')).toBe(true)
-      expect(results.some(r => r.name === 'Global News')).toBe(true)
-    })
-  })
-})