beanbagdb 0.5.52 → 0.5.54

package/src/plugins/text_command.js

@@ -0,0 +1,193 @@
+
+
+
+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
+}
+
+export const text_command = {
+  parse,run,parse_and_run
+};

package/src/system_schema.js

@@ -19,7 +19,7 @@ export const schema_schema = {
       }, 
       name: {
         type: "string",
-        minLength: 5,
+        minLength: 4,
         maxLength: 50,
         pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
         description:"This is the name of the schema.It cannot be changed later"
@@ -74,16 +74,17 @@ export const schema_schema = {
             default: false,
             description:
               "If set, only a single records with this schema will be allowed to insert in the database",
-          },
+          }
         },
-        required :["primary_keys","non_editable_fields","single_record","encrypted_fields"]
+        required :["primary_keys","non_editable_fields","encrypted_fields"]
       },
     },
     required: ["name","description","schema", "settings"],
   },
   settings: {
-    primary_key: ["name"],
+    primary_keys: ["name"],
     editable_fields: ["schema", "settings","description"],
+    encrypted_fields:[]
   },
 };
 
@@ -160,6 +161,35 @@ export const system_schemas = {
       single_record:false
     },
   }
+  // ,
+  // edges:{
+  //   name:"edges",
+  //   description:"To relate one document to another.Labels can be configured using the db_network setting document.This stores edges of a simple directed graph",
+  //   schema:{
+  //     required:["graph","node1","node2","label"],
+  //     type:"object",
+  //     additionalProperties: false,
+  //     properties : {
+  //       graph:{
+  //         type:"string",
+  //         minLength:3,
+  //         default:"default",
+  //         maxLength:100,
+  //         description:"Name of the graph in which this edge is being added. This is managed by the db_network setting "
+  //       },
+  //       node1:{
+  //         type:"string",
+  //         description:"the source of this directed edge. this must be a valid document id."
+  //       }
+  //     }
+  //   },
+  //   settings :{
+  //     primary_key:["graph","node1","node2","label"],
+  //     non_editable_fields:["node1","node2","graph"],
+  //     encrypted_fields:[],
+  //     single_record:false
+  //   }
+  // }
 };
 
 // this is not stored in the DB. only for validating the metadata during doc update

package/test/couchdb.js

@@ -41,7 +41,7 @@ export class BeanBagDB_CouchDB extends BeanBagDB {
         }
       },
       utils:{
-        encrypt:  (text,encryptionKey)=>{
+        encrypt: async  (text,encryptionKey)=>{
           const key = crypto.scryptSync(encryptionKey, 'salt', 32); // Derive a 256-bit key
           const iv = crypto.randomBytes(16); // Initialization vector
           const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
@@ -49,7 +49,7 @@ export class BeanBagDB_CouchDB extends BeanBagDB {
           encrypted += cipher.final('hex');          
           return iv.toString('hex') + ':' + encrypted; // Prepend the IV for later use
         },
-        decrypt :  (encryptedText, encryptionKey)=>{
+        decrypt : async  (encryptedText, encryptionKey)=>{
           const key = crypto.scryptSync(encryptionKey, 'salt', 32); // Derive a 256-bit key
           const [iv, encrypted] = encryptedText.split(':').map(part => Buffer.from(part, 'hex'));
           const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);