beanbagdb 0.5.50 → 0.5.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beanbagdb",
-  "version": "0.5.50",
+  "version": "0.5.51",
   "description": "A JS library to introduce a schema layer to a No-SQL local database",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -34,5 +34,8 @@
     "nano": "^10.1.4",
     "pouchdb": "^9.0.0",
     "pouchdb-find": "^9.0.0"
+  },
+  "mocha": {
+    "spec": "test/**/*.test.js"
   }
 }

package/src/index.js

@@ -1,11 +1,14 @@
 import * as sys_sch from "./system_schema.js";
-// import { version } from "../package.json" assert {type :"json"};
 /**
  * This the core class. it is not very useful in itself but can be used to generate a sub class for a specific database for eg CouchDB.
  * It takes a db_instance argument, which , this class relies on perform  CRUD operations on the data.
  * Why have a "dumb" class ? : So that the core functionalities remains in a single place and the multiple Databases can be supported.
+ * Naming convention :  
+ * - user facing methods : verbs with underscores, no camel case 
+ * - internal methods (uses the this object) only to be used within the class : name starts with underscore (_)
+ * - util methods : these can also be used by the user,  this object not accessed, : name starts with util_
  */
-class BeanBagDB {
+export class BeanBagDB {
   /**
    * @param {object} db_instance - Database object
    * db_instance object contains 3 main keys :
@@ -16,117 +19,196 @@ class BeanBagDB {
    */
   constructor(db_instance) {
     // data validation checks
-    this._check_required_fields(["name", "encryption_key", "api", "utils"],db_instance)
-    this._check_required_fields(["insert", "update", "delete", "search","get","createIndex"],db_instance.api)
-    this._check_required_fields(["encrypt", "decrypt","ping","validate_schema"],db_instance.utils)
+    this.util_check_required_fields(["name", "encryption_key", "api", "utils","db_name"],db_instance)
+    this.util_check_required_fields(["insert", "update", "delete", "search","get","createIndex"],db_instance.api)
+    this.util_check_required_fields(["encrypt", "decrypt","ping","validate_schema"],db_instance.utils)
 
-    if(db_instance.encryption_key.length>20){throw new Error("encryption_key must have at least 20 letters")}
+    if(db_instance.encryption_key.length<20){throw new Error("encryption_key must have at least 20 letters")}
     // db name should not be blank, 
 
-    this.name = db_instance.name;
     this.encryption_key = db_instance.encryption_key;
-
+    this.db_name = db_instance.db_name // couchdb,pouchdb etc...
     this.db_api = db_instance.api;
     this.utils = db_instance.utils;
 
-    this._version = "0.5.0"
-    this.ready_check = { initialized: false, latest: false };
-    console.log("Run ready() now");
+    this.meta = {
+      database_name : db_instance.name,
+      backend_database : this.db_name,
+      beanbagdb_version_db : null
+    }
+    
+    this._version = this._get_current_version()
+    // latest indicated if the DB was initialized with the latest version or not. 
+    this.active =  false 
 
+    console.log("Run ready() now");
+    
     this.plugins = {}
+    
+    this.error_codes = {
+      not_active : "Database is not ready. Run ready() first",
+      schema_not_found:"Schema not found"
+    } 
+  }
+
+  async metadata(){
+    // returns system data 
+    return {
+      ... this.meta,
+      beanbagdb_version_code : this._version,
+      ready_to_use : this.active 
+    }
+    // todo : doc count, schema count, records for each schema, size of the database, 
   }
 
   /**
    * This is to check if the database is ready to be used. It it important to run this after the class is initialized.
    */
   async ready() {
-    console.log("Checking...");
-    // @TODO : ping the database
-    // this._version = await getPackageVersion()
-    this.ready_check = await this._check_ready_to_use();
-    if (this.ready_check.initialized) {
-      console.log("Ready to use!");
+    // TODO Ping db
+    let check = { initialized: false, latest: false ,db_version:null};
+    let version_search = await this.db_api.search({
+      selector: { schema: "system_settings", "data.name": "beanbagdb_version" },
+    });
+    if (version_search.docs.length > 0) {
+      let doc = version_search.docs[0];
+      this.active  = doc["data"]["value"] == this._version;
+      this.meta.beanbagdb_version_db = doc["data"]["value"]
+    }
+    if(this.active){
+      console.log("Ready")
+    }else{
+      await this.initialize_db()
     }
   }
 
-  check_if_ready(){
-    return this.ready_check.ready 
-  }
+
 
   /**
    * Initializes the database making it ready to be used. Typically, required to run after every time package is updated to a new version.
    * See the documentation on the architecture of the DB to understand what default schemas are required for a smooth functioning of the database
    */
   async initialize_db() {
+    // this works on its own but is usually called by ready automatically if required 
+
+    // check for schema_scehma : if yes, check if latest and upgrade if required, if no create a new schema doc
+    let logs = ["init started"]
     try {
-      if (this.ready_check.initialized == false) {
-        // add the   meta-schemas doc
+      let schema = await  this.get_schema_doc("schema")
+      if (schema["data"]["version"] != sys_sch.schema_schema.version){
+        logs.push("old schema_schema v "+schema["data"]["version"])
+        let full_doc  = await this.db_api.get(schema["_id"])
+        full_doc["data"] =  {...sys_sch.schema_schema}
+        full_doc["meta"]["updated_on"] = this._get_now_unix_timestamp()
+        await this.db_api.update(full_doc)
+        logs.push("new schema_schema v "+sys_sch.schema_schema.version)
+      }
+
+    } catch (error) {
+     console.log(error)
+     if (error.message==this.error_codes.schema_not_found) {
+      console.log("...adding new ")
+        // inserting new schema_schema doc
         let schema_schema_doc = this._get_blank_doc("schema");
         schema_schema_doc.data = sys_sch.schema_schema;
         await this.db_api.insert(schema_schema_doc);
-        // add system schemas
-        let keys = Object.keys(sys_sch.system_schemas);
-        for (let index = 0; index < keys.length; index++) {
-          const element = sys_sch.system_schemas[keys[index]];
-          let schema_record = this._get_blank_schema_doc(
-            "schema",
-            sys_sch.schema_schema["schema"],
-            element
-          );
-          await this.db_api.insert(schema_record);
+        logs.push("init schema_schema v "+sys_sch.schema_schema.version)
+     }
+    }
+
+    let keys = Object.keys(sys_sch.system_schemas);
+    for (let index = 0; index < keys.length; index++) {
+      const schema_name = sys_sch.system_schemas[keys[index]]["name"] 
+      const schema_data = sys_sch.system_schemas[keys[index]];
+      try {
+        // console.log(schema_name)
+        let schema1 = await  this.get_schema_doc(schema_name)
+        if (schema1["data"]["version"] != schema_data.version){
+          logs.push("old "+schema_name+" v "+schema1["data"]["version"])
+          let full_doc  = await this.db_api.get(schema1["_id"])
+          full_doc["data"] =  {...schema_data}
+          full_doc["meta"]["updated_on"] = this._get_now_unix_timestamp()
+          await this.db_api.update(full_doc)
+          logs.push("new "+schema_name+" v "+schema_data.version)
         }
-        // create an index
-        await this.db_api.createIndex({
-          index: { fields: ["schema", "data", "meta"] },
-        });
-        console.log("Database Indexed.");
-        // create the log doc
-        const log_schema = sys_sch.system_schemas["logs"]["schema"];
-        let log_doc = this._get_blank_schema_doc("system_logs", log_schema, {
-          logs: [
-            {
-              message: `Database is initialized with version ${this._version}.`,
-              on: this._get_now_unix_timestamp(),
-              human_date: new Date().toLocaleString(),
-            },
-          ],
-        });
-        await this.db_api.insert(log_doc);
-        // create the setting doc
-        const setting_schema = sys_sch.system_schemas["settings"]["schema"];
-        let setting_doc = this._get_blank_schema_doc(
-          "system_settings",
-          setting_schema,
-          {
-            name: "beanbagdb_version",
-            value: this._version,
-            user_editable: false,
+      } catch (error) {
+        console.log(error)
+        if (error.message==this.error_codes.schema_not_found) {
+          // inserting new schema doc
+          let new_schema_doc = this._get_blank_schema_doc("schema",sys_sch.schema_schema["schema"],schema_data);
+          await this.db_api.insert(new_schema_doc);
+          logs.push("init "+schema_name+" v "+schema_data.version)
+        }
+      }
+    }
+    // store the logs in the log_doc ,  generate it for the first time 
+    // console.log(logs)
+    if(logs.length>1){
+      // version needs to be updated in the object as well as settings and must be logged
+      logs.push("Init done")
+      
+      await this.insert_or_update_setting("system_logs",{value:{text:logs.join(","),added:this._get_now_unix_timestamp()},"on_update_array":"append"})
+      await this.insert_or_update_setting("beanbagdb_version",{value:this._version})
+      // await this.insert_or_update_setting("system_logs",{value:{text:"This is just a test.",added:this._get_now_unix_timestamp()}})
+
+      this.meta.beanbagdb_version_db = this._version
+      this.active = true
+    }else{
+      // no new updates were done 
+      console.log("already updated. nothing is required to be done. continue")
+    }
+  }
+  async insert_or_update_setting(name,new_data,schema={}){
+    // TODO implement schema check
+    if(!new_data){throw new Error("No data provided")}
+    if(!new_data.value){throw new Error("No value provided")}
+
+    let doc_search = await this.db_api.search({"selector":{"schema":"system_settings","data.name":name}})
+    if(doc_search.docs.length>0){
+      // doc already exists, check schema and update it : if it exists then it's value already exists and can be 
+      let doc = {...doc_search.docs[0]}
+      if(Array.isArray(doc.data.value)){
+          let append_type = doc.data.on_update_array
+          if(append_type=="append"){
+            doc["data"]["value"].push(new_data.value)
+          }else if(append_type=="update"){
+            doc["data"]["value"] = new_data.value
+          }else{
+            throw new Error("Invalid on update array value")
           }
-        );
-        await this.db_api.insert(setting_doc);
-        // finally update the flags
-        this.ready_check.initialized = true;
-        this.ready_check.latest = true;
-        console.log("Database initialized");
-      } else {
-        console.log("Database already initialized");
-        if (!this.ready_check.latest) {
-          // update to latest schema
-          this._update_system_schema();
-        } else {
-          console.log("Database already up to date");
+        }else{
+          doc["data"]["value"]  = new_data.value
         }
+        // finally update it 
+        doc["meta"]["updated_on"] = this._get_now_unix_timestamp()
+        await this.db_api.update(doc)
+        return doc
+      
+    }else{
+      // doc does not exists, generate a new one 
+      let new_val= {value:new_data.value}
+
+      if (new_data.on_update_array){
+        // this indicates the provided value is initial value inside the array
+        new_val.value = [new_data.value]
+        new_val.on_update_array = new_data.on_update_array
       }
-    } catch (error) {
-      console.log(error);
-      throw error;
+      let new_doc = this._get_blank_doc("system_settings")
+      new_doc["data"] = {
+        "name": name,
+        ...new_val
+      }
+      let d = await this.db_api.insert(new_doc)
+      return d
     }
   }
 
+
   /**
    * Adds indexes for all the schemas in the data base. This is important to make search faster. This must be done every time a new schema is introduced in the database
    */
   async update_indexes() {
+    this._check_ready_to_use()
     // @TODO check this. i don't the index created this way are actually useful in search.
     let all_schemas_docs = await this.db_api.search({
       selector: { schema: "schema" },
@@ -153,41 +235,74 @@ class BeanBagDB {
     //const validate = ajv.compile(schema_obj);
     //const valid = validate(data_obj);
     if (!valid) {
-      console.log(validate.errors);
-      throw new Error(validate.errors);
+      throw new ValidationError(validate.errors);
     }
   }
 
   validate_schema_object(schema_doc){
-    let errors = []
+    let errors = [{"message":"Schema validation errors "}]
     if(!schema_doc["schema"]["type"]){
-      errors.push("Schema must have the field schema.'type' which can only be 'object' ")
+      errors.push({message:"Schema must have the field schema.'type' which can only be 'object' "})
     }else{
       if(schema_doc["schema"]["type"]!="object"){
-        errors.push("The schema.'type' value  is invalid.Only 'object' allowed")
+        errors.push({message:"The schema.'type' value  is invalid.Only 'object' allowed"})
       }
     }
     if(!schema_doc["schema"]["properties"]){
-      errors.push("The schema.'properties' object does not exists")
+      errors.push({message:"The schema.'properties' object does not exists"})
     }else{
       if(typeof(schema_doc["schema"]["properties"])!="object"){
-        errors.push("Invalid schema.properties. It must be an object and must have atleast one field inside.")
+        errors.push({message:"Invalid schema.properties. It must be an object and must have atleast one field inside."})
       }
       if(Object.keys(schema_doc["schema"]["properties"]).length==0){
-        errors.push("You must define at least one property")
+        errors.push({message:"You must define at least one property"})
       }
     }
 
     if(!schema_doc["schema"]["additionalProperties"]){
-      errors.push("The schema.'additionalProperties' field is required")
+      errors.push({message:"The schema.'additionalProperties' field is required"})
     }else{
       if(typeof(schema_doc["schema"]["additionalProperties"])!="boolean"){
-        errors.push("Invalid schema.additionalProperties. It must be a boolean value")
+        errors.push({message:"Invalid schema.additionalProperties. It must be a boolean value"})
+      }
+    }
+
+    const allKeys = Object.keys(schema_doc["schema"]["properties"])
+    if(schema_doc["settings"]["primary_keys"].length>0){
+      // check if all keys belong to the schema and are not of type object
+      let all_pk_exist = schema_doc["settings"]["primary_keys"].every(item=>allKeys.includes(item)&&schema_doc["schema"]["properties"][item]["type"]!="object"&&schema_doc["schema"]["properties"][item]["type"]!="array")
+      
+      if(!all_pk_exist){
+        errors.push({message:"Primary keys invalid. All keys must be defined in the schema and must be non object"})
+      }
+    }
+
+
+    if(schema_doc["settings"]["non_editable_fields"].length>0){
+      // check if all keys belong to the schema
+      let all_ne_exist = schema_doc["settings"]["non_editable_fields"].every(item=>allKeys.includes(item))
+      if(!all_ne_exist){
+        errors.push({message:"Non editable fields invalid. All fields must be defined in the schema "})
       }
     }
 
-    if(errors.length>0){
-      throw new Error("Schema validation errors- "+errors.join(","))
+    if(schema_doc["settings"]["encrypted_fields"].length>0){
+      // check if all keys belong to the schema and are only string
+      let all_enc_exist = schema_doc["settings"]["encrypted_fields"].every(item=>allKeys.includes(item)&&schema_doc["schema"]["properties"][item]["type"]=="string")
+      if(!all_enc_exist){
+        errors.push({message:"Invalid encrypted fields. All fields must be defined in the schema and must be string "})
+      }
+
+      // check : primary keys cannot be encrypted
+      let all_enc_no_pk = schema_doc["settings"]["encrypted_fields"].every(item=>!schema_doc["settings"]["primary_keys"].includes(item))
+      if(!all_enc_no_pk){
+        errors.push({message:"Invalid encrypted fields.Primary key fields cannot be encrypted "})
+      }
+    }
+  
+    /// cannot encrypt primary field keys 
+    if(errors.length>1){
+      throw new ValidationError(errors)
     }
   }
 
@@ -198,9 +313,10 @@ class BeanBagDB {
    * @returns {Object} {doc} or {doc,schema}
    */
   async get(doc_id,include_schema=false) {
+    this._check_ready_to_use()
     let doc = await this.db_api.get(doc_id);
     let schema = await this.get_schema_doc(doc.schema);
-    doc = this._decrypt_doc(schema, doc);
+    doc = this._decrypt_doc(schema["data"], doc);
     if(include_schema){
       return {doc,schema}
     }
@@ -215,10 +331,11 @@ class BeanBagDB {
     let schemaSearch = await this.db_api.search({
       selector: { schema: "schema", "data.name": schema_name },
     });
+    // console.log(schemaSearch)
     if (schemaSearch.docs.length == 0) {
-      throw new Error("Schema not found");
+      throw new Error(this.error_codes.schema_not_found);
     }
-    return schemaSearch.docs[0]["data"];
+    return schemaSearch.docs[0];
   }
 
   /**
@@ -230,7 +347,9 @@ class BeanBagDB {
    * @returns object
    */
   async get_doc(schema_name, primary_key = {}) {
-    let s_doc = await this.get_schema_doc(schema_name);
+    this._check_ready_to_use()
+    let schema_doc = await this.get_schema_doc(schema_name);
+    let s_doc = schema_doc["data"];
     let doc_obj;
     if (
       s_doc["settings"]["primary_keys"] &&
@@ -268,6 +387,7 @@ class BeanBagDB {
    * @param {Object} criteria
    */
   async search(criteria) {
+    this._check_ready_to_use()
     if (!criteria["selector"]) {
       throw new Error("Invalid search query.");
     }
@@ -285,12 +405,14 @@ class BeanBagDB {
    * @param {Object} settings (optional)
    */
   async insert(schema, data, meta= {},settings = {}) {
+    //console.log("here in insert")
+    this._check_ready_to_use()
     try {
       let doc_obj = await this._insert_pre_checks(schema, data, settings);
       let new_rec = await this.db_api.insert(doc_obj);
       return { id: new_rec["id"] };
     } catch (error) {
-      console.log(error);
+      // console.log(error);
       throw error;
     }
   }
@@ -312,13 +434,14 @@ class BeanBagDB {
    * @param {*} schema_name
    * @param {doc_obj} updates {data:{},meta:{}}, need not be the full document, just the new values of all/some fields
    * @param {Boolean} save_conflict = true -
-   * @returns
+   * 
    */
   async update(doc_id, rev_id, updates, update_source="api",save_conflict = true) {
+    this._check_ready_to_use()
     // making a big assumption here : primary key fields cannot be edited
     // so updating the doc will not generate primary key conflicts
     let req_data = await this.get(doc_id,true);
-    let schema = req_data.schema // await this.get_schema_doc(schema_name);
+    let schema = req_data.schema 
     let full_doc = req_data.doc // await this.get(doc_id)["doc"];
 
     // @TODO fix this : what to do if the rev id does not match 
@@ -329,43 +452,37 @@ class BeanBagDB {
     //   }
     // }
 
-    // blank check
-
     // update new value depending on settings.editable_fields (if does not exists, all fields are editable)
-    let edit_fields = Object.keys(schema.schema.properties)
-    if(schema.settings["editable_fields"]&&schema.settings["editable_fields"].length>0){
-      edit_fields = schema.settings["editable_fields"]
-    }
+    let all_fields = Object.keys(schema.schema.properties)
+    let unedit_fields = schema.settings["non_editable_fields"]
+    let edit_fields = all_fields.filter(item=>!unedit_fields.includes(item))
 
     // now generate the new doc with updates 
     let allowed_updates = this._filterObject(updates.data,edit_fields);
     let updated_data = { ...full_doc.data, ...allowed_updates };
 
-    // validate data
     this.validate_data(schema.schema, updated_data);
 
     // primary key check if multiple records can  be created 
-    if(schema.settings["single_record"]==false){
-      if(schema.settings["primary_keys"]&&schema.settings["primary_keys"].length>0){
-        let pri_fields = schema.settings["primary_keys"]
-        let search_criteria = {schema:schema.name}
-        pri_fields.map(itm=>{search_criteria["data."+itm] = updated_data[itm]})
-        let search = await this.search({selection:search_criteria})
-        if(search.docs.length>0){
-          if(search.docs.length==1){
-            let thedoc  = search.docs[0]
-            if(thedoc["_id"]!=doc_id){
-              throw new Error("Update not allowed. Document with the same primary key already exists")
-            }
-          }else{
-            throw new Error("There is something wrong with the schema")
+    if(schema.settings["single_record"]==false && schema.settings["primary_keys"].length>0){
+      let pri_fields = schema.settings["primary_keys"]
+      let search_criteria = {schema:schema.name}
+      pri_fields.map(itm=>{search_criteria["data."+itm] = updated_data[itm]})
+      let search = await this.search({selection:search_criteria})
+      if(search.docs.length>0){
+        if(search.docs.length==1){
+          let thedoc  = search.docs[0]
+          if(thedoc["_id"]!=doc_id){
+            throw new DocUpdateError([{message:"Update not allowed. Document with the same primary key already exists"}])
           }
         }
-      }
+        else{
+          throw new Error("There is something wrong with the schema primary keys")
+        }
+      } 
     }
 
     // encrypt the data  
-
     full_doc["data"] = updated_data
     full_doc = this._encrypt_doc(schema,full_doc);
     
@@ -384,11 +501,13 @@ class BeanBagDB {
   }
 
   async delete(doc_id) {
+    this._check_ready_to_use()
     await this.db_api.delete(doc_id)
   }
 
 
   async load_plugin(plugin_name,plugin_module){
+    this._check_ready_to_use()
     this.plugins[plugin_name] = {}
     for (let func_name in plugin_module){
       if(typeof plugin_module[func_name]=='function'){
@@ -401,24 +520,39 @@ class BeanBagDB {
     }
   }
 
-  //////// Helper method ////////
+  //////// Internal methods ////////
+
+  _get_current_version(){
+    // current version is the sum of versions of all system defined schemas 
+    let sum = sys_sch.schema_schema.version
+    let keys = Object.keys(sys_sch.system_schemas).map(item=>{
+      sum = sum+  sys_sch.system_schemas[item].version
+    })
+    if(sum == NaN){
+      throw Error("Error in system schema version numbers")
+    }
+    return sum 
+  }
+
+  _check_ready_to_use(){
+    if(!this.active){
+      throw new Error(this.error_codes.not_active)
+    }
+  }
+
 
   _generate_random_link(){
     const dictionary = ['rain', 'mars', 'banana', 'earth', 'kiwi', 'mercury', 'fuji', 'hurricane', 'matterhorn', 'snow', 'saturn', 'jupiter', 'peach', 'wind', 'pluto', 'apple', 'k2', 'storm', 'venus', 'denali', 'cloud', 'sunshine', 'mango', 'drizzle', 'pineapple', 'aconcagua', 'gasherbrum', 'apricot', 'neptune', 'fog', 'orange', 'blueberry', 'kilimanjaro', 'uranus', 'grape', 'storm', 'montblanc', 'lemon', 'chooyu', 'raspberry', 'cherry', 'thunder', 'vinson', 'breeze', 'elbrus', 'everest', 'parbat', 'makalu', 'nanga', 'kangchenjunga', 'lightning', 'cyclone', 'comet', 'asteroid', 'pomegranate', 'nectarine', 'clementine', 'strawberry', 'tornado', 'avalanche', 'andes', 'rockies', 'himalayas', 'pyrenees', 'carpathians', 'cascade', 'etna', 'vesuvius', 'volcano', 'tundra', 'whirlwind', 'iceberg', 'eclipse', 'zephyr', 'tropic', 'monsoon', 'aurora'];
     return Array.from({ length: 4 }, () => dictionary[Math.floor(Math.random() * dictionary.length)]).join('-');
   }
 
-  _check_required_fields(requiredFields,obj){
-    for (const field of requiredFields) {
-      if (!obj[field]) {throw new Error(`${field} is required`);}
-    }
-  }
+  
 
   /**
    * 
    * @param {*} obj 
    * @param {*} fields 
-   * @returns 
+   * 
    */
   _filterObject(obj, fields) {
     return fields.reduce((filteredObj, field) => {
@@ -429,36 +563,7 @@ class BeanBagDB {
     }, {});
   }
 
-  /**
-   * Checks if the selected database is initialized for working with BeanBagDB. Also throws a warning if package version does not match with database version.
-   * Every time a database is initialized, a setting document `beanbagdb_version` is added. If this does not exists, the database is not initialized. If it exists but does not match the current version, a warning is shown.
-   * @returns {object} {initialized:boolean,latest:boolean}
-   */
-  async _check_ready_to_use() {
-    // @TODO check if ready to use in major API methods
-    let check = { initialized: false, latest: false };
-    // @TODO this is not really fool proof. check all the required docs, they have the system_generated flag
-    // what if some user mistakenly modifies or deletes some of the required docs ?
-    let version_search = await this.db_api.search({
-      selector: { schema: "system_settings", "data.name": "beanbagdb_version" },
-    });
-    if (version_search.docs.length > 0) {
-      let doc = version_search.docs[0];
-      check.initialized = true;
-      check.latest = doc["data"]["value"] == this._version;
-    }
-    if (check.initialized == false) {
-      console.warn(
-        "This database is not ready to be used. It is not initialized. Run `initialize_db()` first"
-      );
-    }
-    if ((check.latest == false) & (check.initialized == true)) {
-      console.warn(
-        "This database is not updated with the latest version. Run `initialize_db()` again to update to the latest version"
-      );
-    }
-    return check;
-  }
+
 
   /**
    * To update the system schema or reset to a stable version to ensure functioning of the BeanBagDB
@@ -488,7 +593,7 @@ class BeanBagDB {
     let doc = {
       data: {},
       meta: {
-        createdOn: this._get_now_unix_timestamp(),
+        created_on: this._get_now_unix_timestamp(),
         tags: [],
         app :{},
         link : this._generate_random_link() // there is a link by default. overwrite this if user provided one but only before checking if it is unique
@@ -629,6 +734,54 @@ class BeanBagDB {
     doc_obj["data"] = new_data;
     return doc_obj;
   }
+
+  ////// Utility methods 
+  util_check_required_fields(requiredFields,obj){
+    for (const field of requiredFields) {
+      if (!obj[field]) {throw new Error(`${field} is required`);}
+    }
+  }
 }
 
-export default BeanBagDB;
+
+export class ValidationError extends Error {
+  constructor(errors = []) {
+    // Create a message based on the list of errors
+    //console.log(errors)
+    let error_messages = errors.map(item=>` ${(item.instancePath||" ").replace("/","")} ${item.message} `)
+    let message = `Validation failed with ${errors.length} error(s): ${error_messages.join(",")}`;
+    super(message);
+    this.name = 'ValidationError';
+    this.errors = errors;  // Store the list of errors
+  }
+}
+
+export class DocUpdateError extends Error {
+  constructor(errors=[]){
+    let error_messages  = errors.map(item=>`${item.message}`)
+    let message = `Error in document update. ${error_messages.join(",")}`
+    super(message)
+    this.name = "DocUpdateError";
+    this.errors = errors
+  }
+}
+
+export class DocInsertError extends Error {
+  constructor(errors=[]){
+    let error_messages  = errors.map(item=>`${item.message}`)
+    let message = `Error in document insert. ${error_messages.join(",")}`
+    super(message)
+    this.name = "DocInsertError";
+    this.errors = errors
+  }
+}
+
+export class DocNotFoundError extends Error {
+  constructor(errors=[]){
+    let error_messages  = errors.map(item=>`${item.message}`)
+    let message = `Error in fetching document. Criteria : ${error_messages.join(",")}`
+    super(message)
+    this.name = "DocNotFoundError";
+    this.errors = errors
+  }
+}

package/src/system_schema.js

@@ -1,7 +1,8 @@
 export const schema_schema = {
   name: "schema",
-  description:"Meta-schema or schema for defining other schemas",
+  description:"Meta-schema or the schema for defining other schemas",
   system_generated:true,
+  version:0.5,
   schema: {
     type: "object",
     additionalProperties: false,
@@ -10,6 +11,12 @@ export const schema_schema = {
         type:"boolean",
         default:false
       },
+      version: {
+        type: "number",
+        minimum: 0,
+        default: 1,
+        description:"This is an optional field.To be used primarily for system schemas"
+      }, 
       name: {
         type: "string",
         minLength: 5,
@@ -41,14 +48,17 @@ export const schema_schema = {
               type: "string",
             },
             maxItems: 10,
+            description:"Fields that makes each document unique in the schema.Leave it blank if you do not need it. You can still be able to distinguish documents using the link field and the document id."
           },
-          editable_fields: {
+          non_editable_fields: {
             type: "array",
             default: [],
             items: {
               type: "string",
             },
             maxItems: 50,
+            minItems:0,
+            description:"The list of fields whose values are added when the document is created but cannot be edited later in future."
           },
           encrypted_fields: {
             type: "array",
@@ -57,6 +67,7 @@ export const schema_schema = {
               type: "string",
             },
             maxItems: 50,
+            description:"Once set, all the data in this field will be encrypted before storing it in the database. Encryption key must be provided during the time of BeanBagDB initialization and must be managed by the user as it is NOT stored in the database"
           },
           single_record: {
             type: "boolean",
@@ -65,6 +76,7 @@ export const schema_schema = {
               "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: ["name","description","schema", "settings"],
@@ -76,29 +88,9 @@ export const schema_schema = {
 };
 
 export const system_schemas = {
-  logs: {
-    system_generated:true,
-    description:"Schema for the log doc. Single log doc for the whole DB to log stuff about the DB",
-    name: "system_logs",
-    schema: {
-      type: "object",
-      additionalProperties: true,
-      properties: {
-        logs: {
-          type: "array",
-          items: {
-            type: "object",
-            additionalProperties: true,
-          },
-        },
-      },
-    },
-    settings: {
-      single_record: true
-    },
-  },
   keys: {
     system_generated:true,
+    version:0.5,
     description:"To store user defined key. this can include anything like API tokens etc. There is a special method to fetch this. The values are encrypted",
     name: "system_keys",
     schema: {
@@ -129,10 +121,13 @@ export const system_schemas = {
     },
     settings: {
       primary_keys: ["name"],
-      encrypted_fields:["value"]
+      encrypted_fields:["value"],
+      non_editable_fields:[],
+      single_record: false
     },
   },
   settings: {
+    version:0.5,
     system_generated:true,
     description:"The system relies on these settings for proper functioning or enabling optional features.",
     name: "system_settings",
@@ -144,27 +139,25 @@ export const system_schemas = {
         name: {
           type: "string",
           minLength: 5,
-          maxLength: 250,
+          maxLength: 1000,
           pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
         },
         value: {
-          type: "string",
-          minLength: 5,
-          maxLength: 5000,
-          pattern: "^[^\n\r]*$",
-          description:"Must be a single line string"
-        },
-        user_editable: {
-          type: "boolean",
-          default: true,
-          description:
-            "Whether this setting is editable by the user or only by the system",
+          type: ["string", "number", "boolean", "array"] 
         },
+        on_update_array:{
+          type:"string",
+          default:"replace",
+          description:"Special operation only for updating Arrays. Either replace it or append new elements to it. Cannot be edited",
+          enum:["replace","append"],
+        }
       },
     },
     settings: {
       primary_keys: ["name"],
-      editable_fields: ["value"],
+      non_editable_fields: ["name"],
+      encrypted_fields:[],
+      single_record:false
     },
   },
 };

package/test/couch_connect.js

@@ -0,0 +1,29 @@
+import * as cdb from "./couchdb.js"
+import "dotenv/config"
+
+
+
+
+
+(async()=>{
+
+  let db = new cdb.BeanBagDB_CouchDB(process.env.cdburl, process.env.cdbname, process.env.secret)  
+  
+  //db.initialize_db()
+  await db.ready()
+   console.log(await db.metadata())
+  let test_schema = {
+    "name":"contact_list",
+    "description":"My contact book",
+    "schema":{},
+    "settings":{}
+  }
+
+  //let sch = await  db.insert("schema",test_schema,{"link":"test1"})
+  //console.log(sch)
+
+
+})();
+
+
+

package/test/couchdb.js

@@ -0,0 +1,75 @@
+// const crypto = require('crypto');
+// const SDB = require("beanbagdb")
+
+import Ajv  from 'ajv';
+import nano from "nano";  
+import BeanBagDB  from '../src/index.js';
+
+export class BeanBagDB_CouchDB extends BeanBagDB {
+  constructor(db_url,db_name,encryption_key){
+    //const cdb = import("nano")(db_url)
+    const cdb = nano(db_url)
+    const doc_obj = {
+      db_name:"couchdb",
+      name: db_name,
+      encryption_key: encryption_key,
+      api:{
+       insert: async (doc)=>{
+        const result = await cdb.insert(doc)
+        return result
+       },
+       // delete: ()=>{db1.destroy},
+        update: async (doc)=>{
+          const result = await cdb.insert(doc)
+          return result
+        },
+        search: async (query)=>{
+          const results = await cdb.find(query)
+          return results // of the form {docs:[],...}
+        },
+        get: async (id)=>{
+          const data = await cdb.get(id)
+          return data
+        },
+        createIndex: async (filter)=>{
+          const data = await cdb.createIndex(filter)
+          return data
+        },
+        delete: async (doc_id)=>{
+          const data = await cdb.get(id)
+          await cdb.destroy(data._id,data._rev)
+        }
+      },
+      utils:{
+        encrypt:  (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);
+          let encrypted = cipher.update(text, 'utf8', 'hex');
+          encrypted += cipher.final('hex');          
+          return iv.toString('hex') + ':' + encrypted; // Prepend the IV for later use
+        },
+        decrypt :  (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);
+          let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+          decrypted += decipher.final('utf8');
+          return decrypted;
+        },
+        ping : ()=>{
+          // @TODO ping the database to check connectivity when class is ready to use
+        },
+        validate_schema: (schema_obj, data_obj)=>{
+          const ajv = new Ajv({code: {esm: true}})  // options can be passed, e.g. {allErrors: true}
+          const validate = ajv.compile(schema_obj);
+          const valid = validate(data_obj);
+          return {valid,validate}
+        }
+      }
+    }
+    super(doc_obj)
+  }
+}
+
+  

package/test/init.test.js

@@ -1,7 +1,7 @@
 // to test initialization of the BeanBagDB class 
 import { get_pdb_doc } from './pouchdb.js';
 import { throws, strictEqual } from "assert";
-import BeanBagDB  from '../src/index.js';
+import {BeanBagDB}  from '../src/index.js';
 
 /**
  * Initial setup

package/test/operations.test.js

@@ -2,9 +2,7 @@
 // to test initialization of the BeanBagDB class 
 import { get_pdb_doc } from './pouchdb.js';
 import { throws, strictEqual,rejects } from "assert";
-import BeanBagDB  from '../src/index.js';
-
-
+import {BeanBagDB,ValidationError}  from '../src/index.js';
 
 let database   // this is the global db object
 
@@ -20,60 +18,64 @@ describe("Successful database class init (required for further testing) ", async
   });
 });
 
-
-
-
-describe("Testing creation of schema docs", async () => {
+describe("Schema doc insertion gives errors when", async () => {
   let schema_docs_invalid = [
-    {
+    [ "name missing",
+       {
       name: "",
       description: "",
       schema: {},
       settings: {},
-    },
-    {
+    }],
+    ["name is too short ",
+      {
       name: "nos",
       description: "",
       schema: {},
       settings: {},
-    },
-    {
+    }],
+    ["schema is blank",
+      {
       name: "contact",
       description: "",
       schema: {},
       settings: {},
-    },
-    {
+    }],
+    ["schema object missing",
+      {
       name: "contact",
       description: "This can be left blank",
-      schema: {},
       settings: {},
-    },
-    {
+    }],
+    [
+      "no schema.type",{
       name: "contact",
       description: "This can be left blank",
       schema: {
         "abc":"something"
       },
       settings: {},
-    },
-    {
+    }],
+    ["schema.type is invalid",
+      {
       name: "contact",
       description: "This can be left blank",
       schema: {
         "type":"something",
       },
       settings: {},
-    },
-    {
+    }],
+    ["schema.properties is missing",
+      {
       name: "contact",
       description: "This can be left blank",
       schema: {
         "type":"object",
       },
       settings: {},
-    },
-    {
+    }],
+    ["schema.properties is invalid",
+      {
       name: "contact",
       description: "This can be left blank",
       schema: {
@@ -81,8 +83,9 @@ describe("Testing creation of schema docs", async () => {
         "properties":"something"
       },
       settings: {},
-    },
-    {
+    }],
+    ["schema.properties are missing/blank object",
+      {
       name: "contact",
       description: "This can be left blank",
       schema: {
@@ -90,8 +93,9 @@ describe("Testing creation of schema docs", async () => {
         "properties":{}
       },
       settings: {},
-    },
-    {
+    }],
+    ["schema.additionalProperties is missing",
+      {
       name: "contact",
       description: "This can be left blank",
       schema: {
@@ -99,8 +103,9 @@ describe("Testing creation of schema docs", async () => {
         "properties":{"name":{"type":"string"}}
       },
       settings: {},
-    },
-    {
+    }],
+    ["schema.additionalProperties is invalid",
+      {
       name: "contact",
       description: "This can be left blank",
       schema: {
@@ -109,8 +114,30 @@ describe("Testing creation of schema docs", async () => {
         "additionalProperties":"no"
       },
       settings: {},
-    },
-    // {
+    }],
+    [
+      "setting is missing",{
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}},
+        "additionalProperties":true
+      }
+    }],
+    [
+      "setting is invalid",{
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}},
+        "additionalProperties":true
+      },
+      settings:"none"
+    }],
+    // ["settings.primary_keys is missing",
+    //   {
     //   name: "contact",
     //   description: "This can be left blank",
     //   schema: {
@@ -118,28 +145,183 @@ describe("Testing creation of schema docs", async () => {
     //     "properties":{"name":{"type":"string"}},
     //     "additionalProperties":true
     //   },
-    //   settings: {},
-    // },
+    //   settings: {
+    //   },
+    // }],
+    ["settings.primary_keys is invalid",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:"name"
+      },
+    }],
+    ["settings.non_editable_fields is invalid",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:["name"],
+        non_editable_fields:"all"
+      },
+    }],
+    ["settings.single_record is invalid",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:["name"],
+        non_editable_fields:[],
+        single_record:"no"
+      },
+    }],
+    ["settings.encrypted_fields is invalid",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:["name"],
+        non_editable_fields:[],
+        single_record:false,
+        encrypted_fields:"none"
+      },
+    }],
+    ["settings.primary_keys fields are not defined in schema",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:["name1"],
+        non_editable_fields:[],
+        single_record:false,
+        encrypted_fields:"none"
+      },
+    }],
+    ["settings.primary_keys field is an object",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"object"},"address":{type:"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:["name"],
+        non_editable_fields:[],
+        single_record:false,
+        encrypted_fields:[]
+      },
+    }],
+    ["settings.non_editable_fields not defined in the schema",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"},"address":{type:"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:["name"],
+        non_editable_fields:["mobile"],
+        single_record:false,
+        encrypted_fields:[]
+      },
+    }],
+    ["settings.encrypted_fields not defined in the schema",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"},"address":{type:"object"},"secret":{"type":"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:["name"],
+        non_editable_fields:["mobile"],
+        single_record:false,
+        encrypted_fields:["password"]
+      },
+    }],
+    ["settings.encrypted_fields is not a string",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"},"address":{type:"object"},"secret":{"type":"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:["name"],
+        non_editable_fields:["mobile"],
+        single_record:false,
+        encrypted_fields:["address"]
+      },
+    }],
+    ["settings.encrypted_fields is a primary key",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"},"address":{type:"object"},"secret":{"type":"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:["name"],
+        non_editable_fields:["mobile"],
+        single_record:false,
+        encrypted_fields:["name"]
+      },
+    }]
   ];
 
-  let doc_obj = get_pdb_doc("test_database_25", "qwertyuiopaqwsde1254");
-  let database = new BeanBagDB(doc_obj);
-  database.initialize_db();
-  database.ready();
-  // schema_docs_invalid.forEach(doc=>{})
-  for (let index = 0; index < schema_docs_invalid.length; index++) {
-    const element = schema_docs_invalid[index];
 
-    it("throws error", async () => {
+  before(async () => {
+    let doc_obj = get_pdb_doc("test_database_25", "qwertyuiopaqwsde1254");
+    database = new BeanBagDB(doc_obj);
+    await database.ready(); // Ensure the database is ready before running tests
+    console.log("Ready for more tests...");
+  });
+
+  schema_docs_invalid.forEach((element, index) => {
+    it(`${element[0]}`, async () => {
       await rejects(
         async () => {
-          await database.insert("schema", element);
+          await database.insert("schema", element[1]);
         },
-        Error
+        ValidationError
       );
     });
-
-  }
+  });  
   
 });
 

package/test/pouchdb.js

@@ -10,6 +10,7 @@ export const get_pdb_doc = (dbname,secret)=>{
 const pdb = new PouchDB(dbname);
   const doc_obj = {
     name: dbname,
+    db_name:"pouchdb",
     encryption_key: secret,
     api: {
       insert: async (doc) => {

package/test/test1.js

@@ -158,21 +158,29 @@
 
 import { get_pdb_doc } from './pouchdb.js';
 import { throws, strictEqual } from "assert";
-import BeanBagDB  from '../src/index.js';
+import {BeanBagDB}  from '../src/index.js';
 
 (async()=>{
+
   let schema_docs_invalid = [
     {
-     "name":"",
-     "description":"",
-     "schema":{},
-     "settings":{} 
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"},"address":{type:"object"},"secret":{"type":"string"}},
+        "additionalProperties":true
+      },
+      settings: {
+        primary_keys:["name"],
+        non_editable_fields:["address"],
+        single_record:false,
+        encrypted_fields:["name"]
+      },
     }
-    
     ]
   let doc_obj = get_pdb_doc("test_database_26","qwertyuiopaqwsde1254")
   let database = new BeanBagDB(doc_obj);
-  database.initialize_db()
-  database.ready()
+  await database.ready()
   let a = await database.insert("schema",schema_docs_invalid[0])
 })()