beanbagdb 0.5.53 → 0.5.60

package/src/system_schema.js

@@ -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.52,
     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,
@@ -123,15 +117,14 @@ export const system_schemas = {
     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,39 +150,115 @@ 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",
+        },
+        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

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

@@ -0,0 +1,52 @@
+// 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 {text_command} from "../src/plugins/text_command.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("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 {
+      await database.load_plugin("txtcmd",text_command)
+      chai.expect(database.plugins).to.not.be.empty
+    } catch (error) {
+      console.log(error)
+      throw error
+    }
+  })
+
+  it('successfully runs the loaded the plugin method', async () => {
+    try {
+      //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
+    }
+  })
+});
+
+