beanbagdb 0.5.43 → 0.5.45

package/src/system_schema.js

@@ -0,0 +1,180 @@
+export 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"],
+  },
+};
+
+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,
+    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
+export const editable_metadata_schema = {
+  additionalProperties: false,
+  properties:{
+    tags:{
+      type:"array",
+      items:{type:"string"},
+      default:[],
+      maxItems: 40,
+    }
+  }
+}

package/test/init.test.js

@@ -0,0 +1,231 @@
+// 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 = {};
+
+import { throws, strictEqual } from "assert";
+
+ 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"],
+  ["utils", {}],
+  ["api", {}],
+];
+const test_obj = { name: "bla", encryption_key: "1234567890opuityerqwas" };
+const full_util = {util: { encrypt: () => {}, decrypt: () => {}, ping: () => {} , validate_schema:()=>{}},}
+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: () => {}, validate_schema:()=>{} } },
+  ],
+  [
+    "util.decrypt missing",
+    { ...test_obj, ...full_api, util: { encrypt: () => {}, ping: () => {}, validate_schema:()=>{} } },
+  ],
+  [
+    "util.validate_schema missing",
+    { ...test_obj, ...full_api, util: { encrypt: () => {}, ping: () => {}, decrypt: () => {} } },
+  ],
+  [
+    "util.ping missing",
+    {
+      ...test_obj,
+      ...full_api,
+      util: { encrypt: () => {}, decrypt: () => {} ,validate_schema:()=>{}},
+    },
+  ],
+];
+
+let database;
+
+describe("Tests initialization of the BeanBagDB class without no init object", async () => {
+  it("Throws error", () => {
+    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", () => {
+    throws(() => {
+      database = new BeanBagDB({});
+    }, Error);
+  });
+  it("some invalid field throws error", () => {
+    throws(() => {
+      database = new BeanBagDB({ dbname: "sample" });
+    }, Error);
+  });
+  test_set1.forEach((item) => {
+    it(`only ${item[0]} throws error`, () => {
+      throws(() => {
+        let key = item[0];
+        database = new BeanBagDB({ key: item[1] });
+      }, Error);
+    });
+  });
+  test_set_api.forEach((item) => {
+    it(`${item[0]} throws error`, () => {
+      throws(() => {
+        let obj = { ...item[1] };
+        database = new BeanBagDB(obj);
+      }, Error);
+    });
+  });
+});
+
+describe("Successful database class init", async () => {
+  it("global database variable not yet initialized", () => {
+    strictEqual(
+      database instanceof BeanBagDB,
+      false,
+      "The variable is not yet initialized"
+    );
+  });
+
+  it("DB init successful", () => {
+    database = new BeanBagDB(doc_obj);
+    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

@@ -0,0 +1,157 @@
+// // require("dotenv").config();
+// import 'dotenv/config'
+// // import * as cbbdb from "../src/couchdb.js"
+// // const cbbdb = require("../src/couchdb.js");
+// // const pbbdb = require("../src/pouchdb.js");
+// import BeanBagDB_PouchDB from "../src/pouchdb.js";
+// import BeanBagDB_CouchDB from "../src/couchdb.js";
+// // const pl1  = require("./helper.js")
+
+// (async()=>{
+//   // console.log(process.env.cdburl)
+//   let db = new BeanBagDB_CouchDB(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 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
+//     }
+//   }
+// }
+
+
+// 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)
+// // })();