jexidb 2.0.3 → 2.1.1

package/jest.config.js

@@ -0,0 +1,24 @@
+export default {
+  testEnvironment: 'node',
+  testMatch: ['**/test/**/*.test.js', '**/test/**/*.test.mjs'],
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  coveragePathIgnorePatterns: [
+    '/node_modules/',
+    '/test/',
+    '/dist/'
+  ],
+  verbose: true,
+  testTimeout: 10000,
+  maxWorkers: '50%', // Allow parallel test execution for better performance
+  detectOpenHandles: true, // Detect open handles to identify resource leaks
+  transform: {
+    '^.+\\.mjs$': 'babel-jest',
+    '^.+\\.js$': 'babel-jest'
+  },
+  transformIgnorePatterns: [
+    'node_modules/(?!(.*\\.mjs$|p-limit|yocto-queue))'
+  ],
+  setupFilesAfterEnv: ['<rootDir>/test/setup.js']
+};

package/package.json

@@ -1,68 +1,77 @@
 {
   "name": "jexidb",
-  "version": "2.0.3",
-  "description": "JexiDB - A fast and reliable local CRUD database for Electron apps with pure JavaScript JSONL architecture",
-  "main": "./dist/index.js",
-  "module": "./src/index.js",
-  "types": "./dist/index.d.ts",
+  "version": "2.1.1",
+  "type": "module",
+  "description": "JexiDB is a pure JS NPM library for managing data on disk efficiently, without the need for a server.",
+  "main": "./dist/Database.cjs",
+  "module": "./src/Database.mjs",
   "exports": {
     ".": {
-      "import": "./src/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./package.json": "./package.json"
+      "require": "./dist/Database.cjs",
+      "import": "./src/Database.mjs"
+    }
   },
   "scripts": {
-    "build": "babel src -d dist",
-    "dev": "babel src -d dist --watch",
-    "test": "jest && node scripts/cleanup-after-tests.js",
+    "test": "node scripts/run-tests.js",
     "test:watch": "jest --watch",
-    "test:clean": "node scripts/cleanup-after-tests.js",
-    "test:optimized": "node scripts/optimize-tests.js --performance",
-    "test:parallel": "node scripts/optimize-tests.js --parallel --workers 4",
-    "test:fast": "node scripts/optimize-tests.js --parallel --workers 4 --performance --no-isolation",
-    "prepublishOnly": "npm run build",
-    "generate-test-db": "node scripts/run-test-db.js",
-    "generate-test-db:multiple": "node scripts/run-test-db.js --multiple",
-    "list-test-dbs": "node scripts/list-test-dbs.js",
-    "verify-test-db": "node scripts/verify-test-db.js",
-    "test-optimization": "node scripts/test-optimization.js",
-    "benchmark-compression": "node scripts/benchmark-compression.js",
-    "benchmark-performance": "node scripts/benchmark-performance.js",
-    "generate-docs": "node scripts/generate-docs.js"
+    "test:coverage": "jest --coverage && npm run clean:test-files",
+    "test:legacy": "node --expose-gc test/test.mjs",
+    "clean:test-files": "node scripts/clean-test-files.js",
+    "build": "npx babel src/Database.mjs --plugins @babel/plugin-transform-async-generator-functions --out-file-extension .cjs --out-dir dist",
+    "prepare": "node scripts/prepare.js"
   },
-  "keywords": [
-    "database",
-    "crud",
-    "local",
-    "electron",
-    "javascript",
-    "json",
-    "storage",
-    "jexidb",
-    "jsonl",
-    "nosql"
-  ],
-  "author": "Edenware",
+  "author": "EdenwareApps",
   "license": "MIT",
   "devDependencies": {
-    "@babel/cli": "^7.23.0",
-    "@babel/core": "^7.23.0",
-    "@babel/preset-env": "^7.23.0",
-    "jest": "^29.7.0"
+    "@babel/cli": "^7.25.6",
+    "@babel/core": "^7.25.2",
+    "@babel/plugin-transform-async-generator-functions": "^7.25.4",
+    "@babel/preset-env": "^7.28.3",
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "babel-jest": "^30.0.5",
+    "jest": "^30.1.3",
+    "jest-extended": "^6.0.0",
+    "rollup": "^4.48.1"
+  },
+  "dependencies": {
+    "@valentech/sializer": "^0.3.9",
+    "async-mutex": "^0.5.0",
+    "p-limit": "^6.1.0"
+  },
+  "optionalDependencies": {
+    "fast-deep-equal": "^3.1.3",
+    "fast-json-stringify": "^5.7.0",
+    "msgpack": "^1.0.3"
   },
-  "engines": {
-    "node": ">=14.0.0"
+  "directories": {
+    "test": "test"
   },
-  "files": [
-    "dist",
-    "src",
-    "README.md",
-    "CHANGELOG.md",
-    "docs",
-    "examples"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EdenwareApps/jexidb.git"
+  },
+  "keywords": [
+    "couchdb",
+    "database",
+    "nosql",
+    "pouchdb",
+    "local-storage",
+    "db",
+    "persistent-storage",
+    "dexiejs",
+    "embedded-database",
+    "data-management",
+    "nedb",
+    "lowdb",
+    "dexie",
+    "offline-database",
+    "simple-database",
+    "fast-database",
+    "jexidb"
   ],
-  "dependencies": {
-  }
+  "bugs": {
+    "url": "https://github.com/EdenwareApps/jexidb/issues"
+  },
+  "homepage": "https://github.com/EdenwareApps/jexidb#readme"
 }

package/scripts/README.md

@@ -0,0 +1,47 @@
+# Scripts
+
+This directory contains utility scripts for the JexiDB project.
+
+## clean-test-files.js
+
+A Node.js script that automatically cleans up test files generated during test execution.
+
+### Usage
+
+```bash
+# Run manually
+node scripts/clean-test-files.js
+
+# Run via npm script
+npm run clean:test-files
+```
+
+### What it cleans
+
+The script removes files matching these patterns:
+- `test-db-*` (with or without extensions)
+- `test-db-*.jdb`
+- `test-db-*.idx.jdb` (contains both index and offsets data)
+- `test-normalize*` (with or without extensions)
+- `test-confusion*` (with or without extensions)
+- `debug-*` (with or without extensions)
+- `test-simple-*`
+- `test-count.jdb`
+
+### Integration with npm test
+
+The cleanup script is automatically executed after running tests:
+
+```bash
+npm test  # Runs jest && npm run clean:test-files
+```
+
+This ensures that test files are automatically cleaned up after each test run, keeping the project directory clean.
+
+### Features
+
+- **Pattern-based cleanup**: Uses regex patterns to identify test files
+- **Safe deletion**: Only deletes files, not directories
+- **Error handling**: Continues execution even if some files can't be deleted
+- **Verbose output**: Shows which files were cleaned
+- **Summary**: Reports total number of files cleaned

package/scripts/benchmark-array-serialization.js

@@ -0,0 +1,108 @@
+import { performance } from 'node:perf_hooks'
+import Serializer from '../src/Serializer.mjs'
+
+const ITERATIONS = parseInt(process.env.BENCH_ITERATIONS ?? '200', 10)
+const RECORDS_PER_ITERATION = parseInt(process.env.BENCH_RECORDS ?? '2000', 10)
+
+const serializer = new Serializer({
+  enableAdvancedSerialization: true,
+  enableArraySerialization: true,
+  debugMode: false
+})
+
+// Ensure schema is initialized to trigger array serialization path
+const schemaFields = ['id', 'name', 'value', 'tags', 'metadata', 'score', 'createdAt']
+serializer.schemaManager.initializeSchema(schemaFields)
+
+function createRecord(index) {
+  return {
+    id: `rec-${index}`,
+    name: `Record ${index}`,
+    value: index,
+    tags: [`tag-${index % 10}`, `tag-${(index + 3) % 10}`],
+    metadata: {
+      active: index % 2 === 0,
+      category: `category-${index % 5}`,
+      flags: [index % 7 === 0, index % 11 === 0]
+    },
+    score: Math.sin(index) * 100,
+    createdAt: new Date(1700000000000 + index * 60000).toISOString()
+  }
+}
+
+function prepareData() {
+  const raw = new Array(RECORDS_PER_ITERATION)
+  const arrayFormat = new Array(RECORDS_PER_ITERATION)
+  const normalized = new Array(RECORDS_PER_ITERATION)
+
+  for (let i = 0; i < RECORDS_PER_ITERATION; i++) {
+    const record = createRecord(i)
+    raw[i] = record
+    const arr = serializer.convertToArrayFormat(record)
+    arrayFormat[i] = arr
+    normalized[i] = serializer.deepNormalizeEncoding(arr)
+  }
+
+  return { raw, arrayFormat, normalized }
+}
+
+function benchFastPath(normalizedArrays) {
+  let totalLength = 0
+  for (let i = 0; i < normalizedArrays.length; i++) {
+    const json = serializer._stringifyNormalizedArray(normalizedArrays[i])
+    totalLength += json.length
+  }
+  return totalLength
+}
+
+function benchLegacyPath(normalizedArrays) {
+  let totalLength = 0
+  for (let i = 0; i < normalizedArrays.length; i++) {
+    const json = JSON.stringify(normalizedArrays[i])
+    totalLength += json.length
+  }
+  return totalLength
+}
+
+function runBenchmarks() {
+  const { normalized } = prepareData()
+
+  // Warm-up
+  benchFastPath(normalized)
+  benchLegacyPath(normalized)
+
+  let fastDuration = 0
+  let legacyDuration = 0
+  let fastTotal = 0
+  let legacyTotal = 0
+
+  for (let i = 0; i < ITERATIONS; i++) {
+    const startFast = performance.now()
+    fastTotal += benchFastPath(normalized)
+    fastDuration += performance.now() - startFast
+
+    const startLegacy = performance.now()
+    legacyTotal += benchLegacyPath(normalized)
+    legacyDuration += performance.now() - startLegacy
+  }
+
+  console.log(`Benchmark settings:`)
+  console.log(`  iterations: ${ITERATIONS}`)
+  console.log(`  records/iteration: ${RECORDS_PER_ITERATION}`)
+  console.log('')
+  console.log(`Fast path total time:   ${fastDuration.toFixed(2)} ms`)
+  console.log(`Legacy path total time: ${legacyDuration.toFixed(2)} ms`)
+  console.log('')
+  console.log(`Average fast path per iteration:   ${(fastDuration / ITERATIONS).toFixed(4)} ms`)
+  console.log(`Average legacy path per iteration: ${(legacyDuration / ITERATIONS).toFixed(4)} ms`)
+  console.log('')
+  console.log(`Output size parity check: fast=${fastTotal} legacy=${legacyTotal}`)
+}
+
+try {
+  runBenchmarks()
+} catch (error) {
+  console.error('Benchmark failed:', error)
+  process.exit(1)
+}
+

package/scripts/clean-test-files.js

@@ -0,0 +1,75 @@
+#!/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

@@ -0,0 +1,31 @@
+#!/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

@@ -0,0 +1,80 @@
+#!/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

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