beanbagdb 0.5.45 → 0.5.50

package/.github/workflows/deploy_docs.yml

@@ -0,0 +1,38 @@
+name: Generate and Deploy JSDoc
+
+on:
+  push:
+    branches:
+      - release
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+jobs:
+  # Single deploy job since we're just deploying
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+      - name: Install dependencies
+        run: npm install
+      - name: Generate JSDoc
+        run: npx jsdoc -c jsdoc.json
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          # Upload entire repository
+          path: './docs-static'
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

package/.github/workflows/release.yml

@@ -4,7 +4,7 @@ name: Release npm Package
 on:
   push:
     branches:
-      - main
+      - release
 
 jobs:
   build:
@@ -30,8 +30,8 @@ jobs:
       run: npm install
 
     # Step 4: Run tests
-    # - name: Run tests
-    #   run: npm test
+    - name: Run tests
+      run: npm test
 
     # Step 5: Publish to npm if tests pass
     - name: Publish to npm

package/.github/workflows/test_on_master.yml

@@ -0,0 +1,36 @@
+name: Test code on master
+
+# Trigger the workflow on push to the "main" branch
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+    # Step 1: Check out the code from the repository
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    # Step 2: Set up Node.js environment
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.17.0'  
+        cache: 'npm'         
+        registry-url: 'https://registry.npmjs.org'
+
+    # Step 3: Install dependencies
+    - name: Install dependencies
+      run: npm install
+
+    # Step 4: Run tests
+    - name: Run tests
+      run: npm test
+
+

package/index.md

@@ -0,0 +1 @@
+This is where i write the documentation 

package/jsdoc.json

@@ -0,0 +1,21 @@
+{
+  "source": {
+    "include": ["src"],    
+    "includePattern": ".+\\.js(doc|x)?$",
+    "excludePattern": "(^|\\/|\\\\)_"
+  },
+  "opts": {
+    "destination": "./docs-static",  
+    "recurse": true,
+    "readme":"./index.md",
+    "tutorials": "./docs"
+  },
+  "plugins": [
+    "plugins/markdown"  
+  ],
+  "templates": {
+    "default": {
+      "outputSourceFiles": false
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beanbagdb",
-  "version": "0.5.45",
+  "version": "0.5.50",
   "description": "A JS library to introduce a schema layer to a No-SQL local database",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -29,6 +29,7 @@
     "ajv": "^8.17.1",
     "chai": "^5.1.1",
     "dotenv": "^16.4.5",
+    "jsdoc": "^4.0.3",
     "mocha": "^10.7.3",
     "nano": "^10.1.4",
     "pouchdb": "^9.0.0",

package/src/index.js

@@ -158,6 +158,39 @@ class BeanBagDB {
     }
   }
 
+  validate_schema_object(schema_doc){
+    let errors = []
+    if(!schema_doc["schema"]["type"]){
+      errors.push("Schema must have the field schema.'type' which can only be 'object' ")
+    }else{
+      if(schema_doc["schema"]["type"]!="object"){
+        errors.push("The schema.'type' value  is invalid.Only 'object' allowed")
+      }
+    }
+    if(!schema_doc["schema"]["properties"]){
+      errors.push("The schema.'properties' object does not exists")
+    }else{
+      if(typeof(schema_doc["schema"]["properties"])!="object"){
+        errors.push("Invalid schema.properties. It must be an object and must have atleast one field inside.")
+      }
+      if(Object.keys(schema_doc["schema"]["properties"]).length==0){
+        errors.push("You must define at least one property")
+      }
+    }
+
+    if(!schema_doc["schema"]["additionalProperties"]){
+      errors.push("The schema.'additionalProperties' field is required")
+    }else{
+      if(typeof(schema_doc["schema"]["additionalProperties"])!="boolean"){
+        errors.push("Invalid schema.additionalProperties. It must be a boolean value")
+      }
+    }
+
+    if(errors.length>0){
+      throw new Error("Schema validation errors- "+errors.join(","))
+    }
+  }
+
   /**
    * Returns a document with the provided ID
    * @param {String} doc_id - the doc Id (not the primary key)
@@ -251,7 +284,7 @@ class BeanBagDB {
    * @param {Object} data e.g {"name":"","mobile":""...}
    * @param {Object} settings (optional)
    */
-  async insert(schema, data, settings = {}) {
+  async insert(schema, data, meta= {},settings = {}) {
     try {
       let doc_obj = await this._insert_pre_checks(schema, data, settings);
       let new_rec = await this.db_api.insert(doc_obj);
@@ -370,6 +403,11 @@ class BeanBagDB {
 
   //////// Helper method ////////
 
+  _generate_random_link(){
+    const dictionary = ['rain', 'mars', 'banana', 'earth', 'kiwi', 'mercury', 'fuji', 'hurricane', 'matterhorn', 'snow', 'saturn', 'jupiter', 'peach', 'wind', 'pluto', 'apple', 'k2', 'storm', 'venus', 'denali', 'cloud', 'sunshine', 'mango', 'drizzle', 'pineapple', 'aconcagua', 'gasherbrum', 'apricot', 'neptune', 'fog', 'orange', 'blueberry', 'kilimanjaro', 'uranus', 'grape', 'storm', 'montblanc', 'lemon', 'chooyu', 'raspberry', 'cherry', 'thunder', 'vinson', 'breeze', 'elbrus', 'everest', 'parbat', 'makalu', 'nanga', 'kangchenjunga', 'lightning', 'cyclone', 'comet', 'asteroid', 'pomegranate', 'nectarine', 'clementine', 'strawberry', 'tornado', 'avalanche', 'andes', 'rockies', 'himalayas', 'pyrenees', 'carpathians', 'cascade', 'etna', 'vesuvius', 'volcano', 'tundra', 'whirlwind', 'iceberg', 'eclipse', 'zephyr', 'tropic', 'monsoon', 'aurora'];
+    return Array.from({ length: 4 }, () => dictionary[Math.floor(Math.random() * dictionary.length)]).join('-');
+  }
+
   _check_required_fields(requiredFields,obj){
     for (const field of requiredFields) {
       if (!obj[field]) {throw new Error(`${field} is required`);}
@@ -452,7 +490,8 @@ class BeanBagDB {
       meta: {
         createdOn: this._get_now_unix_timestamp(),
         tags: [],
-        app :{}
+        app :{},
+        link : this._generate_random_link() // there is a link by default. overwrite this if user provided one but only before checking if it is unique
       },
       schema: schema_name,
     };
@@ -527,7 +566,7 @@ class BeanBagDB {
    * @param {Object} schema
    * @param {Object} data
    */
-  async _insert_pre_checks(schema, data, settings = {}) {
+  async _insert_pre_checks(schema, data,meta={} ,settings = {}) {
     // schema search
     let sch_search = await this.search({
       selector: { schema: "schema", "data.name": schema },
@@ -539,8 +578,24 @@ class BeanBagDB {
     // validate data
     this.validate_data(schemaDoc.schema, data);
 
+    // validate meta
+    this.validate_data(sys_sch.editable_metadata_schema, meta);
+    
+    // duplicate meta.link check
+    if(meta.link){
+      let link_search = await this.search({ selector: {"meta.link":meta.link} });
+      console.log(link_search);
+      if (link_search.docs.length > 0) {
+        throw new Error("This link already exists in the database");
+      }
+    }
+
     // special checks for special docs
     // @TODO : for schema dos: settings fields must be in schema field
+    if(schema=="schema"){
+      //more checks are required
+      this.validate_schema_object(data)
+    }
     // @TODO : check if single record setting is set to true
 
     // duplicate check

package/src/system_schema.js

@@ -15,17 +15,20 @@ export const schema_schema = {
         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",
@@ -45,7 +48,7 @@ export const schema_schema = {
             items: {
               type: "string",
             },
-            maxItems: 20,
+            maxItems: 50,
           },
           encrypted_fields: {
             type: "array",
@@ -53,7 +56,7 @@ export const schema_schema = {
             items: {
               type: "string",
             },
-            maxItems: 10,
+            maxItems: 50,
           },
           single_record: {
             type: "boolean",
@@ -68,7 +71,7 @@ export const schema_schema = {
   },
   settings: {
     primary_key: ["name"],
-    editable_fields: ["schema", "settings"],
+    editable_fields: ["schema", "settings","description"],
   },
 };
 
@@ -175,6 +178,12 @@ export const editable_metadata_schema = {
       items:{type:"string"},
       default:[],
       maxItems: 40,
+    },
+    link:{
+      type:"string",
+      minLength:2,
+      maxLength:2000,
+      pattern: "^[a-zA-Z0-9-]+$"
     }
   }
 }

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,145 @@
-// 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  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("Testing creation of schema docs", async () => {
+  let schema_docs_invalid = [
+    {
+      name: "",
+      description: "",
+      schema: {},
+      settings: {},
+    },
+    {
+      name: "nos",
+      description: "",
+      schema: {},
+      settings: {},
+    },
+    {
+      name: "contact",
+      description: "",
+      schema: {},
+      settings: {},
+    },
+    {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {},
+      settings: {},
+    },
+    {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "abc":"something"
+      },
+      settings: {},
+    },
+    {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"something",
+      },
+      settings: {},
+    },
+    {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+      },
+      settings: {},
+    },
+    {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":"something"
+      },
+      settings: {},
+    },
+    {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{}
+      },
+      settings: {},
+    },
+    {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}}
+      },
+      settings: {},
+    },
+    {
+      name: "contact",
+      description: "This can be left blank",
+      schema: {
+        "type":"object",
+        "properties":{"name":{"type":"string"}},
+        "additionalProperties":"no"
+      },
+      settings: {},
+    },
+    // {
+    //   name: "contact",
+    //   description: "This can be left blank",
+    //   schema: {
+    //     "type":"object",
+    //     "properties":{"name":{"type":"string"}},
+    //     "additionalProperties":true
+    //   },
+    //   settings: {},
+    // },
+  ];
+
+  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 () => {
+      await rejects(
+        async () => {
+          await database.insert("schema", element);
+        },
+        Error
+      );
+    });
+
+  }
+  
+});
+

package/test/pouchdb.js

@@ -0,0 +1,73 @@
+// this is a pouch db instance of beanbagdb used for testing.
+import Ajv  from 'ajv';
+import PouchDB from 'pouchdb';
+import pouchdbFind from 'pouchdb-find';
+PouchDB.plugin(pouchdbFind)
+import { scryptSync, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
+
+
+export const get_pdb_doc = (dbname,secret)=>{
+const pdb = new PouchDB(dbname);
+  const doc_obj = {
+    name: dbname,
+    encryption_key: secret,
+    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}
+      }
+    },
+  }
+  return doc_obj
+}

package/test/test1.js

@@ -154,4 +154,25 @@
 // //   let db = new cbbdb(process.env.cdburl, process.env.cdbname, "sample_key");
 // //   await db.ready();
 // //   db.load_plugin("sample",pl1)
-// // })();
+// // })();
+
+import { get_pdb_doc } from './pouchdb.js';
+import { throws, strictEqual } from "assert";
+import BeanBagDB  from '../src/index.js';
+
+(async()=>{
+  let schema_docs_invalid = [
+    {
+     "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])
+})()