beanbagdb 0.5.80 → 0.6.0

package/test/pouchdb.js

@@ -3,7 +3,7 @@ import Ajv  from 'ajv';
 import PouchDB from 'pouchdb';
 import pouchdbFind from 'pouchdb-find';
 PouchDB.plugin(pouchdbFind)
-import { scryptSync, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
+import crypto from 'crypto' 
 
 
 export const get_pdb_doc = (dbname,secret)=>{
@@ -42,28 +42,75 @@ const pdb = new PouchDB(dbname);
     },
     utils: {
       encrypt: async (text, encryptionKey) => {
-        //console.log(encryptionKey)
-        const key = scryptSync(encryptionKey, "salt", 32); // Derive a 256-bit key
-        const iv = randomBytes(16); // Initialization vector
-        const cipher = createCipheriv("aes-256-cbc", key, iv);
-        let encrypted = cipher.update(text, "utf8", "hex");
-        encrypted += cipher.final("hex");
-        //console.log("IV:", iv.toString("hex"));
-        //console.log("Encrypted:", encrypted);
-        return iv.toString("hex") + ":" + encrypted; // Prepend the IV for decryption
+        const encoder = new TextEncoder();
+        const data = encoder.encode(text); // Encode the text into bytes
+
+        // Ensure the encryption key is of valid length (16, 24, or 32 bytes for AES-GCM)
+        const keyBytes = encoder.encode(encryptionKey);
+        if (
+          keyBytes.length !== 16 &&
+          keyBytes.length !== 24 &&
+          keyBytes.length !== 32
+        ) {
+          throw new Error("Encryption key must be 16, 24, or 32 bytes long.");
+        }
+
+        // Convert encryptionKey to CryptoKey
+        const key = await crypto.subtle.importKey(
+          "raw",
+          keyBytes,
+          { name: "AES-GCM" },
+          false,
+          ["encrypt"]
+        );
+
+        // Create a random initialization vector (IV)
+        const iv = crypto.getRandomValues(new Uint8Array(12)); // 12 bytes for AES-GCM
+
+        // Encrypt the data
+        const encrypted = await crypto.subtle.encrypt(
+          { name: "AES-GCM", iv: iv },
+          key,
+          data
+        );
+
+        // Convert encrypted data and IV to base64 for storage
+        const encryptedArray = new Uint8Array(encrypted);
+        const encryptedText = btoa(String.fromCharCode(...encryptedArray));
+        const ivText = btoa(String.fromCharCode(...iv));
+
+        return ivText + ":" + encryptedText; // Store IV and encrypted text together
       },
-      decrypt: async  (encryptedText, encryptionKey) => {
-        //console.log(encryptedText, encryptionKey)
-        const key = scryptSync(encryptionKey, "salt", 32); // Derive a 256-bit key
-        const [ivHex, encryptedHex] = encryptedText.split(":");
-        const iv = Buffer.from(ivHex, "hex");
-        const encrypted = Buffer.from(encryptedHex, "hex");
-        //console.log("IV:", iv.toString("hex"));
-        //console.log("Encrypted:", encrypted.toString("hex"));
-        const decipher = createDecipheriv("aes-256-cbc", key, iv);
-        let decrypted = decipher.update(encrypted, "hex", "utf8");
-        decrypted += decipher.final("utf8");
-        return decrypted;
+      decrypt: async (encryptedText, encryptionKey) => {
+        const [ivText, encryptedData] = encryptedText.split(":");
+
+        // Convert IV and encrypted data from base64 to byte arrays
+        const iv = Uint8Array.from(atob(ivText), (c) => c.charCodeAt(0));
+        const encryptedArray = Uint8Array.from(atob(encryptedData), (c) =>
+          c.charCodeAt(0)
+        );
+
+        const encoder = new TextEncoder();
+
+        // Convert encryptionKey to CryptoKey
+        const key = await crypto.subtle.importKey(
+          "raw",
+          encoder.encode(encryptionKey),
+          { name: "AES-GCM" },
+          false,
+          ["decrypt"]
+        );
+
+        // Decrypt the data
+        const decrypted = await crypto.subtle.decrypt(
+          { name: "AES-GCM", iv: iv },
+          key,
+          encryptedArray
+        );
+
+        // Convert decrypted data back to a string
+        const decoder = new TextDecoder();
+        return decoder.decode(decrypted);
       },
       ping: () => {
         // @TODO ping the database to check connectivity when class is ready to use

package/src/plugins/text_command.js

@@ -1,191 +0,0 @@
-const commands = {
-  new: {
-    parse: async (instance,parts) => {
-      let criteria = {}
-      criteria.schema = parts.length==0?"":parts.join("")
-      return criteria
-    },
-    run: async (instance,command) => {
-      if (command.criteria.schema==""){
-        // return a list of all schemas present in the DB
-        let all_schema = await instance.get("schema_list")
-        return all_schema
-      }else{
-        // return the schema object for the given schema if not found throw error
-        let schema_obj = await instance.search({"selector":{"schema":"schema","data.name":command.criteria.schema}})
-        //console.log(schema_obj)
-        if(schema_obj.docs.length==0){
-          throw new Error("Schema with this name does not exists")
-        }
-        return schema_obj.docs[0]
-      }
-    },
-    help: `To create a new record. Format : new/"schema_name(optional)". If no schema name provided, a list of valid schema name is returned`
-  },
-  open:{
-    parse: async (instance,parts) => {
-      let criteria = {}
-      if (parts.length==0){
-        throw new Error("Invalid arguments.open command needs unique id")
-      }
-      let id_type = parts[0]
-      if(id_type=="id"){
-        parts.shift()
-        criteria["_id"] = parts.join("")
-      }else if(id_type=="link"){
-        parts.shift()
-        criteria["link"] = parts.join("")
-      }else if(id_type=="key"){
-        parts.shift()
-        let text= parts.join()
-        let p = text.split(",")
-
-        p.map(itm=>{
-          let p1 = itm.split("=")
-          if(p1[0]=="schema"){
-            criteria["schema"] = p1[1]
-          }else{
-            criteria["data"][p1[0]] = p1[1]
-          }
-        })
-
-        if(!criteria["schema"]){
-          throw new Error("Key requires a schema")
-        }
-      }else{
-        throw new Error("Invalid unique key")
-      }
-      return criteria
-    },
-    run: async (instance,command) => {
-      try {
-        let data = await instance.read(command.criteria,true)  
-        return data
-      } catch (error) {
-        throw error
-      }      
-    },
-    help: `To open a record using it's unique id. Format : open/"id||link|key"/"value". In case of key field name must be provided  as : field1=value1,fields2=value2...`
-  },
-  tool:{
-    parse : async (instance,parts)=>{
-      let criteria = {}
-      criteria.type = parts.length==0?"info":parts.join("")
-      return criteria
-    },
-    run : async (instance,command)=>{
-      let c_type = command.criteria.type
-      let data = {}
-      if (c_type=="info"){
-        // to get all basic info about the database
-        let data = {
-          meta: instance.metadata(),
-          schemas : {},
-          logs:[]
-        }
-        let schemas = await instance.get("schema_list") 
-        data.schemas = schemas
-        
-        let logs_doc = await instance.read({"schema":"system_settings","data":{name:"system_logs"}})
-        //console.log(logs_doc)
-        data =logs_doc.doc.data.value
-        return data
-
-      }else if(c_type=="plugins"){
-        // to show list of all plugins installed
-        // todo later not implemented yet 
-      }else if(c_type=="settings"){
-        // to show the list of all setting docs available 
-        let search = instance.search({"selector":{"schema":"system_settings"}})
-        return {docs:search.docs}
-      }
-      else if(c_type=="keys"){
-        // to show the list of all keys present in the db 
-        let search = instance.search({"selector":{"schema":"system_keys"}})
-        return {docs:search.docs}
-      }
-      else{
-        throw new Error("Invalid tool command")
-      }
-    },
-  }
-};
-
-const parse = async (instance, text) => {
-  let data = {
-    errors: [],
-    valid: false,
-    name: "",
-    criteria: {},
-  };
-  if (!text) {
-    data.errors.push(
-      "No text command provided. Format : command_name/parameter"
-    );
-  }
-  let parts = text.split("/");
-  if (parts.length == 0) {
-    data.errors.push("Invalid text command");
-  }
-  let command_name = parts[0];
-  if (!commands[command_name]) {
-    data.errors.push(
-      "Invalid command name. Valid : " + Object.keys(commands).join(",")
-    );
-  }
-  data.name = command_name;
-  try {
-    parts.shift();
-    let criteria = await commands[command_name].parse(instance,parts);
-    data.criteria = criteria;
-  } catch (error) {
-    data.errors.push(error.message);
-  }
-  if (data.errors.length == 0) {
-    data.valid = true;
-  }
-  return data;
-};
-
-const run = async (instance, command) => {
-  let data = {
-    result:{},
-    errors:[],
-    valid:false
-  };
-
-  if (!command) {
-    data.errors.push("No command object provided ");
-  }
-  if (!command.valid){
-    data.errors["Command cannot be run"]
-    
-  }
-  if(!commands[command.name]){
-    data.errors["Invalid command name"]
-  }
-
-  try {
-    let data1 = await commands[command.name].run(instance,command)
-    //console.log(data)
-    data.result = data1
-  } catch (error) {
-    data.errors.push(error.message)
-  }
-  if(data.errors.length==0){
-    data.valid = true
-  }
-  return data
-};
-
-const parse_and_run = async(instance, text) => {
-  let command = await parse(instance,text)
-  console.log(command)
-  let command_result = await run(instance,command)
-  return command_result
-}
-// const schemas =    []
-
-export const text_command = {
-  actions: {parse,run,parse_and_run}
-};

package/test/plugin.test.js

@@ -1,52 +0,0 @@
-// to test database operations. assuming the class is initialized successfully
-// to test initialization of the BeanBagDB class
-import { get_pdb_doc } from "./pouchdb.js";
-import assert, { throws, strictEqual, rejects } from "assert";
-import { BeanBagDB, DocCreationError, EncryptionError, ValidationError,DocNotFoundError, DocUpdateError } from "../src/index.js";
-
-import {text_command} from "../src/plugins/text_command.js"
-
-import * as chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-
-chai.use(chaiAsPromised);
-
-// Then either:
-const expect = chai.expect;
-
-let database; // this is the global db object
-
-
-describe("Testing plugin load", async () => {
-  
-  before(async () => {
-    let doc_obj = get_pdb_doc("test_database_30", "qwertyuiopaqwsde1254");
-    database = new BeanBagDB(doc_obj);
-    await database.ready(); // Ensure the database is ready before running tests
-    console.log("Ready for more tests...");
-  });
-
-  it('successfully loads the plugin', async () => {
-    try {
-      await database.load_plugin("txtcmd",text_command)
-      chai.expect(database.plugins).to.not.be.empty
-    } catch (error) {
-      console.log(error)
-      throw error
-    }
-  })
-
-  it('successfully runs the loaded the plugin method', async () => {
-    try {
-      //await database.load_plugin("txtcmd",text_command)
-      let command = await database.plugins["txtcmd"].parse("new/system_keys")
-      //console.log(command)
-      assert (command.valid ==true) 
-    } catch (error) {
-      console.log(error)
-      throw error
-    }
-  })
-});
-
-