beanbagdb 0.0.1 → 0.0.5

package/.github/workflows/release.yml

@@ -0,0 +1,38 @@
+name: Release npm Package
+
+# Trigger the workflow on push to the "main" branch
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    # Step 1: Check out the code from the repository
+    - name: Checkout code
+      uses: actions/checkout@v3
+
+    # Step 2: Set up Node.js environment
+    - name: Setup Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: '20.17.0'  # Specify the Node.js version you want to use
+        cache: 'npm'         # Cache npm modules for faster builds
+
+    # Step 3: Install dependencies
+    - name: Install dependencies
+      run: npm install
+
+    # Step 4: Run tests
+    - name: Run tests
+      run: npm test
+
+    # Step 5: Publish to npm if tests pass
+    - name: Publish to npm
+      run: npm publish
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+

package/README.md

@@ -7,19 +7,131 @@
 v 0.0.0
 </div>
 
-## Intro
+## The Database architecture
+A BeanbagDB is a collection of JSON documents. In a NoSQL database, documents don't need to follow a specific schema. Typically, the developer defines a schema based on the specific problem the app is intended to solve. 
 
+While, BeanBagDB allows users to create their own schemas for documents, all document internally share a consistent structure that accommodates the user defined schema. 
 
-## Installation  
+Each document in the database follows this structure :
+```
+{
+  _id, _rev
+  data : {
+    user data
+  },
+  schema: "name_of_the_schema",
+  meta : {},
+}
+```
 
-### Option 1 : To use it with CouchDB 
+Here, the `data` object contains user's information, while the `schema` defines it's associated structure. The `meta` field holds metadata such as creation and last updated on date and user defined tags. 
 
-### Option 2 : To use it with PouchDB
+Even schema documents follow this structure. 
 
-### Option 3 : Web app
+### Examples : 
 
-## The Database architecture
+A system defined schema :
+```
+{ 
+  schema:"schema"
+  data : {
+    name: "system_tags",
+    .....
+  },
+  ...
+}
+```
+(In this example, the schema of this doc is `schema` because it stores the schema document, which will be use to validate documents that follows this schema)
+
+The document adhering to this schema might look like : 
+```
+{
+  schema:"system_tags",
+  data:{
+    tags:["tag1","tag2"]
+  }
+  ....
+}
+```
+User Defined schemas :
+```
+{
+  "schema":"schema",
+  "data":{
+    "name":"contacts",
+    ...
+  }
+}
+```
+And a sample document based on this user defined schema might look like :
+```
+{
+  schema:"contacts",
+  "data":{
+    "name":"Human 1",
+    "email":"human@on.earth"
+  }
+}
+```
+
+### System defined schemas 
+To ensure the system functions smoothly, each DB is initialized with a set of system defined schemas and seed documents. These are automatically added when the database is first created. These system defined are typically named with the prefix `system_`.
+
+List of system schemas :
+- `logs` : to log system and user actions 
+- `settings` : System level settings  (`name`,`value`,`json` for more details)
+- `keys` :  user level settings , these are encrypted and stored in the DB 
+- `secrets` : encrypted text (TODO)
+- `relations` : To create a network of relations  (TODO)
+- `index` :  (TODO)
+- `scripts` :  (TODO)
+
+## The BeanBagDB class
+
+The `BeanBagDB` class  contains the the logical part of how to interact with a local database. However, it does not itself makes any changes in the database. To make it (somewhat) compatible with multiple databases (e.g. CouchDB on the server, PouchDB in the browser), the class takes an db_instance object where the actual CRUD actions on the database can be performed. 
+
+To add support for a database, we extend the `BeanBagDB` class. 
+
+### API
+- `initialize_db()`
+- `log(stuff={whatever})`
+- `get_setting_doc(setting_name)`
+- `get_schema_doc()`
+- `validate_data()`
+- `insert_pre_check()`
+- `insert()`
+- `get()`
+- `load_doc()`
+- `update_data()`
+- ...
+
+
+## JSON Schema (in progress)
+[Source](https://json-schema.org/) and [another](https://www.learnjsonschema.com/2020-12/)
+
+### Basic schema structure 
+```
+{
+  "name":"",
+  "description":"",
+  "properties":{
+
+  },
+  "settings":{
 
-## API
+  }
+}
+```
+#### Properties:
+- Settings :
+  - `additionalProperties:true`
+  - `required:[]`
+  - 
+- Defining custom fields :
+  - `type:""` Valid values: ``
 
 
+#### Settings :
+- `primary_key:[]` 
+- `editable_fields:[]`
+- `single_record : true` 

package/package.json

@@ -1,30 +1,38 @@
 {
   "name": "beanbagdb",
-  "version": "0.0.1",
-  "description": "The core JS library to work with schema with NoSQL DBs",
+  "version": "0.0.5",
+  "description": "A JS library to introduce a schema layer to a No-SQL local database",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "mocha"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/shubhvjain/infodb-core.git"
+    "url": "git+https://github.com/shubhvjain/beanbagdb.git"
   },
   "keywords": [
     "couchdb",
     "pouchdb",
     "local",
-    "database"
+    "database",
+    "schema"
   ],
   "author": "svj",
   "license": "ISC",
   "bugs": {
-    "url": "https://github.com/shubhvjain/infodb-core/issues"
+    "url": "https://github.com/shubhvjain/beanbagdb/issues"
   },
-  "homepage": "https://github.com/shubhvjain/infodb-core#readme",
+  "homepage": "https://github.com/shubhvjain/beanbagdb#readme",
   "dependencies": {
     "ajv": "^8.12.0",
     "dotenv": "^16.4.5",
-    "nano": "^10.1.3"
+    "nano": "^10.1.3",
+    "pouchdb": "^9.0.0",
+    "pouchdb-adapter-memory": "^9.0.0",
+    "pouchdb-find": "^9.0.0"
+  },
+  "devDependencies": {
+    "chai": "^5.1.1",
+    "mocha": "^10.7.3"
   }
 }

package/src/couchdb.js

@@ -0,0 +1,63 @@
+const crypto = require('crypto');
+const SDB = require("./index.js")
+
+class BeanBagDB_CouchDB extends SDB {
+  constructor(db_url,db_name,encryption_key){
+    const cdb = require("nano")(db_url)
+    const doc_obj = {
+      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
+        }
+      }
+    }
+    super(doc_obj)
+  }
+}
+
+module.exports = BeanBagDB_CouchDB