beanbagdb 0.5.46 → 0.5.51

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,22 +11,31 @@ 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,
         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",
-        minLength:1,
-        maxLength:1000
+        minLength:0,
+        maxLength:1000,
+        description:"A small description of what  data in this schema stores."
       },
       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/",
       },
       settings: {
         type: "object",
@@ -38,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",
@@ -54,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",
@@ -62,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"],
@@ -73,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: {
@@ -126,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",
@@ -141,27 +139,25 @@ 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
     },
   },
 };

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,83 +1,13 @@
-// to test initialization of the BeanBagDB class. using in memory pouch db for testing to avoid additional setup.
-import PouchDB from 'pouchdb';
-import pouchdbFind from 'pouchdb-find';
-PouchDB.plugin(pouchdbFind)
-import { scryptSync, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
-const db_name = "test_database_24"
-const pdb = new PouchDB(db_name);
-import Ajv  from 'ajv';
-
-const doc_obj = {
-  name: db_name,
-  encryption_key: "qwertyuiopaqwsde1254",
-  api: {
-    insert: async (doc) => {
-      const result = await pdb.post(doc);
-      return result;
-    },
-    // delete: ()=>{db1.destroy},
-    update: async (doc) => {
-      const result = await pdb.put(doc);
-      return result;
-    },
-    search: async (query) => {
-      const results = await pdb.find(query);
-      return results; // of the form {docs:[],...}
-    },
-    get: async (id) => {
-      const data = await pdb.get(id);
-      return data;
-    },
-    delete: async (id) => {
-      const doc = await pdb.get(id);
-      const resp = await pdb.remove(doc);
-      return resp;
-    },
-    createIndex: async (filter) => {
-      const data = await pdb.createIndex(filter);
-      return data;
-    },
-  },
-  utils: {
-    encrypt: (text, encryptionKey) => {
-      const key = scryptSync(encryptionKey, "salt", 32); // Derive a 256-bit key
-      const iv = randomBytes(16); // Initialization vector
-      const cipher = 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 = scryptSync(encryptionKey, "salt", 32); // Derive a 256-bit key
-      const [iv, encrypted] = encryptedText
-        .split(":")
-        .map((part) => Buffer.from(part, "hex"));
-      const decipher = 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}
-    }
-  },
-}
-
-let the_correct_object = {};
-
+// 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
  * database is the global var where the beanbag class is initialized
  */
+
 const test_set1 = [
   ["name", "sample"],
   ["encryption_key", "sample_key"],
@@ -210,6 +140,7 @@ describe("Successful database class init", async () => {
   });
 
   it("DB init successful", () => {
+    let doc_obj = get_pdb_doc("test_database_24","qwertyuiopaqwsde1254")
     database = new BeanBagDB(doc_obj);
     strictEqual(
       database instanceof BeanBagDB,

package/test/operations.test.js

@@ -1 +1,327 @@
-// to test database operations. assuming the class is initialized successfully 
+// 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 { throws, strictEqual,rejects } from "assert";
+import {BeanBagDB,ValidationError}  from '../src/index.js';
+
+let database   // this is the global db object
+
+describe("Successful database class init (required for further testing) ", async () => {
+  it("DB init successful", () => {
+    let doc_obj = get_pdb_doc("test_database_25","qwertyuiopaqwsde1254")
+    database = new BeanBagDB(doc_obj);
+    strictEqual(
+      database instanceof BeanBagDB,
+      true,
+      "The variable is initialized successfully"
+    );
+  });
+});
+
+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",
+      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: {
+        "type":"object",
+        "properties":"something"
+      },
+      settings: {},
+    }],
+    ["schema.properties are missing/blank object",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{}
+      },
+      settings: {},
+    }],
+    ["schema.additionalProperties is missing",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}}
+      },
+      settings: {},
+    }],
+    ["schema.additionalProperties is invalid",
+      {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}},
+        "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: {
+    //     "type":"object",
+    //     "properties":{"name":{"type":"string"}},
+    //     "additionalProperties":true
+    //   },
+    //   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"]
+      },
+    }]
+  ];
+
+
+  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[1]);
+        },
+        ValidationError
+      );
+    });
+  });  
+  
+});
+