beanbagdb 0.5.50 → 0.5.52

package/src/system_schema.js

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

package/test/couch_connect.js

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

package/test/couchdb.js

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

package/test/init.test.js

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

package/test/operations.test.js

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

package/test/pouchdb.js

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

package/test/test1.js

@@ -158,21 +158,20 @@
 
 import { get_pdb_doc } from './pouchdb.js';
 import { throws, strictEqual } from "assert";
-import BeanBagDB  from '../src/index.js';
+import {BeanBagDB}  from '../src/index.js';
 
 (async()=>{
+
   let schema_docs_invalid = [
     {
-     "name":"",
-     "description":"",
-     "schema":{},
-     "settings":{} 
+      name: "",
+      description: "",
+      schema: {},
+      settings: {},
     }
-    
     ]
   let doc_obj = get_pdb_doc("test_database_26","qwertyuiopaqwsde1254")
   let database = new BeanBagDB(doc_obj);
-  database.initialize_db()
-  database.ready()
-  let a = await database.insert("schema",schema_docs_invalid[0])
+  await database.ready()
+  let a = await database.create("schema",schema_docs_invalid[0])
 })()