jexidb 2.0.3 → 2.1.1

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

@@ -0,0 +1,154 @@
+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

@@ -0,0 +1,238 @@
+/**
+ * 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

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