beanbagdb 0.0.1 → 0.5.1

package/src/system_schema.js

@@ -0,0 +1,184 @@
+const schema_schema = {
+  name: "schema",
+  description:"Meta-schema or schema for defining other schemas",
+  system_generated:true,
+  schema: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      system_generated:{
+        type:"boolean",
+        default:false
+      },
+      name: {
+        type: "string",
+        minLength: 5,
+        maxLength: 50,
+        pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
+      },
+      description:{
+        type:"string",
+        minLength:1,
+        maxLength:1000
+      },
+      schema: {
+        type: "object",
+        additionalProperties: true,
+        minProperties: 1,
+        maxProperties: 50,
+      },
+      settings: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          primary_keys: {
+            type: "array",
+            default: [],
+            items: {
+              type: "string",
+            },
+            maxItems: 10,
+          },
+          editable_fields: {
+            type: "array",
+            default: [],
+            items: {
+              type: "string",
+            },
+            maxItems: 20,
+          },
+          encrypted_fields: {
+            type: "array",
+            default: [],
+            items: {
+              type: "string",
+            },
+            maxItems: 10,
+          },
+          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: ["name","description","schema", "settings"],
+  },
+  settings: {
+    primary_key: ["name"],
+    editable_fields: ["schema", "settings"],
+  },
+};
+
+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,
+    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: {
+      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,
+          pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
+        },
+      },
+    },
+    settings: {
+      primary_keys: ["name"],
+      encrypted_fields:["value"]
+    },
+  },
+  settings: {
+    system_generated:true,
+    description:"The system relies on these settings for proper functioning or enabling optional features.",
+    name: "system_settings",
+    schema: {
+      required:["name","value"],
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        name: {
+          type: "string",
+          minLength: 5,
+          maxLength: 250,
+          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",
+        },
+      },
+    },
+    settings: {
+      primary_keys: ["name"],
+      editable_fields: ["value"],
+    },
+  },
+};
+
+// this is not stored in the DB. only for validating the metadata during doc update
+const editable_metadata_schema = {
+  additionalProperties: false,
+  properties:{
+    tags:{
+      type:"array",
+      items:{type:"string"},
+      default:[],
+      maxItems: 40,
+    }
+  }
+}
+
+module.exports.system_schemas = system_schemas;
+module.exports.schema_schema = schema_schema;
+module.exports.editable_metadata_schema = editable_metadata_schema;

package/test/helper.js

@@ -0,0 +1,12 @@
+// helper file for testing 
+
+async function on_load(db){
+  console.log(db.name)
+  console.log("loading...done")
+}
+
+let print = async (db,msg)=>{
+  console.log(msg)
+}
+
+module.exports = {on_load,print}

package/test/init.test.js

@@ -0,0 +1,219 @@
+// to test initialization of the BeanBagDB class. using in memory pouch db for testing to avoid additional setup.
+const PouchDB = require("pouchdb");
+PouchDB.plugin(require("pouchdb-find"));
+const crypto = require('crypto');
+const db_name = "test_database_24"
+const pdb = new PouchDB(db_name);
+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 = 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
+    },
+  },
+}
+
+the_correct_object = {};
+
+const assert = require("assert");
+
+const BeanBagDB = require("../src/index");
+
+/**
+ * Initial setup
+ * database is the global var where the beanbag class is initialized
+ */
+const test_set1 = [
+  ["name", "sample"],
+  ["encryption_key", "sample_key"],
+  ["utils", {}],
+  ["api", {}],
+];
+const test_obj = { name: "bla", encryption_key: "1234567890opuityerqwas" };
+const full_util = {util: { encrypt: () => {}, decrypt: () => {}, ping: () => {} },}
+const full_api = {api: { update: () => {}, delete: () => {}, get: () => {}, search: () => {}, createIndex: () => {}}}
+const test_set_api = [
+  [
+    "api.insert missing",
+    {
+      ...test_obj,
+      ...full_util,
+      api: {update: () => {}, delete: () => {}, get: () => {}, search: () => {}, createIndex: () => {}},
+    },
+  ],
+  [
+    "api.update missing",
+    {
+      ...test_obj,
+      ...full_util,
+      api: {insert: () => {}, delete: () => {}, get: () => {},search: () => {},createIndex: () => {}},
+    },
+  ],
+  [
+    "api.delete missing",
+    {
+      ...test_obj,
+      ...full_util,
+      api: { insert: () => {}, update: () => {}, get: () => {}, search: () => {}, createIndex: () => {}},
+    },
+  ],
+  [
+    "api.get missing",
+    {
+      ...test_obj,
+      ...full_util,
+      api: { insert: () => {}, update: () => {}, delete: () => {}, search: () => {}, createIndex: () => {}}
+    },
+  ],
+  [
+    "api.search missing",
+    {
+      ...test_obj,
+      ...full_util,
+      api: { insert: () => {}, update: () => {}, delete: () => {}, get: () => {}, createIndex: () => {}}
+    },
+  ],
+  [
+    "api.createIndex missing",
+    {
+      ...test_obj,
+      ...full_util,
+      api: { insert: () => {}, update: () => {}, delete: () => {}, get: () => {}, search: () => {}},
+    },
+  ],
+  [
+    "util.encrypt missing",
+    { ...test_obj, ...full_api, util: { decrypt: () => {}, ping: () => {} } },
+  ],
+  [
+    "util.decrypt missing",
+    { ...test_obj, ...full_api, util: { encrypt: () => {}, ping: () => {} } },
+  ],
+  [
+    "util.ping missing",
+    {
+      ...test_obj,
+      ...full_api,
+      util: { encrypt: () => {}, decrypt: () => {} },
+    },
+  ],
+];
+
+let database;
+
+describe("Tests initialization of the BeanBagDB class without no init object", async () => {
+  it("Throws error", () => {
+    assert.throws(() => {
+      database = new BeanBagDB();
+    }, Error);
+  });
+});
+
+describe("Tests initialization of the BeanBagDB class with incomplete init object", async () => {
+  /*
+   * Proper object : {name,encryption_key,api:{insert,updated,delete,search,get,createIndex},utils:{encrypt,decrypt,ping}}
+   */
+  it("Blank object throw error", () => {
+    assert.throws(() => {
+      database = new BeanBagDB({});
+    }, Error);
+  });
+  it("some invalid field throws error", () => {
+    assert.throws(() => {
+      database = new BeanBagDB({ dbname: "sample" });
+    }, Error);
+  });
+  test_set1.forEach((item) => {
+    it(`only ${item[0]} throws error`, () => {
+      assert.throws(() => {
+        let key = item[0];
+        database = new BeanBagDB({ key: item[1] });
+      }, Error);
+    });
+  });
+  test_set_api.forEach((item) => {
+    it(`${item[0]} throws error`, () => {
+      assert.throws(() => {
+        let obj = { ...item[1] };
+        database = new BeanBagDB(obj);
+      }, Error);
+    });
+  });
+});
+
+describe("Successful database class init", async () => {
+  it("global database variable not yet initialized", () => {
+    assert.strictEqual(
+      database instanceof BeanBagDB,
+      false,
+      "The variable is not yet initialized"
+    );
+  });
+
+  it("DB init successful", () => {
+    database = new BeanBagDB(doc_obj);
+    assert.strictEqual(
+      database instanceof BeanBagDB,
+      true,
+      "The variable is initialized successfully"
+    );
+  });
+});
+
+/**
+ * process is : create a new obj with all required inputs, run ready() , then initialize_db , then ready to perform operations
+ *
+ * to test:
+ * - no object
+ * - incomplete objects and inner objects
+ * - good example
+ *
+ * initialized by ready not called ,
+ */

package/test/operations.test.js

@@ -0,0 +1 @@
+// to test database operations. assuming the class is initialized successfully 

package/test/test1.js

@@ -1,37 +1,140 @@
-require('dotenv').config()
-console.log(process.env)
-const SDB = require("../index.js")
-const cdb = require("nano")(process.env.cdburl)
-const doc_obj = {
-  name: process.env.cdbname,
-  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
-    },
-    get: async (id)=>{
-      const data = await cdb.get(id)
-      return data
-    },
-    createIndex: async (filter)=>{
-      const data = await cdb.createIndex(filter)
-      return data
+require("dotenv").config();
+const cbbdb = require("../src/couchdb.js");
+const pbbdb = require("../src/pouchdb.js");
+const pl1  = require("./helper.js")
+async function main1() {
+  let db = new cbbdb(process.env.cdburl, process.env.cdbname, "sample_key");
+  
+  try {
+    await db.ready();
+    await db.initialize_db();
+    await db.update_indexes()
+  } catch (error) {
+    console.log(error);
+  }
+}
+
+async function main2() {
+  let db = new cbbdb(process.env.cdburl, process.env.cdbname, "sample_key");
+  await db.ready();
+  // await db.update_indexes()
+  sample_setting_docs = [
+    {
+      name: "sample1",
+      value: "sample thing here",
+    },
+    {
+      name: "no_value",
+    },
+    {
+      value: "incorrect name",
+    },
+    {
+      name: "sample1",
+      value: "sample thing here",
+    },
+    {
+      name: "sample1",
+      value: "primary key check",
+    },
+    {
+      name: "Sample2",
+      value: "normal insert",
+    },
+    {
+      value: "No name provided",
+    },
+  ];
+  let t = sample_setting_docs.length
+  for (let i = 0; i < t; i++) {
+    try {
+      let newid =  await db.insert("system_settings",sample_setting_docs[i])
+      console.log(newid)
+    } catch (error) {
+      console.log("Error "+i)
+      console.error(error)
+      continue
+    }
+  }
+}
+
+async function main3() {
+  let db = new cbbdb(process.env.cdburl, process.env.cdbname, "sample_key");
+  await db.ready();
+  // await db.update_indexes()
+  sample_setting_docs = [
+    {
+      name: "sample1",
+      value: "sample thing here",
+    },
+    {
+      name: "sample2",
+      value: "sample thing here again",
+    },
+   
+    {
+      name: "sample1",
+      value: "sample thing here again",
+    },
+  ];
+  let t = sample_setting_docs.length
+  for (let i = 0; i < t; i++) {
+    try {
+      let newid =  await db.insert("system_keys",sample_setting_docs[i])
+      console.log(newid)
+    } catch (error) {
+      console.log("Error "+i)
+      console.error(error)
+      continue
     }
   }
 }
 
-let db = new SDB.InfoDB(doc_obj)
-try {
-  db.initialize_db()
-} catch (error) {
-  console.log(error)
+
+async function main4(){
+  let db = new cbbdb(process.env.cdburl, process.env.cdbname, "sample_key");
+  await db.ready();
+  let doc1 = await db.get("e94b5eebe6b3c6dab8e2508d5908717c")
+  console.log(doc1)
+  let doc2 = await db.get_doc("system_keys",{"name":"sample2"})
+  console.log(doc2)
+  let doc3 = await db.get_doc("system_logs")
+  console.log(doc3)
+}
+
+async function main5(){
+  let db = new cbbdb(process.env.cdburl, process.env.cdbname, "sample_key");
+  await db.ready();
+  let id = "e94b5eebe6b3c6dab8e2508d5908717c"
+  let rec_1 = await db.get(id)
+  let rec1 = rec_1.doc
+  console.log(rec1)
+  let rec1u = await db.update(id,"",{data:{"value":"secret key updated"},meta:{tags:["testing1","testing2","money"]}})
+  console.log(rec1u)
+  let r1 = await db.get(id)
+  console.log(r1)
+}
+
+async function main6(){
+  let db = new pbbdb(process.env.cdburl, process.env.cdbname, "sample_key");
+  await db.ready()
+  //await db.initialize_db()
+
 }
+
+// main1().then(() => {console.log("Bye.");}).catch();
+
+// main3().then(() => {console.log("Bye.");}).catch();
+
+// main4().then(() => {console.log("Bye.");}).catch();
+
+// main5().then(() => {console.log("Bye.");}).catch();
+
+// main6().then(() => {console.log("Bye.");}).catch();
+
+
+(async ()=>{
+  let db = new cbbdb(process.env.cdburl, process.env.cdbname, "sample_key");
+  await db.ready();
+  db.load_plugin("sample",pl1)
+})();

package/couchdb.js

@@ -1,35 +0,0 @@
-const SDB = require("./index.js")
-class InfoDB_CouchDB extends SDB.InfoDB {
-  constructor(db_url,db_name){
-    const cdb = require("nano")(db_url)
-    const doc_obj = {
-      name: db_name,
-      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
-        },
-        get: async (id)=>{
-          const data = await cdb.get(id)
-          return data
-        },
-        createIndex: async (filter)=>{
-          const data = await cdb.createIndex(filter)
-          return data
-        }
-      }
-    }
-    super(doc_obj)
-  }
-}
-
-module.exports = InfoDB_CouchDB