beanbagdb 0.5.54 → 0.5.61

package/doc-src/1_getting-started.md

@@ -1 +1,64 @@
-# Getting started
+# Getting started
+
+
+
+### Nodes and edges
+
+The records stored in  BeanBagDB can be organized into a simple directed graph. In in simple directed graph, edges have a direction and there can only be one edge between 2 nodes. Edges can have label based on the context of your data. You can also define rules for these edges based on the schema of the nodes.
+
+Example : Consider you have 3 types of nodes : "player", "team", "match"  to simulate a game where a teams has multiple players and a player plays a match as part of a team. 
+Here are the rules: 
+-  A player is part of a team (and not vice versa)
+-  A team plays a match (and not vice versa)
+-  A player cannot be in 2 teams
+-  A match can only be between 2 teams (not more than 2)
+-  Player does not play a match (but a team does, assuming this is a team sport)
+-  A team cannot be part of a team  
+-  A team cannot have more than 11 players
+
+In terms of nodes and edges, the rules translate to:
+
+| rule                                                  | node 1 | edge label  | node 2 | constraint                      |
+|-------------------------------------------------------|--------|-------------|--------|---------------------------------|
+| 1 A player is part of a team (and not vice versa)       | player | is part of  | team   | player-->team                   |
+| 2 A team plays a match (and not vice versa)             | team   | plays       | match  |                                 |
+| 3 A player cannot be in 2 teams                         | player | is part of  | team   | only one such relation          |
+| 4 A match can only be between 2 teams (not more than 2) | team   | plays       | match  | only 2 such relation per match  |
+| 5 Player does not play a match                          | player | plays       | match  | not valid                       |
+| 6 A team cannot be part of a team                       | team   | is part of  | team   | not valid                       |
+| 7 A team cannot have more than 11 players               | player | is part of  | team   | only 11 such relations per team |
+
+
+These rules can be enforced in the database as "edge_constraints" and are automatically checked when new edges are added to the graph.
+
+```
+  - Constraint 1 : 
+    - node 1 : player
+    - edge type : part_of
+    - edge label : is part of a 
+    - node 2 : team
+    - max_from_node1 : 1
+    - max_to_node2 : 11
+  - Constraint 2 :
+    - node 1 : team 
+    - edge type : plays
+    - edge label : plays 
+    - node 2 : match
+    - max_from_node1 : None
+    - max_to_node2 : 2
+```
+- `max_from_node1` defines the maximum number of edges of a certain type that can exist from node 1 to node 2. For example, player1 is part of team1; now, player1 cannot be part of any other team.
+- `max_to_node2` defines the maximum number of edges of a certain type that can be directed towards a particular node. For example, team1 and team2 can only play match1.
+- Violations of these results in an error and the edge is not created
+- for both node1 and node2, the general approach is to whitelist a set of schemas for the specified type of edge. It is still valid to add other types of edges from these nodes to others. 
+- The schema names in node1 and node2 fixes the schema types for this particular edge type. This means creating a relations "player1--(part_of)-->team1" or "team1--(part_of)-->player1" will result in the same relation "player1--(part_of)-->team1". 
+- You can also specify  nodes with different schema types as : "player,coach". 
+- If you want to allow nodes of all schema types, use "*." 
+  - Eg :
+    - Constraint:
+    - node 1: *
+    - edge label: interacts with
+    - node 2: * 
+- If you want to include all except for a few types of nodes, use : "* - schema1, schema2" 
+  - Eg :  "*-tag tagged_as tag" means that nodes of all types (except for tag nodes themselves) can be tagged with a tag.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beanbagdb",
-  "version": "0.5.54",
+  "version": "0.5.61",
   "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

@@ -344,6 +344,7 @@ export class BeanBagDB {
   async create(schema, data, meta = {}, settings = {}) {
     this._check_ready_to_use();
     if(!schema){throw new DocCreationError(`No schema provided`)}
+    if(schema=="setting_edge"){throw new DocCreationError("This type of record can only be created through the create_edge api")}
     if(Object.keys(data).length==0){throw new DocCreationError(`No data provided`)}
     try {
       let doc_obj = await this._insert_pre_checks(schema, data,meta, settings);
@@ -440,7 +441,6 @@ export class BeanBagDB {
  * - Retrieves the document based on the provided search criteria.
  * - Checks the revision ID to detect potential conflicts. (To be implemented: behavior when the `rev_id` does not match).
  * - Validates editable fields against `schema.settings.editable_fields` (or allows editing of all fields if not specified).
- * - Performs primary key conflict checks if multiple records are allowed (`single_record == false`).
  * - Encrypts fields if encryption is required by the schema settings.
  * - Updates the `meta` fields (such as `updated_on` and `updated_by`) and saves the updated document to the database.
  *
@@ -448,7 +448,7 @@ export class BeanBagDB {
  * @returns {Object} The result of the document update operation.
  *
  * **Errors**:
- * - Throws an error if a document with the same primary keys already exists (and `single_record == false`).
+ * - Throws an error if a document with the same primary keys already exists .
  * - Throws a `DocUpdateError` if a primary key conflict is detected during the update.
  * 
  * @throws {DocUpdateError} - If a document with conflicting primary keys already exists.
@@ -655,6 +655,119 @@ export class BeanBagDB {
     }
   }
 
+///////////////////////////////////////////////////////////
+//////////////// simple directed graph ////////////////////////
+//////////////////////////////////////////////////////////
+
+async create_edge(node1,node2,edge_name,edge_label=""){
+  this._check_ready_to_use();
+  if(!edge_name){throw new ValidationError("edge_name required")}
+  if(Object.keys(node1)==0){throw new ValidationError("node1 required")}
+  if(Object.keys(node2)==0){throw new ValidationError("node2 required")}
+ 
+  let n1 = await this.read(node1)
+  let n2 = await this.read(node2)
+  let edges_constraint
+
+  try {
+    let d  = await this.read({schema:"setting_edge_constraint",data:{name:edge_name}})
+    edges_constraint = d["doc"]["data"]
+    let errors = [] 
+    let node1id = n1.doc._id
+    let node2id = n2.doc._id
+    let val_check = this._check_nodes_edge(edges_constraint.node1,edges_constraint.node2,n1.doc.schema,n2.doc.schema)
+
+    if (val_check.valid){
+      if(val_check.swapped){
+        // swapping required
+        node1id = n2.doc._id
+        node2id = n1.doc._id
+      }
+    }else{
+      this.errors.push("Invalid nodes.This config of nodes not allowed")
+    }
+        
+    let records = await this.search({selector:{schema:"system_edge","data.edge_name":edge_name}})
+
+    if(edges_constraint.max_from_node1!=-1){
+      let filter1 = records.docs.filter((itm)=>itm.data.node1==node1id)
+      if(filter1.length>=edges_constraint.max_from_node1){
+        errors.push("max limit reached")
+      }
+    }
+
+    if(edges_constraint.max_to_node2!=-1){
+      let filter2 = records.docs.filter((itm)=>itm.data.node2==node2id)
+      if(filter1.length>=edges_constraint.max_from_node1){
+        errors.push("max limit reached")
+      }
+    }
+    
+    if(errors.length==0){
+      let edge = await this.create("system_edge",{node1: node1id , node2: node1id ,edge_name:edge_name })
+      return edge
+    }else{
+      throw new RelationError(errors)
+    }
+    
+  } catch (error) {
+    if(error instanceof DocNotFoundError){
+      let doc = {node1:"*",node2:"*",name:edge_name,label:edge_label}
+      let new_doc = await this.create("system_edge_constraint",doc) 
+      let edge = await this.create("system_edge",{node1: n1.doc._id,node2: n2.doc._id,edge_name:edge_name })
+      return edge
+    }else{
+      throw error
+    }  
+  }
+}
+
+_check_node_schema_match(rule, schema) {
+  /**
+   * Check if the schema matches the rule. The rule can be:
+   * - "*" for any schema
+   * - "*-n1,n2" for all schemas except n1 and n2
+   * - "specific_schema" or "schema1,schema2" for specific schema matches
+   */
+  if (rule === "*") {
+    return true;
+  }
+  
+  if (rule.startsWith("*-")) {
+    // Exclude the schemas listed after "*-"
+    const exclusions = rule.slice(2).split(",");
+    return !exclusions.includes(schema);
+  }
+  
+  // Otherwise, check if schema matches the specific rule (comma-separated for multiple allowed schemas)
+  const allowedSchemas = rule.split(",");
+  return allowedSchemas.includes(schema);
+}
+
+_check_nodes_edge(node1Rule, node2Rule, schema1, schema2) {
+  /**
+   * Check if the edge between schema1 (node1) and schema2 (node2) is valid based on the rules
+   * node1Rule and node2Rule. Also checks if the nodes should be swapped.
+   * 
+   */
+  // Check if schema1 matches node1Rule and if schema2 matches node2Rule
+  const matchesNode1 = this._check_node_schema_match(node1Rule, schema1);
+  const matchesNode2 = this._check_node_schema_match(node2Rule, schema2);
+  
+  // Check if schema1 matches node2Rule and schema2 matches node1Rule (for swapping condition)
+  const matchesSwappedNode1 = this._check_node_schema_match(node2Rule, schema1);
+  const matchesSwappedNode2 = this._check_node_schema_match(node1Rule, schema2);
+
+  // If the schemas match their respective rules (node1 and node2), the edge is valid
+  if (matchesNode1 && matchesNode2) { return { valid: true, swapped: false }}
+  
+  // If swapping makes it valid, indicate that the nodes should be swapped
+  if (matchesSwappedNode1 && matchesSwappedNode2) { return { valid: true, swapped: true }}
+  // Otherwise, the edge is invalid
+  return { valid: false, swapped: false };
+}
+
+
 ///////////////////////////////////////////////////////////
 //////////////// Internal methods ////////////////////////
 //////////////////////////////////////////////////////////
@@ -803,7 +916,10 @@ export class BeanBagDB {
     this.util_validate_data(schemaDoc.schema, data);
 
     // validate meta
-    this.util_validate_data(sys_sch.editable_metadata_schema, meta);
+    if(Object.keys.length>0){
+      this.util_validate_data(sys_sch.editable_metadata_schema, meta)
+    }
+    
 
     // duplicate meta.link check
     if (meta.link) {
@@ -1170,4 +1286,29 @@ constructor(errors=[]){
   this.name = "EncryptionError";
   this.errors = errors
 }
+}
+
+/**
+ * Custom error class for relation error.
+ * 
+ * @extends {Error}
+ */
+export class RelationError extends Error {
+  /**
+* 
+* @extends {Error}
+* @param {ErrorItem[]} [errors=[]] - An array of error objects, each containing details about validation failures.
+*/
+constructor(errors=[]){
+  let error_messages 
+    if(Array.isArray(errors)){
+      error_messages = errors.map(item=>` ${(item.instancePath||" ").replace("/","")} ${item.message} `)
+    }else {
+      error_messages = [errors]
+    }
+  let message = `Error in relation of the simple digraph : ${error_messages.join(",")}`
+  super(message)
+  this.name = "RelationError";
+  this.errors = errors
+}
 }

package/src/system_schema.js

@@ -2,7 +2,7 @@ export const schema_schema = {
   name: "schema",
   description:"Meta-schema or the schema for defining other schemas",
   system_generated:true,
-  version:0.5,
+  version:0.56,
   schema: {
     type: "object",
     additionalProperties: false,
@@ -68,12 +68,6 @@ export const schema_schema = {
             },
             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",
-            default: false,
-            description:
-              "If set, only a single records with this schema will be allowed to insert in the database",
           }
         },
         required :["primary_keys","non_editable_fields","encrypted_fields"]
@@ -83,7 +77,7 @@ export const schema_schema = {
   },
   settings: {
     primary_keys: ["name"],
-    editable_fields: ["schema", "settings","description"],
+    non_editable_fields:[],
     encrypted_fields:[]
   },
 };
@@ -91,9 +85,9 @@ export const schema_schema = {
 export const system_schemas = {
   keys: {
     system_generated:true,
-    version:0.5,
+    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_keys",
+    name: "system_key",
     schema: {
       type: "object",
       additionalProperties: true,
@@ -116,22 +110,20 @@ export const system_schemas = {
           type: "string",
           minLength: 1,
           maxLength: 5000,
-          pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
         },
       },
     },
     settings: {
       primary_keys: ["name"],
       encrypted_fields:["value"],
-      non_editable_fields:[],
-      single_record: false
+      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_settings",
+    name: "system_setting",
     schema: {
       required:["name","value"],
       type: "object",
@@ -157,44 +149,124 @@ export const system_schemas = {
     settings: {
       primary_keys: ["name"],
       non_editable_fields: ["name"],
-      encrypted_fields:[],
-      single_record:false
+      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,
+        }
+      }
+    },
+    settings: {
+      primary_keys: ["name"],
+      non_editable_fields:["name"],
+      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",
+        }
+      }
+    },
+    settings: {
+      primary_keys: ["node1","node2","edge_type"],
+      non_editable_fields:["edge_type"],
+      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"
+          }
+        },
+        caption: {
+          type: "string",
+        },
+        source:{
+          type: "string",
+        }
+      }
+    },
+    settings: {
+      primary_keys: ["caption"],
+      non_editable_fields:[],
+      encrypted_fields:[]
     },
   }
-  // ,
-  // edges:{
-  //   name:"edges",
-  //   description:"To relate one document to another.Labels can be configured using the db_network setting document.This stores edges of a simple directed graph",
-  //   schema:{
-  //     required:["graph","node1","node2","label"],
-  //     type:"object",
-  //     additionalProperties: false,
-  //     properties : {
-  //       graph:{
-  //         type:"string",
-  //         minLength:3,
-  //         default:"default",
-  //         maxLength:100,
-  //         description:"Name of the graph in which this edge is being added. This is managed by the db_network setting "
-  //       },
-  //       node1:{
-  //         type:"string",
-  //         description:"the source of this directed edge. this must be a valid document id."
-  //       }
-  //     }
-  //   },
-  //   settings :{
-  //     primary_key:["graph","node1","node2","label"],
-  //     non_editable_fields:["node1","node2","graph"],
-  //     encrypted_fields:[],
-  //     single_record:false
-  //   }
-  // }
 };
 
 // this is not stored in the DB. only for validating the metadata during doc update
 export const editable_metadata_schema = {
   additionalProperties: false,
+  type:"object",
   properties:{
     tags:{
       type:"array",

package/test/edges.test.js

@@ -0,0 +1,313 @@
+// to test database operations. assuming the class is initialized successfully
+// to test initialization of the BeanBagDB class
+import { get_pdb_doc } from "./pouchdb.js";
+import assert, { throws, strictEqual, rejects } from "assert";
+import {
+  BeanBagDB,
+  DocCreationError,
+  EncryptionError,
+  ValidationError,
+  DocNotFoundError,
+  DocUpdateError,
+} from "../src/index.js";
+
+import * as chai from "chai";
+import chaiAsPromised from "chai-as-promised";
+
+chai.use(chaiAsPromised);
+
+// Then either:
+const expect = chai.expect;
+
+let database; // this is the global db object
+
+describe("Edge constraint insertion tests", async () => {
+  const constraint_docs_invalid = [
+    [
+      "error when node1 empty",
+      {
+        node1: "",
+        node2: "*",
+        name: "sample",
+        label: "Sample",
+      },
+    ],
+    [
+      "error when node2 empty ",
+      {
+        node1: "*",
+        node2: "",
+        name: "sample",
+        label: "Sample",
+      },
+    ],
+    [
+      "error when edge name empty",
+      {
+        node1: "*",
+        node2: "*",
+        name: "",
+        label: "Sample",
+      },
+    ],
+    [
+      "error when node 1 invalid 1",
+      {
+        node1: "*3434",
+        node2: "*",
+        name: "sample",
+        label: "Sample",
+      },
+    ],
+    [
+      "error when node 1 invalid 2",
+      {
+        node1: "1212121 ssd sdsd",
+        node2: "*",
+        name: "sample",
+        label: "Sample",
+      },
+    ],
+    [
+      "error when node 1 invalid 3",
+      {
+        node1: "sample1-sample2",
+        node2: "*",
+        name: "sample",
+        label: "Sample",
+      },
+    ],
+    [
+      "error when node 1 invalid 4",
+      {
+        node1: "*+sample1-sample2",
+        node2: "*",
+        name: "sample",
+        label: "Sample",
+      },
+    ],
+    [
+      "error when edge name is invalid",
+      {
+        node1: "*",
+        node2: "*",
+        name: "Sample one",
+        label: "Sample",
+      },
+    ],
+  ];
+
+  before(async () => {
+    // adding a schema
+    let doc_obj = get_pdb_doc("test_database_41", "qwe33rtyuiopaqwsde1254");
+    database = new BeanBagDB(doc_obj);
+    await database.ready(); // Ensure the database is ready before running tests
+    try {
+      //console.log(test_schema)
+      //let a = await database.create("schema",test_schema)
+      //console.log("Ready for more tests...");
+    } catch (error) {
+      console.log("error in before");
+      console.log(error);
+    }
+  });
+
+  constraint_docs_invalid.forEach((element, index) => {
+    it(`${element[0]}`, async () => {
+      await rejects(async () => {
+        await database.create("setting_edge_constraint", element[1]);
+      }, DocCreationError);
+    });
+  });
+});
+
+describe("Edge insertion test", async () => {
+  // it('read docs', async () => {
+  //   try {
+  //     let udata = await database3.search({selector:{"schema":"book"}})
+  //     assert(udata.docs.length==2)
+  //   } catch (error) {
+  //     //console.log(error)
+  //     throw error
+  //   }
+  // })
+
+  const edge_docs_invalid = [
+    [
+      "error when  invalid node 1",
+      {
+        node1: "sample",
+        node2: "*",
+        name: "does not matter",
+        
+      },
+    ],
+    [
+      "error when node 2 invalid ",
+      {
+        node1: { link: "does_not_exists" },
+        node2: "invalid,must be a criteria obj",
+        name: "sample",
+      },
+    ],
+
+    [
+      "error when edge name invalid",
+      {
+        node1: { link: "sample1" },
+        node2: { link: "sample2" },
+        name: "sample",
+        
+      },
+    ],
+    [
+      "error when both nodes are same",
+      {
+        node1: {},
+        node2: "*",
+        name: "Sample one"
+      },
+    ],
+  ];
+
+  before(async () => {
+    // adding a schema
+    let doc_obj = get_pdb_doc("test_database_41", "qwe33rtyuiopaqwsde1254");
+    database = new BeanBagDB(doc_obj);
+    await database.ready(); // Ensure the database is ready before running tests
+    try {
+      let schemas = [
+        {
+          name: "player",
+          description:"Player",
+          schema: {
+            additionalProperties:true,
+            type:"object",
+            properties: {
+              name: {
+                type: "string",
+              },
+            },
+          },
+          settings: {
+            primary_keys: ["name"],
+            encrypted_fields: [],
+            non_editable_fields: ["name"],
+          },
+        },
+        {
+          name: "team",
+          description:"Team",
+          schema: {
+            additionalProperties:true,
+            type:"object",
+            properties: {
+              name: {
+                type: "string",
+              },
+            },
+          },
+          settings: {
+            primary_keys: ["name"],
+            encrypted_fields: [],
+            non_editable_fields: ["name"],
+          },
+        },
+        {
+          name: "match",
+          description:"Match",
+          schema: {
+            type:"object",
+            additionalProperties:true,
+            properties: {
+              name: {
+                type: "string",
+              },
+            },
+          },
+          settings: {
+            primary_keys: ["name"],
+            encrypted_fields: [],
+            non_editable_fields: ["name"],
+          },
+        },
+      ];
+      for (let index = 0; index < schemas.length; index++) {
+        try {
+          const element = schemas[index];
+          await database.create("schema", element);  
+        } catch (error) {
+          console.log("not heeee")
+          console.log(error)
+        }
+        
+      }
+      const records = [
+        ["player", { name: "player1" }],
+        ["player", { name: "player2" }],
+        ["player", { name: "player3" }],
+        ["player", { name: "player4" }],
+        ["player", { name: "player5" }],
+        ["player", { name: "player6" }],
+        ["player", { name: "player7" }],
+        ["player", { name: "player8" }],
+        ["player", { name: "player9" }],
+        ["player", { name: "player10" }],
+        ["player", { name: "player11" }],
+        ["player", { name: "player12" }],
+        ["player", { name: "player13" }],
+        ["player", { name: "player14" }],
+        ["player", { name: "player15" }],
+        ["team", { name: "team1" }],
+        ["team", { name: "team2" }],
+        ["match", { name: "match1" }],
+        ["match", { name: "match2" }],
+        ["system_edge_constraint",{ name:"part_of",node1:"player",node2:"team", max_from_node1:1, max_to_node2:5 , label:"is part of "}],
+        ["system_edge_constraint",{name: "plays",node1:"team",node2:"match",max_from_node1 : 1, max_to_node2: 2 , label:"plays in" }]
+      ];
+      for (let index = 0; index < records.length; index++) {
+        const element = records[index];
+        let data1 = element[1];
+        await database.create(element[0], data1, { link: data1.name });
+      }
+    } catch (error) {
+      console.log("error in before....");
+      console.log(error);
+    }
+  });
+
+  edge_docs_invalid.forEach((element, index) => {
+    it(`${element[0]}`, async () => {
+      await rejects(async () => {
+        await database.create("setting_edge", element[1]);
+      }, DocCreationError);
+    });
+  });
+
+
+  let valid_edges = [
+    {node1:{link:"player1"},node2:{link:"team1"},edge_name:"part_of"},
+    {node1:{link:"player2"},node2:{link:"team1"},edge_name:"part_of"},
+    {node1:{link:"player3"},node2:{link:"team1"},edge_name:"part_of"},
+    {node1:{link:"player4"},node2:{link:"team1"},edge_name:"part_of"},
+    {node1:{link:"player5"},node2:{link:"team1"},edge_name:"part_of"},
+    {node1:{link:"player6"},node2:{link:"team2"},edge_name:"part_of"},
+    {node1:{link:"player7"},node2:{link:"team2"},edge_name:"part_of"}
+  ]
+
+  valid_edges.forEach((element, index) => {
+    it(`adds an edge`, async () => {
+      try {
+        let edge = await database.create_edge(element.node1,element.node2,element.name)  
+        console.log(edge)
+      } catch (error) {
+        console.log(error)
+      }
+      
+    });
+  });
+
+
+
+
+});

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==8)
+        assert(udata.docs.length==11)
       } 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==4) // schema,book,setting,key
+      assert(udata.docs.length==7) // schema,book,setting,key,edge,edge_constraints
     } catch (error) {
       //console.log(error)
       throw error

package/test/plugin.test.js

@@ -19,15 +19,12 @@ let database; // this is the global db object
 
 describe("Testing plugin load", async () => {
   
-
   before(async () => {
     let doc_obj = get_pdb_doc("test_database_30", "qwertyuiopaqwsde1254");
     database = new BeanBagDB(doc_obj);
     await database.ready(); // Ensure the database is ready before running tests
     console.log("Ready for more tests...");
   });
-  
-   
 
   it('successfully loads the plugin', async () => {
     try {
@@ -41,10 +38,10 @@ describe("Testing plugin load", async () => {
 
   it('successfully runs the loaded the plugin method', async () => {
     try {
-      
-      let command = await database["txtcmd"].parse("new/system_keys")
-      console.log(command)
-      assert (1 ==2) 
+      //await database.load_plugin("txtcmd",text_command)
+      let command = await database.plugins["txtcmd"].parse("new/system_keys")
+      //console.log(command)
+      assert (command.valid ==true) 
     } catch (error) {
       console.log(error)
       throw error