jexidb 1.1.0 → 2.0.1

package/src/IndexManager.mjs

@@ -1,230 +0,0 @@
-export default class IndexManager {
-  constructor(opts) {
-    this.opts = Object.assign({}, opts)
-    this.index = Object.assign({data: {}}, this.opts.index)
-    Object.keys(this.opts.indexes).forEach(field => {
-      this.index.data[field] = {}
-    })    
-  }
-
-  add(row, lineNumber) {
-    if (typeof row !== 'object' || !row) {
-      throw new Error('Invalid \'row\' parameter, it must be an object')
-    }
-    if (typeof lineNumber !== 'number') {
-      throw new Error('Invalid line number')
-    }
-    for (const field in this.index.data) {
-      if (row[field]) {
-        const values = Array.isArray(row[field]) ? row[field] : [row[field]]
-        for (const value of values) {
-          if (!this.index.data[field][value]) {
-            this.index.data[field][value] = new Set()
-          }
-          if (!this.index.data[field][value].has(lineNumber)) {
-            this.index.data[field][value].add(lineNumber)
-          }
-        }
-      }
-    }
-  }
-
-  dryRemove(ln) { // remove line numbers from index without adjusting the rest
-    for (const field in this.index.data) {
-      for (const value in this.index.data[field]) {
-        if (this.index.data[field][value].has(ln)) {
-          this.index.data[field][value].delete(ln)
-        }
-        if (this.index.data[field][value].size === 0) {
-          delete this.index.data[field][value]
-        }
-      }
-    }
-  }
-
-  remove(lineNumbers) { // remove line numbers from index and adjust the rest
-    lineNumbers.sort((a, b) => a - b) // Sort ascending to make calculations easier
-    for (const field in this.index.data) {
-      for (const value in this.index.data[field]) {
-        const newSet = new Set()  
-        for (const ln of this.index.data[field][value]) {
-          let offset = 0
-          for (const lineNumber of lineNumbers) {
-            if (lineNumber < ln) {
-              offset++
-            } else if (lineNumber === ln) {
-              offset = -1 // Marca para remoção
-              break
-            }
-          }  
-          if (offset >= 0) {
-            newSet.add(ln - offset) // Atualiza o valor
-          }
-        }  
-        if (newSet.size > 0) {
-          this.index.data[field][value] = newSet
-        } else {
-          delete this.index.data[field][value]
-        }
-      }
-    }
-  } 
-
-  replace(map) {
-    for (const field in this.index.data) {
-      for (const value in this.index.data[field]) {
-        for(const lineNumber of this.index.data[field][value]) {
-          if (map.has(lineNumber)) {
-            this.index.data[field][value].delete(lineNumber)
-            this.index.data[field][value].add(map.get(lineNumber))
-          }
-        }
-      }
-    }
-  }
-
-  query(criteria, options = {}) {
-    if (typeof options === 'boolean') {
-      options = { matchAny: options };
-    }
-    const { matchAny = false, caseInsensitive = false } = options;
-    if (!criteria) throw new Error('No query criteria provided');
-    const fields = Object.keys(criteria);
-    if (!fields.length) throw new Error('No valid query criteria provided');
-    let matchingLines = matchAny ? new Set() : null;
-  
-    for (const field of fields) {
-      if (typeof this.index.data[field] === 'undefined') continue;
-      const criteriaValue = criteria[field];
-      let lineNumbersForField = new Set();
-      const isNumericField = this.opts.indexes[field] === 'number';
-  
-      if (typeof criteriaValue === 'object' && !Array.isArray(criteriaValue)) {
-        const fieldIndex = this.index.data[field];
-        for (const value in fieldIndex) {
-          let includeValue = true;
-          if (isNumericField) {
-            const numericValue = parseFloat(value);
-            if (!isNaN(numericValue)) {
-              if (criteriaValue['>'] !== undefined && numericValue <= criteriaValue['>']) {
-                includeValue = false;
-              }
-              if (criteriaValue['>='] !== undefined && numericValue < criteriaValue['>=']) {
-                includeValue = false;
-              }
-              if (criteriaValue['<'] !== undefined && numericValue >= criteriaValue['<']) {
-                includeValue = false;
-              }
-              if (criteriaValue['<='] !== undefined && numericValue > criteriaValue['<=']) {
-                includeValue = false;
-              }
-              if (criteriaValue['!='] !== undefined) {
-                const excludeValues = Array.isArray(criteriaValue['!='])
-                  ? criteriaValue['!=']
-                  : [criteriaValue['!=']];
-                if (excludeValues.includes(numericValue)) {
-                  includeValue = false;
-                }
-              }
-            }
-          } else {
-            if (criteriaValue['contains'] !== undefined && typeof value === 'string') {
-              const term = String(criteriaValue['contains']);
-              if (caseInsensitive) {
-                if (!value.toLowerCase().includes(term.toLowerCase())) {
-                  includeValue = false;
-                }
-              } else {
-                if (!value.includes(term)) {
-                  includeValue = false;
-                }
-              }
-            }
-            if (criteriaValue['regex'] !== undefined) {
-              let regex;
-              if (typeof criteriaValue['regex'] === 'string') {
-                regex = new RegExp(criteriaValue['regex'], caseInsensitive ? 'i' : '');
-              } else if (criteriaValue['regex'] instanceof RegExp) {
-                if (caseInsensitive && !criteriaValue['regex'].ignoreCase) {
-                  const flags = criteriaValue['regex'].flags.includes('i')
-                    ? criteriaValue['regex'].flags
-                    : criteriaValue['regex'].flags + 'i';
-                  regex = new RegExp(criteriaValue['regex'].source, flags);
-                } else {
-                  regex = criteriaValue['regex'];
-                }
-              }
-              if (regex && !regex.test(value)) {
-                includeValue = false;
-              }
-            }
-            if (criteriaValue['!='] !== undefined) {
-              const excludeValues = Array.isArray(criteriaValue['!='])
-                ? criteriaValue['!=']
-                : [criteriaValue['!=']];
-              if (excludeValues.includes(value)) {
-                includeValue = false;
-              }
-            }
-          }
-  
-          if (includeValue) {
-            for (const lineNumber of fieldIndex[value]) {
-              lineNumbersForField.add(lineNumber);
-            }
-          }
-        }
-      } else {
-        // Comparação simples de igualdade
-        const values = Array.isArray(criteriaValue) ? criteriaValue : [criteriaValue];
-        const fieldData = this.index.data[field];
-        for (const searchValue of values) {
-          for (const key in fieldData) {
-            let match = false;
-            if (isNumericField) {
-              // Converter ambas as partes para número
-              match = Number(key) === Number(searchValue);
-            } else {
-              match = caseInsensitive
-                ? key.toLowerCase() === String(searchValue).toLowerCase()
-                : key === searchValue;
-            }
-            if (match) {
-              for (const lineNumber of fieldData[key]) {
-                lineNumbersForField.add(lineNumber);
-              }
-            }
-          }
-        }
-      }
-  
-      // Consolida os resultados de cada campo
-      if (matchAny) {
-        matchingLines = new Set([...matchingLines, ...lineNumbersForField]);
-      } else {
-        if (matchingLines === null) {
-          matchingLines = lineNumbersForField;
-        } else {
-          matchingLines = new Set([...matchingLines].filter(n => lineNumbersForField.has(n)));
-        }
-        if (!matchingLines.size) {
-          return new Set();
-        }
-      }
-    }
-    return matchingLines || new Set();
-  } 
- 
-  load(index) {
-    for(const field in index.data) {
-      for(const term in index.data[field]) {
-        index.data[field][term] = new Set(index.data[field][term]) // set to array 
-      }
-    }
-    this.index = index
-  }
-  
-  readColumnIndex(column) {
-    return new Set((this.index.data && this.index.data[column]) ? Object.keys(this.index.data[column]) : [])
-  }
-}

package/src/Serializer.mjs

@@ -1,120 +0,0 @@
-import { EventEmitter } from 'events'
-import zlib from 'zlib'
-import v8 from 'v8'
-
-export default class Serializer extends EventEmitter {
-  constructor(opts = {}) {
-    super()
-    this.opts = Object.assign({}, opts)
-    this.brotliOptions = {
-      params: {
-        [zlib.constants.BROTLI_PARAM_QUALITY]: 4
-      }
-    }
-  }
-
-  async serialize(data, opts={}) {
-    let line
-    let header = 0x00 // 1 byte de header
-    const useV8 = (this.opts.v8 && opts.json !== true) || opts.v8 === true
-    const compress = (this.opts.compress && opts.compress !== false) || opts.compress === true
-    const addLinebreak = opts.linebreak !== false || (!useV8 && !compress && opts.linebreak !== false)
-    if (useV8) {
-      header |= 0x02 // set V8
-      line = v8.serialize(data)
-    } else {
-      const json = JSON.stringify(data)
-      line = Buffer.from(json, 'utf-8')
-    }
-    if (compress) {
-      let err
-      const compressionType = useV8 ? 'deflate' : 'brotli'
-      const buffer = await this.compress(line, compressionType).catch(e => err = e)
-      if(!err && buffer.length && buffer.length < line.length) {
-        header |= 0x01
-        line = buffer
-      }
-    }
-    const totalLength = 1 + line.length + (addLinebreak ? 1 : 0)
-    const result = Buffer.alloc(totalLength)
-    result[0] = header
-    line.copy(result, 1, 0, line.length)
-    if(addLinebreak) {
-      result[result.length - 1] = 0x0A
-    }
-    return result
-  }  
-
-  async deserialize(data) {
-    if(data.length === 0) {
-      return null
-    }
-    let line, isCompressed, isV8
-    const header = data.readUInt8(0)
-    const valid = header === 0x00 || header === 0x01 || header === 0x02 || header === 0x03
-    if(valid) {
-      isCompressed = (header & 0x01) === 0x01
-      isV8 = (header & 0x02) === 0x02
-      line = data.subarray(1) // remove byte header
-    } else {
-      isCompressed = isV8 = false
-      try {
-        return JSON.parse(data.toString('utf-8').trim())
-      } catch (e) {
-        throw new Error('Failed to deserialize JSON data')
-      }
-    }
-    if (isCompressed) {
-      const compressionType = isV8 ? 'deflate' : 'brotli'
-      line = await this.decompress(line, compressionType).catch(e => err = e)
-    }
-    if (isV8) {
-      try {
-        return v8.deserialize(line)
-      } catch (e) {
-        throw new Error('Failed to deserialize V8 data')
-      }
-    } else {
-      try {
-        return JSON.parse(line.toString('utf-8').trim())
-      } catch (e) {
-        throw new Error('Failed to deserialize JSON data')
-      }
-    }
-  }
-
-  compress(data, type) {
-    return new Promise((resolve, reject) => {
-      const callback = (err, buffer) => {
-        if (err) {
-          reject(err)
-        } else {
-          resolve(buffer)
-        }
-      }
-      if(type === 'brotli') {
-        zlib.brotliCompress(data, this.brotliOptions, callback)
-      } else {
-        zlib.deflate(data, callback)
-      }
-    })
-  }
-
-  decompress(data, type) {
-    return new Promise((resolve, reject) => {
-      const callback = (err, buffer) => {
-        if (err) {
-          reject(err)
-        } else {
-          resolve(buffer)
-        }
-      }
-      if(type === 'brotli') {
-        zlib.brotliDecompress(data, callback)
-      } else {
-        zlib.inflate(data, callback)
-      }
-    })
-  }
-  
-}

package/test/README.md

@@ -1,13 +0,0 @@
-## Test Results
-The following are the results of the automated tests conducted on my PC for different serialization formats and compression methods.
-
-| Format                         | Size (bytes) | Time elapsed (ms) |
-|-------------------------------|--------------|--------------------|
-| JSON                          | 1117         | 21                 |
-| V8 Serialization              | 1124         | 12 🏆       |
-| JSON with Brotli Compression   | 1038	🏆 | 20              |
-| V8 with Brotli Compression     | 1052         | 15                |
-
-When using V8 for serialization, be aware that serialized data may not deserialize correctly across different versions of V8 (which powers Chromium, Node.js, and Electron), leading to potential data loss or corruption. This issue is specific to V8 serialization; however, when using JSON, the data remains universal and compatible across environments.
-
-To avoid this issue, always use your V8 database with the same version of Node.js.

package/test/test.mjs

@@ -1,173 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { Database } from '../src/Database.mjs';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const benchmarks = {}
-
-// Array of objects containing the name and specific messages for each character
-const characters = [
-    {
-        name: 'Scorpion',
-        missingMessage: 'Did Scorpion pull a "GET OVER HERE" on the missing entries?',
-        updateMessage: 'Scorpion refuses to update. Maybe he’s stuck in the Netherrealm?',
-        deleteMessage: 'I thought Scorpion was gone, but he’s still here! Must be that "Hellfire Resurrection."',
-        signatureMove: 'Spear', powerType: 'Hellfire'
-    },
-    {
-        name: 'Scarlet',
-        missingMessage: 'Did Scarlet drain the life from the missing entries with her blood magic?',
-        updateMessage: 'Scarlet refuses to update. Maybe her blood magic is causing interference?',
-        deleteMessage: 'I thought Scarlet was gone, but she’s still here! Must be that blood regeneration ability.',
-        signatureMove: 'Blood Tentacle', powerType: 'Blood Manipulation'
-    },
-    {
-        name: 'Frost',
-        missingMessage: 'Did Frost freeze the missing entries?',
-        updateMessage: 'Frost refuses to update. Maybe she’s stuck in an ice block?',
-        deleteMessage: 'I thought Frost was gone, but she’s still here! Must be that "Ice Shield."',
-        signatureMove: 'Ice Daggers', 
-        powerType: 'Cryomancy'
-    },
-    {
-        name: 'Frost',
-        missingMessage: 'Did Frost freeze the missing entries?',
-        updateMessage: 'Frost refuses to update. Maybe she’s stuck in an ice block?',
-        deleteMessage: 'I thought Frost was gone, but she’s still here! Must be that "Ice Shield."',
-        signatureMove: 'Ice Daggers', 
-        powerType: 'Cryomancy'
-    }    
-];
-
-// Function to run the tests
-const runTests = async (id, name, format, opts) => {
-
-    // Define the character for this battle based on the battle ID
-    const character = characters[(id - 1) % characters.length];
-
-    // Path to the test file
-    const testFilePath = path.join(__dirname, 'test-' + name + '.jdb');
-    
-    console.log('Battle #' + id + ' (' + format + ') is starting...\n');
-    fs.writeFileSync(testFilePath, '', { encoding: null }); // Clear the file before starting the tests
-    const start = Date.now()
-    const db = new Database(testFilePath, opts); // Instantiate the database
-
-    // 1. Test if the instance was created correctly
-    await db.init(); // Call init() right after the instance is created
-    console.assert(db.initialized === true, `Test failed: Database didn't initialize. Looks like Raiden needs to give it a shock!`);
-
-    // 2. Test data insertion with Mortal Kombat characters
-    await db.insert({ id: 1, name: character.name, signatureMove: character.signatureMove, powerType: character.powerType });
-    await db.insert({ id: 2, name: 'Sub-Zero', signatureMove: 'Ice Ball', powerType: 'Cryomancy' });
-    await db.insert({ id: 3, name: 'Raiden', signatureMove: 'Electric Fly', powerType: 'Lightning' });
-    await db.insert({ id: 4, name: 'Jax', signatureMove: 'Ground Pound', powerType: 'Strength' });
-    await db.insert({ id: 5, name: 'Sindel', signatureMove: 'Sonic Scream', powerType: 'Sound' });
-    await db.insert({ id: 6, name: 'Ermac', signatureMove: 'Telekinesis', powerType: 'Telekinesis' });
-    await db.insert({ id: 7, name: 'Mileena', signatureMove: 'Sai Throw', powerType: 'Teleportation' });
-    await db.insert({ id: 8, name: 'Kenshi', signatureMove: 'Telekinetic Slash', powerType: 'Telekinesis' });
-    await db.insert({ id: 9, name: 'D\'Vorah', signatureMove: 'Swarm', powerType: 'Insects' });
-    await db.insert({ id: 10, name: 'Sonya Blade', signatureMove: 'Energy Rings', powerType: 'Special Forces Technology' });
-    await db.insert({ id: 11, name: 'Kotal Kahn', signatureMove: 'Sunstone', powerType: 'Osh-Tekk Strength' });   
-
-    // "Flawless Victory" if the insertion is successful
-    console.log('Round 1 - CREATE: Flawless Victory! All characters inserted successfully.');
-
-    // 3. Test if the data was inserted correctly
-    let results = await db.query({ id: { '<=': 5 } });
-    const pass1 = results.length === 5;
-    const pass2 = results[0].name === character.name;
-    console.assert(pass1, `Round 2 - READ: Test failed: Where is everyone? ${character.missingMessage}`);
-    console.assert(pass2, `Round 2 - READ: Test failed: ${character.name} seems to have been teleported out of the database!`);
-    if(pass1 && pass2) console.log(`Round 2 - READ: Flawless Victory! All characters inserted successfully, led by ${character.name}.`);
-
-    // 4. Test indexes
-    const pass3 = await db.indexManager.readColumnIndex('name').has(character.name)
-    console.assert(pass3, `Round 3 - INDEX: Test failed: ${character.name} is not in the index.`);
-    if(pass3) console.log(`Round 3 - INDEX: Flawless Victory! ${character.name} is in the index.`);
-
-    // 5. Test data update
-    await db.update({ id: 1 }, { name: character.name + ' Updated' });
-    results = await db.query({ id: 1 });
-    const pass4 = results.length === 1 && results[0].name === character.name + ' Updated';
-    console.assert(pass4, `Round 3 - UPDATE: Test failed: ${character.updateMessage}`);
-    if(pass4) console.log(`Round 3 - UPDATE: Flawless Victory! ${character.name} has been updated successfully.`);
-
-    // 6. Test data deletion
-    await db.delete({ name: character.name + ' Updated' });
-    results = await db.query({ id: { '<=': 2 } });
-    const pass5 = results.length === 1;
-    const pass6 = results[0].name === 'Sub-Zero';
-    console.assert(pass5, `Round 4 - DELETE: Test failed: ${character.deleteMessage}`);
-    console.assert(pass6, `Round 4 - DELETE: Test failed: Sub-Zero is nowhere to be seen. Did he freeze the system?`);
-    if(pass5 && pass6) console.log(`Round 4 - DELETE: Flawless Victory! ${character.name} has been eliminated successfully.`);
-
-    // End the battle and log the result
-    if(pass1 && pass2 && pass4 && pass5 && pass6) {
-        let err, elapsed = Date.now() - start;
-        const { size } = await fs.promises.stat(testFilePath);
-        if(!benchmarks[format]) {
-            benchmarks[format] = { elapsed, size }
-        } else {
-            benchmarks[format].elapsed = (elapsed + benchmarks[format].elapsed)
-            benchmarks[format].size = (size + benchmarks[format].size)
-        }
-        console.log(`\nBattle #${id} ended: All tests with format "${format}" ran successfully! Fatality avoided this time.\n\n`);
-        global.gc()
-    } else {
-        benchmarks[format] = { elapsed: 'Error', size: 'Error' };
-        global.gc();
-        throw `\nBattle #${id} ended: Some tests failed with format "${format}"! Time to train harder.\n\n`;
-    }
-}
-
-async function runAllTests() {
-    const depth = 10
-    let err, i = 1
-    let tests = [
-        ['json', 'JSON', { indexes: { id: 'number', name: 'string' }, v8: false, compress: false, compressIndex: false }],
-        ['v8', 'V8 serialization', { indexes: { id: 'number', name: 'string' }, v8: true, compress: false, compressIndex: false }],
-        ['json-compressed', 'JSON with Brotli compression', { indexes: { id: 'number', name: 'string' }, v8: false, compress: false, compressIndex: true }],
-        ['v8-compressed', 'V8 with Deflate compression', { indexes: { id: 'number', name: 'string' }, v8: true, compress: false, compressIndex: true }]
-    ]
-    tests = Array(depth).fill(tests).flat()
-    tests = tests.map(value => ({ value, sort: Math.random() })).sort((a, b) => a.sort - b.sort).map(({ value }) => value)
-    for(const test of tests) {
-        await runTests(i++, test[0], test[1], test[2]).catch(e => {
-            benchmarks[test[1]] = { elapsed: 'Error', size: 'Error' };
-            console.error(e)
-            err = e
-        })
-    }
-    const winners = {}
-    for (const [format, result] of Object.entries(benchmarks)) {
-        if (result.elapsed !== 'Error' && result.size !== 'Error') {
-            if (typeof(winners.elapsed) === 'undefined' || result.elapsed < winners.elapsed) {
-                winners.elapsed = result.elapsed
-                winners.format = format
-            }
-            if (typeof(winners.size) === 'undefined' || result.size < winners.size) {
-                winners.size = result.size
-                winners.format = format
-            }
-        }
-    }
-    for(const format in benchmarks) {
-        for(const prop of ['elapsed', 'size']) {
-            if(benchmarks[format][prop] === winners[prop]) {
-                benchmarks[format][prop] += ' \uD83C\uDFC6'
-            }
-        }
-    }
-    console.log('Benchmarks results after '+ tests.length +' battles:')
-    console.table(benchmarks)
-    // setInterval(() => {}, 1000)
-    // global.Database = Database
-    // global.__dirname = __dirname
-    process.exit(err ? 1 : 0)
-}
-
-// Run the tests
-runAllTests().catch(error => console.error('Error during tests:', error));