jexidb 1.0.2

package/src/IndexManager.mjs

@@ -0,0 +1,186 @@
+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, matchAny=false) {
+    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') {
+              if (!value.includes(criteriaValue['contains'])) {
+                includeValue = false;
+              }
+            }
+            if (criteriaValue['regex'] !== undefined && typeof value === 'string') {
+              const regex = new RegExp(criteriaValue['regex']);
+              if (!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 {
+        const values = Array.isArray(criteriaValue) ? criteriaValue : [criteriaValue];
+        for (const value of values) {
+          if (this.index.data[field][value]) {
+            for (const lineNumber of this.index.data[field][value]) {
+              lineNumbersForField.add(lineNumber);
+            }
+          }
+        }
+      }
+      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/serializers/Advanced.mjs

@@ -0,0 +1,120 @@
+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.linebreak = Buffer.from([0x0A])
+    this.delimiter = Buffer.from([0xFF, 0xFF, 0xFF, 0xFF])
+    this.defaultBuffer = Buffer.alloc(4096)
+    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.v8 === true
+    const compress = this.opts.compress || opts.compress === true
+    if (useV8) {
+      header |= 0x02 // set V8
+      line = v8.serialize(data)
+    } else {
+      if(compress) {
+        line = Buffer.from(JSON.stringify(data), 'utf-8')
+      } else {
+        return Buffer.from(JSON.stringify(data) + (opts.linebreak !== false ? '\n' : ''), 'utf-8')
+      }
+    }
+    if (compress) {
+      let err
+      const buffer = await this.compress(line).catch(e => err = e)
+      if(!err) {
+        header |= 0x01
+        line = buffer
+      }
+    }
+    const totalLength = 1 + line.length + (opts.linebreak !== false ? 1 : 0)
+    const result = Buffer.alloc(totalLength)
+    result[0] = header
+    line.copy(result, 1)
+    if (opts.linebreak !== false) {
+      result[totalLength - 1] = 0x0A
+    }
+    return result
+  }  
+
+  async deserialize(data, opts={}) {
+    let line
+    const header = data.readUInt8(0)
+    const valid = header === 0x00 || header === 0x01 || header === 0x02 || header === 0x03
+    let isCompressed, isV8, decompresssed
+    if(valid) {
+      isCompressed = (header & 0x01) === 0x01
+      isV8 = (header & 0x02) === 0x02
+      line = data.subarray(1) // remove byte header
+    } else {
+      isCompressed = isV8 = false
+      line = data
+    }
+    if (isCompressed) {
+      let err
+      const buffer = await this.decompress(line).catch(e => err = e)
+      if(!err) {
+        decompresssed = true
+        line = buffer
+      }
+    }
+    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) {
+        console.error('Failed to deserialize', header, line.toString('utf-8').trim())
+        throw new Error('Failed to deserialize JSON data')
+      }
+    }
+  }
+
+  compress(data) {
+    return new Promise((resolve, reject) => {
+      zlib.brotliCompress(data, this.brotliOptions, (err, buffer) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(buffer)
+        }
+      })
+    })
+  }
+
+  decompress(data) {
+    return new Promise((resolve, reject) => {
+      zlib.brotliDecompress(data, (err, buffer) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(buffer)
+        }
+      })
+    })
+  }
+
+  async safeDeserialize(json) {
+    try {
+      return await this.deserialize(json)
+    } catch (e) {
+      return null
+    }
+  }
+}

package/src/serializers/Simple.mjs

@@ -0,0 +1,21 @@
+export default class Serializer {
+
+  constructor(opts={}) {
+    this.opts = Object.assign({}, opts)
+  }
+
+  async serialize(data, opts={}) {
+    return Buffer.from(JSON.stringify(data) + (opts.linebreak !== false ? '\n' : ''), 'utf-8')
+  }  
+
+  async deserialize(data, opts={}) {
+    const line = data.toString('utf-8')
+    try {
+      return JSON.parse(line)
+    } catch (e) {
+      console.error('Failed to deserialize', line)
+      throw new Error('Failed to deserialize JSON data')
+    }
+  }
+  
+}

package/test/test-json.jdb

@@ -0,0 +1,12 @@
+{"id":2,"name":"Sub-Zero","signatureMove":"Ice Ball","powerType":"Cryomancy"}
+{"id":3,"name":"Raiden","signatureMove":"Electric Fly","powerType":"Lightning"}
+{"id":4,"name":"Jax","signatureMove":"Ground Pound","powerType":"Strength"}
+{"id":5,"name":"Sindel","signatureMove":"Sonic Scream","powerType":"Sound"}
+{"id":6,"name":"Ermac","signatureMove":"Telekinesis","powerType":"Telekinesis"}
+{"id":7,"name":"Mileena","signatureMove":"Sai Throw","powerType":"Teleportation"}
+{"id":8,"name":"Kenshi","signatureMove":"Telekinetic Slash","powerType":"Telekinesis"}
+{"id":9,"name":"D'Vorah","signatureMove":"Swarm","powerType":"Insects"}
+{"id":10,"name":"Sonya Blade","signatureMove":"Energy Rings","powerType":"Special Forces Technology"}
+{"id":11,"name":"Kotal Kahn","signatureMove":"Sunstone","powerType":"Osh-Tekk Strength"}
+{"data":{"id":{"2":[0],"3":[1],"4":[2],"5":[3],"6":[4],"7":[5],"8":[6],"9":[7],"10":[8],"11":[9]},"name":{"Sub-Zero":[0],"Raiden":[1],"Jax":[2],"Sindel":[3],"Ermac":[4],"Mileena":[5],"Kenshi":[6],"D'Vorah":[7],"Sonya Blade":[8],"Kotal Kahn":[9]}}}
+[0,78,158,234,310,390,472,559,631,733,822,1070]

package/test/test.mjs

@@ -0,0 +1,152 @@
+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');
+    
+    // Function to clear the test file before each run
+    const clearTestFile = () => {
+        fs.writeFileSync(testFilePath, '', { encoding: null });
+    }
+
+    console.log('Battle #' + id + ' (' + format + ') is starting...\n');
+    clearTestFile(); // 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 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.`);
+
+    // 5. 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;
+        elapsed = elapsed < 1000 ? elapsed + 'ms' : (elapsed / 1000).toFixed(3) + 's';
+        const { size } = await fs.promises.stat(testFilePath);
+        benchmarks[format] = { elapsed, size };
+        console.log(`\nBattle #${id} ended: All tests with format "${format}" ran successfully! Fatality avoided this time.\n\n`);
+    } else {
+        benchmarks[format] = { elapsed: 'Error', size: 'Error' };
+        throw `\nBattle #${id} ended: Some tests failed with format "${format}"! Time to train harder.\n\n`;
+    }
+}
+
+async function runAllTests() {
+    let err
+    await runTests(1, 'json', 'JSON', {
+        indexes: {id: 'number', name: 'string'},
+        v8: false,
+        compress: false,
+        compressIndex: false
+    }).catch(e => err = e)
+    await runTests(2, 'v8', 'V8 serialization', {
+        indexes: {id: 'number', name: 'string'},
+        v8: true,
+        compress: false,
+        compressIndex: false
+    }).catch(e => err = e)
+    await runTests(3, 'json-compressed', 'JSON with Brotli compression', {
+        indexes: {id: 'number', name: 'string'},
+        v8: false,
+        compress: false,
+        compressIndex: true
+    }).catch(e => err = e)
+    await runTests(3, 'v8-compressed', 'V8 with Brotli compression', {
+        indexes: {id: 'number', name: 'string'},
+        v8: true,
+        compress: false,
+        compressIndex: true
+    }).catch(e => err = e)
+    console.table(benchmarks)
+    process.exit(err ? 1 : 0)
+}
+
+// Run the tests
+runAllTests().catch(error => console.error('Error during tests:', error));