beanbagdb 0.5.61 → 0.5.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beanbagdb",
-  "version": "0.5.61",
+  "version": "0.5.71",
   "description": "A JS library to introduce a schema layer to a No-SQL local database",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/index.js

@@ -114,7 +114,7 @@ export class BeanBagDB {
    *
    * This method performs the following actions:
    * - Pings the database.
-   * - Searches the database for the `system_settings.beanbagdb_version` document.
+   * - Searches the database for the `system_setting.beanbagdb_version` document.
    * - Sets the class state as active if the version matches the current BeanBagDB version.
    * - If the version does not match, calls `initialize()` to set up the database to the latest version.
    * @todo Code to ping the DB and throw Connection error if failed to connect
@@ -123,17 +123,22 @@ export class BeanBagDB {
    */
   async ready() {
     // TODO Ping db
+    console.log("running ready....")
     let version_search = await this.db_api.search({
-      selector: { schema: "system_settings", "data.name": "beanbagdb_version" },
-    });
+      selector: { schema: "system_setting", "data.name": "beanbagdb_system" },
+    })
+    //console.log(version_search)
     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"];
+      //console.log(doc)
+      this.active = doc["data"]["value"]["version"] == this._version;
+      this.meta.beanbagdb_version_db = doc["data"]["value"]["version"];
     }
     if (this.active) {
       console.log("Ready");
     } else {
+      console.log("Not ready. Init required")
+      //throw new Error("Initialization required")
       await this.initialize();
     }
   }
@@ -155,81 +160,132 @@ export class BeanBagDB {
    */
   async initialize() {
     // 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 {
-      let schema = await this.get("schema",{name:"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.util_get_now_unix_timestamp();
-        await this.db_api.update(full_doc);
-        logs.push("new schema_schema v " + sys_sch.schema_schema.version);
-      }
+      let app_data = await this.initialize_db(sys_sch.default_app)
+      console.log(app_data)
+      this.meta.beanbagdb_version_db = this._version;
+      this.active = true;
+      return app_data      
     } catch (error) {
-      // console.log(error);
-      if (error instanceof DocNotFoundError) {
-        // 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);
-        logs.push("init schema_schema v " + sys_sch.schema_schema.version);
-      }
+      console.log("Error in initializing instance")
+      console.log(error)
+      throw error
     }
 
-    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]];
+  }
+
+  async initialize_db(app_data){
+    // app_data : meta(name,description), schemas[] , default_records:[]
+    // TODO check if add_data is valid
+    // calculate the app_version 
+    let latest_version = 0
+    app_data.schemas.map(sch=>{latest_version = latest_version + sch.version})
+    app_data.records.map(sch=>{latest_version = latest_version + sch.version})
+
+
+    // check if app setting record exists 
+    let version_search = await this.db_api.search({
+      selector: { schema: "system_setting", "data.name": app_data.meta.name },
+    })
+
+    let update_required = true 
+    let doc 
+    if (version_search.docs.length > 0) {
+      doc = version_search.docs[0];
+      if(doc["data"]["value"]["version"] == latest_version){
+        update_required = false
+      }
+    }
+    
+    // if no update required return the document 
+    if(!update_required){return doc}
+    // if version is latest no additional steps required
+    // version mismatch => update all docs
+
+    let text = `Initializing ${app_data.meta.name} app to v.${latest_version}`
+    let steps = ["update started"]
+
+    for (let index = 0; index < app_data.schemas.length; index++) {
+      const schema_name = app_data.schemas[index]["name"];
+      const schema_data = app_data.schemas[index]
+      steps.push(`checking.${schema_name}`)
       try {
         // console.log(schema_name)
         let schema1 = await this.get("schema",{name:schema_name}) 
         if (schema1["data"]["version"] != schema_data.version) {
-          logs.push("old " + schema_name + " v " + schema1["data"]["version"]);
+          steps.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.util_get_now_unix_timestamp();
+          console.log(full_doc)
           await this.db_api.update(full_doc);
-          logs.push("new " + schema_name + " v " + schema_data.version);
+          
+          steps.push(`new.${schema_name}.v=${schema_data.version}`);
+        }else{
+          steps.push(`${schema_name}.v.${schema1["data"]["version"]}=latest`)
         }
       } catch (error) {
         // console.log(error);
         if (error instanceof DocNotFoundError) {
           // 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);
+          if(schema_name=="schema"&& app_data.meta.name=="beanbagdb_system"){
+            // this is to initialize the system schema
+            let schema_schema_doc = this._get_blank_doc("schema");
+            schema_schema_doc.data = schema_data;
+            //console.log(schema_schema_doc)
+            await this.db_api.insert(schema_schema_doc);
+          }else{
+            let system_schema = sys_sch.default_app.schemas[0]["schema"]
+            let new_schema_doc = this._get_blank_schema_doc(
+              "schema",
+              system_schema,
+              schema_data
+            );
+            await this.db_api.insert(new_schema_doc);
+          }
+          steps.push(`init.${schema_name}.v=${schema_data.version}`);
+        }else{
+          steps.push(`${schema_name}.error.message : ${error.message} `);
         }
       }
     }
-    // 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.save_setting_doc("system_logs", {
-        value: { text: logs.join(","), added: this.util_get_now_unix_timestamp() },
-        on_update_array: "append",
-      });
-      await this.save_setting_doc("beanbagdb_version", {
-        value: this._version,
-      });
 
-      this.meta.beanbagdb_version_db = this._version;
-      this.active = true;
-      console.log(logs.join(","))
-    } else {
-      // no new updates were done
-      console.log("Database already up to date");
+    for (let index = 0; index < app_data.records.length; index++) {
+      const schema_name = app_data.records[index]["schema"]
+      const schema_data = app_data.records[index]["record"]
+      const record_title = app_data.records[index]["title"]
+      steps.push(`checking.records.${record_title}`)
+      try {
+        let new_doc = await this.create(schema_name,schema_data,app_data.records[index]["meta"])
+        steps.push(`doc.${record_title}.created`)
+      } catch (error) {
+        if(!(error instanceof DocCreationError)){
+          steps.push(`error in doc ${record_title} insertion: ${error.message}, doc: ${JSON.stringify(schema_data)}`)
+        }
+      }
+    }
+
+    let app_doc = { ... app_data.meta, version: latest_version}
+    try {
+      await this.save_setting_doc(app_data.meta.name, {
+        value: app_doc,
+      });       
+    } catch (error) {
+      console.log(error)
+      console.log("error in storing/updating beanbagdb_version")
     }
-  }
+
+    try {
+      let new_log_doc =  this._get_blank_doc("system_log")
+      new_log_doc.data = {text,data:{steps},time:this.util_get_now_unix_timestamp(),app:app_data.meta.name}
+      await this.db_api.insert(new_log_doc);
+      console.log("init logged")
+    } catch (error) {
+      console.log(error)
+    }
+    return app_doc
+  } 
 
 
   /**
@@ -263,7 +319,7 @@ export class BeanBagDB {
     }
 
     let doc_search = await this.db_api.search({
-      selector: { schema: "system_settings", "data.name": name },
+      selector: { schema: "system_setting", "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
@@ -293,7 +349,7 @@ export class BeanBagDB {
         new_val.value = [new_data.value];
         new_val.on_update_array = new_data.on_update_array;
       }
-      let new_doc = this._get_blank_doc("system_settings");
+      let new_doc = this._get_blank_doc("system_setting");
       new_doc["data"] = {
         name: name,
         ...new_val,
@@ -641,18 +697,35 @@ export class BeanBagDB {
     }
   }
 
+  /**
+   * To load a plugin in the current BeanBagDB instance.
+   * Plug_module has to be loaded manually first. It must export an object containing fields: `actions` and `schema`. 
+   * `actions` is an object of methods which can be called after loading the plugin. 
+   * `schema` is an array of JSON schemas that are required by the plugin. Every time a plugin is loaded, this list is schemas is verified. New updates are added automatically to the database and logged 
+   *  methods inside actions must be async and must have at least one parameter : `db_instance` which is assumed to be the current instance of the BeanBagDB object itself. They ideally must also return some value.
+   * @param {string} plugin_name 
+   * @param {object} plugin_module 
+   */
   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") {
-        this.plugins[plugin_name][func_name] = plugin_module[func_name].bind(null,this)
+    //console.log(plugin_module)
+    if(plugin_module.actions){
+      for (let func_name in plugin_module.actions) {
+        if (typeof plugin_module.actions[func_name] == "function") {
+          this.plugins[plugin_name][func_name] = plugin_module.actions[func_name].bind(null,this)
+        }
       }
     }
-    // Check if the plugin has an on_load method and call it
-    if (typeof this.plugins[plugin_name].on_load === "function") {
-      await this.plugins[plugin_name].on_load();
+
+    if(plugin_module.schemas){
+      await this._upgrade_schema_in_bulk(plugin_module.schemas,true,`Updating ${plugin_name} plugin schemas`)
     }
+
+    // Check if the plugin has an on_load method and call it
+    // if (typeof this.plugins[plugin_name].on_load === "function") {
+    //   await this.plugins[plugin_name].on_load();
+    // }
   }
 
 ///////////////////////////////////////////////////////////
@@ -772,6 +845,65 @@ _check_nodes_edge(node1Rule, node2Rule, schema1, schema2) {
 //////////////// Internal methods ////////////////////////
 //////////////////////////////////////////////////////////
 
+
+async _upgrade_schema_in_bulk(schemas,log_upgrade=false,log_message="Schema Upgrade in bulk"){
+  // TODO add a check to now allow default system schema to be updated from this method
+
+  let steps = ["schema update started"]
+  let update_was_required = false
+  for (let index = 0; index < schemas.length; index++) {
+    const schema_name = schemas[index]["name"];
+    const schema_data = schemas[index]
+    steps.push(`checking.${schema_name}`)
+    try {
+      let schema1 = await this.get("schema",{name:schema_name}) 
+      if (schema1["data"]["version"] != schema_data.version) {
+        steps.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.util_get_now_unix_timestamp();
+        console.log(full_doc)
+        await this.db_api.update(full_doc);
+        steps.push(`new.${schema_name}.v=${schema_data.version}`);
+        update_was_required = update_was_required || true
+      }else{
+        steps.push(`${schema_name}.v.${schema1["data"]["version"]}=latest`)
+      }
+    } catch (error) {
+      // console.log(error);
+      if (error instanceof DocNotFoundError) {
+        // inserting new schema doc
+          let system_schema = sys_sch.default_app.schemas[0]["schema"]
+          let new_schema_doc = this._get_blank_schema_doc(
+            "schema",
+            system_schema,
+            schema_data
+          );
+          await this.db_api.insert(new_schema_doc);
+        
+        steps.push(`init.${schema_name}.v=${schema_data.version}`);
+        update_was_required = update_was_required || true
+      }else{
+        steps.push(`${schema_name}.error.message : ${error.message} `);
+      }
+    }
+  }
+  // console.log(JSON.stringify(steps))
+  // console.log(update_was_required)
+  if (update_was_required && log_upgrade){
+    // log it if asked 
+    try {
+      let new_log_doc =  this._get_blank_doc("system_log")
+      new_log_doc.data = {text:log_message,data:{steps},time:this.util_get_now_unix_timestamp()}
+      await this.db_api.insert(new_log_doc);      
+    } catch (error) {
+      console.log(error) 
+    }
+
+  }
+  return {update_was_required,logs:steps}
+}
+
 /**
  * Retrieves the current version of the system by summing up the version numbers 
  * of all system-defined schemas.
@@ -783,10 +915,10 @@ _check_nodes_edge(node1Rule, node2Rule, schema1, schema2) {
  */
   _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;
-    });
+    let sum = 0 
+    // sys_sch.schema_schema.version;
+    sys_sch.default_app.schemas.map((item) => {sum = sum + item.version})
+    sys_sch.default_app.records.map((item) => {sum = sum + item.version})
     if (sum == NaN) {
       throw Error("Error in system schema version numbers");
     }

package/src/plugins/text_command.js

@@ -1,6 +1,3 @@
-
-
-
 const commands = {
   new: {
     parse: async (instance,parts) => {
@@ -187,7 +184,8 @@ const parse_and_run = async(instance, text) => {
   let command_result = await run(instance,command)
   return command_result
 }
+// const schemas =    []
 
 export const text_command = {
-  parse,run,parse_and_run
+  actions: {parse,run,parse_and_run}
 };

package/src/system_schema.js

@@ -1,267 +1,326 @@
-export const schema_schema = {
-  name: "schema",
-  description:"Meta-schema or the schema for defining other schemas",
-  system_generated:true,
-  version:0.56,
-  schema: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      system_generated:{
-        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: 4,
-        maxLength: 50,
-        pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
-        description:"This is the name of the schema.It cannot be changed later"
+export const default_app = {
+  meta :{
+    name:"beanbagdb_system",
+    description:"This is the default system app required for proper functioning of the database"
+  },
+  schemas:[
+    {
+      name: "schema",
+      description:"Meta-schema or the schema for defining other schemas",
+      system_generated:true,
+      version:0.80,
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          system_generated:{
+            title:"System generated schema",
+            type:"boolean",
+            default:false
+          },
+          version: {
+            type: "number",
+            title:"Version",
+            minimum: 0,
+            default: 1,
+            description:"This is an optional field.To be used primarily for system schemas"
+          }, 
+          name: {
+            type: "string",
+            title:"Name",
+            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"
+          },
+          description:{
+            type:"string",
+            title:"About",
+            minLength:0,
+            maxLength:1000,
+            description:"A small description of what  data in this schema stores."
+          },
+          schema: {
+            type: "object",
+            title:"JSON Schema specification",
+            additionalProperties: true,
+            minProperties: 1,
+            maxProperties: 50,
+            description:"This must be a valid JSON Schema which will be used to validate documents created with this schema.See this https://tour.json-schema.org/",
+          },
+          settings: {
+            type: "object",
+            title:"Additional Settings",
+            additionalProperties: true,
+            properties: {
+              primary_keys: {
+                title:"Primary key",
+                type: "array",
+                default: [],
+                items: {
+                  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."
+              },
+              non_editable_fields: {
+                type: "array",
+                title:"Non editable fields",
+                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",
+                title:"List of fields encrypted",
+                default: [],
+                items: {
+                  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"
+              },
+              display_fields: {
+                type: "array",
+                title:"List of fields to show in short view",
+                default: [],
+                items: {
+                  type: "string",
+                },
+                maxItems: 50,
+                description:"These fields will be used when a record is displayed in short"
+              }
+            },
+            required :["primary_keys","non_editable_fields","encrypted_fields"]
+          },
+        },
+        required: ["name","version","description","schema", "settings"],
       },
-      description:{
-        type:"string",
-        minLength:0,
-        maxLength:1000,
-        description:"A small description of what  data in this schema stores."
+      settings: {
+        primary_keys: ["name"],
+        non_editable_fields:[],
+        encrypted_fields:[],
+        display_fields:["name","version","description"]
       },
+    },
+    {
+      system_generated:true,
+      version:0.60,
+      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_key",
       schema: {
         type: "object",
         additionalProperties: true,
-        minProperties: 1,
-        maxProperties: 50,
-        description:"This must be a valid JSON Schema which will be used to validate documents created with this schema.See this https://tour.json-schema.org/",
+        required:["name","value"],
+        properties: {
+          name: {
+            type: "string",
+            minLength: 5,
+            maxLength: 50,
+            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"
+          },
+          note: {
+            type: "string",
+            minLength: 1,
+            maxLength: 5000,
+          },
+        },
       },
       settings: {
+        primary_keys: ["name"],
+        encrypted_fields:["value"],
+        non_editable_fields:[]
+      },
+    },
+    {
+      version:0.60,
+      system_generated:true,
+      description:"The system relies on these settings for proper functioning or enabling optional features.",
+      name: "system_setting",
+      schema: {
+        required:["name","value"],
         type: "object",
         additionalProperties: true,
         properties: {
-          primary_keys: {
-            type: "array",
-            default: [],
-            items: {
-              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."
+          name: {
+            type: "string",
+            minLength: 5,
+            maxLength: 1000,
+            pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
           },
-          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."
+          value: {
+            type: ["string", "number", "boolean", "array"] 
           },
-          encrypted_fields: {
-            type: "array",
-            default: [],
-            items: {
-              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"
+          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"],
           }
         },
-        required :["primary_keys","non_editable_fields","encrypted_fields"]
       },
-    },
-    required: ["name","description","schema", "settings"],
-  },
-  settings: {
-    primary_keys: ["name"],
-    non_editable_fields:[],
-    encrypted_fields:[]
-  },
-};
-
-export const system_schemas = {
-  keys: {
-    system_generated:true,
-    version:0.53,
-    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_key",
-    schema: {
-      type: "object",
-      additionalProperties: true,
-      required:["name","value"],
-      properties: {
-        name: {
-          type: "string",
-          minLength: 5,
-          maxLength: 50,
-          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"
-        },
-        note: {
-          type: "string",
-          minLength: 1,
-          maxLength: 5000,
-        },
+      settings: {
+        primary_keys: ["name"],
+        non_editable_fields: ["name"],
+        encrypted_fields:[]
       },
     },
-    settings: {
-      primary_keys: ["name"],
-      encrypted_fields:["value"],
-      non_editable_fields:[]
-    },
-  },
-  settings: {
-    version:0.5,
-    system_generated:true,
-    description:"The system relies on these settings for proper functioning or enabling optional features.",
-    name: "system_setting",
-    schema: {
-      required:["name","value"],
-      type: "object",
-      additionalProperties: true,
-      properties: {
-        name: {
-          type: "string",
-          minLength: 5,
-          maxLength: 1000,
-          pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
-        },
-        value: {
-          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"],
+    {
+      name:"system_edge_constraint",
+      system_generated:true,
+      version:0.50,
+      description: "To define edge constraints for simple directed graph of records.",
+      schema:{
+        type: "object",
+        additionalProperties: true,
+        required:["node1","node2","edge_type"],
+        properties: {
+          node1: {
+            type: "string",
+            minLength: 1,
+            maxLength: 500,
+            pattern: "^(\\*|(\\*-[a-zA-Z0-9_-]+)(,[a-zA-Z0-9_-]+)*|[a-zA-Z0-9_-]+(,[a-zA-Z0-9_-]+)*)$"
+          },
+          node2: {
+            type: "string",
+            minLength: 1,
+            maxLength: 500,
+            pattern: "^(\\*|(\\*-[a-zA-Z0-9_-]+)(,[a-zA-Z0-9_-]+)*|[a-zA-Z0-9_-]+(,[a-zA-Z0-9_-]+)*)$"
+          },
+          name:{
+            type: "string",
+            minLength: 1,
+            maxLength: 500,
+            pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
+          },
+          label:{
+            type: "string",
+            maxLength: 500,
+          },
+          note:{
+            type: "string",
+            maxLength: 5000,
+          },
+          max_from_node1:{
+            type:"number",
+            default: -1,
+          },
+          max_to_node2:{
+            type:"number",
+            default: -1,
+          }
         }
       },
+      settings: {
+        primary_keys: ["name"],
+        non_editable_fields:["name"],
+        encrypted_fields:[]
+      },
     },
-    settings: {
-      primary_keys: ["name"],
-      non_editable_fields: ["name"],
-      encrypted_fields:[]
-    },
-  },
-  edges_constraints:{
-    name:"system_edge_constraint",
-    system_generated:true,
-    version:0.5,
-    description: "To define edge constraints for simple directed graph of records.",
-    schema:{
-      type: "object",
-      additionalProperties: true,
-      required:["node1","node2","edge_type"],
-      properties: {
-        node1: {
-          type: "string",
-          minLength: 1,
-          maxLength: 500,
-          pattern: "^(\\*|(\\*-[a-zA-Z0-9_-]+)(,[a-zA-Z0-9_-]+)*|[a-zA-Z0-9_-]+(,[a-zA-Z0-9_-]+)*)$"
-        },
-        node2: {
-          type: "string",
-          minLength: 1,
-          maxLength: 500,
-          pattern: "^(\\*|(\\*-[a-zA-Z0-9_-]+)(,[a-zA-Z0-9_-]+)*|[a-zA-Z0-9_-]+(,[a-zA-Z0-9_-]+)*)$"
-        },
-        name:{
-          type: "string",
-          minLength: 1,
-          maxLength: 500,
-          pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
-        },
-        label:{
-          type: "string",
-          maxLength: 500,
-        },
-        note:{
-          type: "string",
-          maxLength: 5000,
-        },
-        max_from_node1:{
-          type:"number",
-          default: -1,
-        },
-        max_to_node2:{
-          type:"number",
-          default: -1,
+    {
+      name:"system_edge",
+      system_generated:true,
+      version:0.50,
+      description: "To define edges in the simple directed graph of records.",
+      schema:{
+        type: "object",
+        additionalProperties: true,
+        required:["node1","node2","edge_type"],
+        properties: {
+          node1: {
+            type: "string",
+          },
+          node2: {
+            type: "string",
+          },
+          edge_name:{
+            type: "string",
+          }
         }
-      }
-    },
-    settings: {
-      primary_keys: ["name"],
-      non_editable_fields:["name"],
-      encrypted_fields:[]
+      },
+      settings: {
+        primary_keys: ["node1","node2","edge_type"],
+        non_editable_fields:["edge_type"],
+        encrypted_fields:[]
+      },
     },
-  },
-  edges:{
-    name:"system_edge",
-    system_generated:true,
-    version:0.5,
-    description: "To define edges in the simple directed graph of records.",
-    schema:{
-      type: "object",
-      additionalProperties: true,
-      required:["node1","node2","edge_type"],
-      properties: {
-        node1: {
-          type: "string",
-        },
-        node2: {
-          type: "string",
-        },
-        edge_name:{
-          type: "string",
+    {
+      name:"system_media",
+      system_generated:true,
+      version:0.60,
+      description: "To store images as Base64",
+      schema:{
+        type: "object",
+        additionalProperties: true,
+        required:["imageBase64","caption","source"],
+        properties: {
+          imageBase64: {
+            type: "string",
+            "media": {
+              "binaryEncoding": "base64"
+            }
+          },
+          caption: {
+            type: "string",
+          },
+          source:{
+            type: "string",
+          }
         }
-      }
-    },
-    settings: {
-      primary_keys: ["node1","node2","edge_type"],
-      non_editable_fields:["edge_type"],
-      encrypted_fields:[]
+      },
+      settings: {
+        primary_keys: ["caption"],
+        non_editable_fields:[],
+        encrypted_fields:[]
+      },
     },
-  },
-  media:{
-    name:"system_media",
-    system_generated:true,
-    version:0.5,
-    description: "To store images as Base64",
-    schema:{
-      type: "object",
-      additionalProperties: true,
-      required:["imageBase64","caption","source"],
-      properties: {
-        imageBase64: {
-          type: "string",
-          "media": {
-            "binaryEncoding": "base64"
+    {
+      name:"system_log",
+      system_generated:true,
+      version:0.50,
+      description: "To define edges in the simple directed graph of records.",
+      schema:{
+        type: "object",
+        additionalProperties: true,
+        required:["text"],
+        properties: {
+          text: {
+            type: "string",
+          },
+          data: {
+            type: "object",
+            additionalProperties: true,
+          },
+          app:{
+            type: "string",
+          },
+          time:{
+            type:"string"
           }
-        },
-        caption: {
-          type: "string",
-        },
-        source:{
-          type: "string",
         }
-      }
-    },
-    settings: {
-      primary_keys: ["caption"],
-      non_editable_fields:[],
-      encrypted_fields:[]
-    },
-  }
-};
+      },
+      settings: {
+        primary_keys: [],
+        non_editable_fields:[],
+        encrypted_fields:[]
+      },
+    }
+  ], 
+  records:[]
+}
+
+
 
 // this is not stored in the DB. only for validating the metadata during doc update
 export const editable_metadata_schema = {

package/test/operations.test.js

@@ -1656,7 +1656,7 @@ describe("Doc search tests", async () => {
   it('all docs', async () => {
       try {
         let udata = await database3.search({selector:{}})
-        assert(udata.docs.length==11)
+        assert(udata.docs.length==12)
       } catch (error) {
         //console.log(error)
         throw error
@@ -1676,7 +1676,7 @@ describe("Doc search tests", async () => {
   it('read docs 2', async () => {
     try {
       let udata = await database3.search({selector:{"schema":"schema"}})
-      assert(udata.docs.length==7) // schema,book,setting,key,edge,edge_constraints
+      assert(udata.docs.length==8) // schema,book,setting,key,edge,edge_constraints
     } catch (error) {
       //console.log(error)
       throw error