jexidb 2.1.1 → 2.1.3

package/scripts/clean-test-files.js

@@ -1,75 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'fs';
-import path from 'path';
-
-function cleanTestFiles() {
-  const startTime = Date.now();
-  const currentDir = process.cwd();
-  const files = fs.readdirSync(currentDir);
-  
-  const testFilePatterns = [
-    /^test-db-.*\.jdb$/,
-    /^test-db-.*\.offsets\.jdb$/,
-    /^test-db-.*\.idx\.jdb$/,
-    /^test-db-.*$/, // Files without extension
-    /^test-normalize.*\.jdb$/,
-    /^test-normalize.*\.offsets\.jdb$/,
-    /^test-normalize.*\.idx\.jdb$/,
-    /^test-normalize.*$/, // Files without extension
-    /^test-confusion.*\.jdb$/,
-    /^test-confusion.*\.offsets\.jdb$/,
-    /^test-confusion.*\.idx\.jdb$/,
-    /^test-confusion.*$/, // Files without extension
-    /^debug-.*\.jdb$/,
-    /^debug-.*\.offsets\.jdb$/,
-    /^debug-.*\.idx\.jdb$/,
-    /^debug-.*$/, // Files without extension
-    /^test-simple-.*$/, // test-simple files
-    /^test-count\.jdb$/, // test-count.jdb file
-    /^test-index-persistence-.*\.jdb$/, // index persistence test files
-    /^test-index-persistence-.*\.idx\.jdb$/, // index persistence idx files
-    /^test-indexed-mode-.*\.jdb$/, // indexed mode test files
-    /^test-indexed-mode-.*\.idx\.jdb$/, // indexed mode idx files
-    /^test-term-mapping-.*\.jdb$/, // term mapping test files
-    /^test-term-mapping-.*\.idx\.jdb$/, // term mapping idx files
-    /^test-.*\.jdb$/, // Any test file with .jdb extension
-    /^test-.*\.idx\.jdb$/ // Any test file with .idx.jdb extension
-  ];
-  
-  let cleanedCount = 0;
-  
-  files.forEach(file => {
-    const filePath = path.join(currentDir, file);
-    const stats = fs.statSync(filePath);
-    
-    if (stats.isFile()) {
-      const shouldDelete = testFilePatterns.some(pattern => pattern.test(file));
-      
-      if (shouldDelete) {
-        try {
-          fs.unlinkSync(filePath);
-          cleanedCount++;
-        } catch (error) {
-          console.warn(`Warning: Could not delete ${file}: ${error.message}`);
-        }
-      }
-    }
-  });
-  
-  const endTime = Date.now();
-  const duration = endTime - startTime;
-  
-  if (cleanedCount > 0) {
-    console.log(`✅ Cleaned ${cleanedCount} test files.`);
-  } else {
-    console.log('No test files found to clean.');
-  }
-}
-
-// Run cleanup if this script is executed directly
-if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith('clean-test-files.js')) {
-  cleanTestFiles();
-}
-
-export default cleanTestFiles;

package/scripts/prepare.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-
-import { existsSync } from 'fs';
-import { execSync } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const rootDir = join(__dirname, '..');
-const distFile = join(rootDir, 'dist', 'Database.cjs');
-
-// Check if the bundle already exists
-if (existsSync(distFile)) {
-  console.log('✅ Bundle already exists, skipping build');
-  process.exit(0);
-}
-
-console.log('📦 Bundle not found, building...');
-
-try {
-  execSync('npm run build', { 
-    stdio: 'inherit',
-    cwd: rootDir
-  });
-  console.log('✅ Build completed successfully');
-} catch (error) {
-  console.error('❌ Build failed:', error.message);
-  process.exit(1);
-}
-

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/scripts/score-mode-demo.js

@@ -1,45 +0,0 @@
-import { Database } from '../src/Database.mjs'
-import path from 'path'
-import fs from 'fs'
-
-const dbPath = path.join(process.cwd(), 'temp-score-demo.jdb')
-const idxPath = dbPath.replace('.jdb', '.idx.jdb')
-
-for (const file of [dbPath, idxPath]) {
-  if (fs.existsSync(file)) {
-    fs.unlinkSync(file)
-  }
-}
-
-const db = new Database(dbPath, {
-  indexes: { terms: 'array:string' }
-})
-
-await db.init()
-
-await db.insert({ id: 1, title: 'Ação', terms: ['action'] })
-await db.insert({ id: 2, title: 'Comédia', terms: ['comedy'] })
-await db.insert({ id: 3, title: 'Ação + Comédia', terms: ['action', 'comedy'] })
-await db.save()
-
-const weights = { action: 2.0, comedy: 1.0 }
-
-const modes = ['sum', 'max', 'avg', 'first']
-
-for (const mode of modes) {
-  const results = await db.score('terms', weights, { mode })
-  console.log(`\nmode=${mode}`)
-  for (const entry of results) {
-    console.log(`  ${entry.title.padEnd(16)} score=${entry.score}`)
-  }
-}
-
-await db.destroy()
-
-for (const file of [dbPath, idxPath]) {
-  if (fs.existsSync(file)) {
-    fs.unlinkSync(file)
-  }
-}
-
-

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.