beanbagdb 0.5.46 → 0.5.51

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)
+        }
+      } 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)
         }
-        // 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,
+      }
+    }
+    // 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,13 +235,75 @@ 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 = [{"message":"Schema validation errors "}]
+    if(!schema_doc["schema"]["type"]){
+      errors.push({message:"Schema must have the field schema.'type' which can only be 'object' "})
+    }else{
+      if(schema_doc["schema"]["type"]!="object"){
+        errors.push({message:"The schema.'type' value  is invalid.Only 'object' allowed"})
+      }
+    }
+    if(!schema_doc["schema"]["properties"]){
+      errors.push({message:"The schema.'properties' object does not exists"})
+    }else{
+      if(typeof(schema_doc["schema"]["properties"])!="object"){
+        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({message:"You must define at least one property"})
+      }
+    }
 
+    if(!schema_doc["schema"]["additionalProperties"]){
+      errors.push({message:"The schema.'additionalProperties' field is required"})
+    }else{
+      if(typeof(schema_doc["schema"]["additionalProperties"])!="boolean"){
+        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(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)
+    }
   }
 
   /**
@@ -169,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}
     }
@@ -186,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];
   }
 
   /**
@@ -201,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"] &&
@@ -239,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.");
     }
@@ -255,13 +404,15 @@ class BeanBagDB {
    * @param {Object} data e.g {"name":"","mobile":""...}
    * @param {Object} settings (optional)
    */
-  async insert(schema, data, settings = {}) {
+  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;
     }
   }
@@ -283,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 
@@ -300,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);
     
@@ -355,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'){
@@ -372,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) => {
@@ -400,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
@@ -459,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
@@ -563,6 +697,10 @@ class BeanBagDB {
 
     // special checks for special docs
     // @TODO : for schema dos: settings fields must be in schema field
+    if(schema=="schema"){
+      //more checks are required
+      this.validate_schema_object(data)
+    }
     // @TODO : check if single record setting is set to true
 
     // duplicate check
@@ -596,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
+  }
+}