milodb 1.0.0

package/README.md

@@ -0,0 +1,141 @@
+Here’s a sample `README.md` file that explains how to use the database manager NPM package you've created.
+
+---
+
+# JSON Database Manager with Encryption
+
+This is a simple database manager that allows you to store and manage your data in encrypted JSON files. It provides an easy-to-use CLI interface to perform CRUD operations (Create, Read, Update, Delete) on tables stored as JSON files.
+
+### Features
+- **Encrypted Data**: Store your data securely using AES encryption.
+- **CRUD Operations**: Create, read, update, and delete records in JSON tables.
+- **Command-Line Interface (CLI)**: Interact with the database using simple CLI commands.
+
+### Table of Contents
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Create a Table](#create-a-table)
+  - [Add a Record](#add-a-record)
+  - [Edit a Record](#edit-a-record)
+  - [Delete a Record](#delete-a-record)
+  - [Get All Records](#get-all-records)
+- [License](#license)
+
+---
+
+## Installation
+
+1. Clone the repository or download the package.
+   
+2. Install the dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Link the package globally to use the CLI commands:
+   ```bash
+   npm link
+   ```
+
+4. The commands will now be available globally through the terminal.
+
+---
+
+## Usage
+
+Once installed, you can use the following commands to manage your encrypted JSON database.
+
+### Create a Table
+
+To create a new table, run the following command:
+
+```bash
+db-manager createTable <tableName>
+```
+
+This will create a new table (a JSON file) in the `./db` directory. The table will be initialized as an empty array.
+
+**Example**:
+```bash
+db-manager createTable users
+```
+
+This will create a table named `users.json` inside the `./db` folder.
+
+### Add a Record
+
+To add a new record to a table, use the `addRecord` command. The record must be a valid JSON object.
+
+```bash
+db-manager addRecord <tableName> <record>
+```
+
+**Example**:
+```bash
+db-manager addRecord users '{"id": 1, "name": "John Doe", "email": "john@example.com"}'
+```
+
+This will add the record to the `users` table. The data will be encrypted before being stored.
+
+### Edit a Record
+
+To edit an existing record, use the `editRecord` command. You need to specify the table name, the `recordId` (the ID of the record to be updated), and the new updated record in JSON format.
+
+```bash
+db-manager editRecord <tableName> <recordId> <updatedRecord>
+```
+
+**Example**:
+```bash
+db-manager editRecord users 1 '{"id": 1, "name": "John Doe", "email": "john.doe@example.com"}'
+```
+
+This will update the record with ID `1` in the `users` table.
+
+### Delete a Record
+
+To delete a record from a table, use the `deleteRecord` command. Provide the table name and the `recordId` of the record you want to delete.
+
+```bash
+db-manager deleteRecord <tableName> <recordId>
+```
+
+**Example**:
+```bash
+db-manager deleteRecord users 1
+```
+
+This will delete the record with ID `1` from the `users` table.
+
+### Get All Records
+
+To retrieve all records from a table, use the `getRecords` command. This will output all the records in the specified table.
+
+```bash
+db-manager getRecords <tableName>
+```
+
+**Example**:
+```bash
+db-manager getRecords users
+```
+
+This will display all the records from the `users` table. The data will be decrypted before being shown.
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+---
+
+### Notes
+
+- All the data is stored encrypted for security. When retrieving data, it will be automatically decrypted before being displayed.
+- Make sure you use a strong `secretKey` in the `encrypt.js` file for enhanced security.
+- This package uses the `fs-extra` module to interact with the file system and store data as JSON files.
+  
+--- 
+
+This README will help users get started with the database manager and use it for simple operations on encrypted JSON data files.

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "milodb",
+  "version": "1.0.0",
+  "main": "src/milodb.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "crypto": "^1.0.1",
+    "fs-extra": "^11.2.0"
+  },
+  "bin": {
+  "milodb": "./src/cli.js"
+}
+}

package/src/cli.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs-extra');
+const MiloDB = require('./src/milodb');
+
+// Function to initialize the database
+async function initDatabase() {
+  const dbPath = path.join(process.cwd(), 'src/db');  // Set the path where the database will be stored
+
+  try {
+    // Create a new instance of MiloDB
+    const db = new MiloDB(dbPath, false); // Default to no encryption
+
+    // Ensure the database folder exists
+    fs.ensureDirSync(dbPath);
+
+    console.log(`Database initialized at: ${dbPath}`);
+
+    // Optionally, you could create a default table
+    // await db.createTable('users');
+    // console.log('Default "users" table created.');
+
+  } catch (error) {
+    console.error('Error initializing database:', error.message);
+    process.exit(1);
+  }
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+
+// Handle the `init` command
+if (args[0] === 'init') {
+  initDatabase();
+} else {
+  console.log('Unknown command. Please use "milodb init" to initialize the database.');
+  process.exit(1);
+}

package/src/encrypt.js

@@ -0,0 +1,24 @@
+// src/encrypt.js
+const crypto = require('crypto');
+const secretKey = 'your-secret-key'; // Use a strong key for real-world applications
+const algorithm = 'aes-256-cbc';
+
+// Encrypt data
+function encrypt(data) {
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv(algorithm, Buffer.from(secretKey), iv);
+  let encryptedData = cipher.update(data, 'utf8', 'hex');
+  encryptedData += cipher.final('hex');
+  return `${iv.toString('hex')}:${encryptedData}`;
+}
+
+// Decrypt data
+function decrypt(encryptedData) {
+  const [iv, data] = encryptedData.split(':');
+  const decipher = crypto.createDecipheriv(algorithm, Buffer.from(secretKey), Buffer.from(iv, 'hex'));
+  let decryptedData = decipher.update(data, 'hex', 'utf8');
+  decryptedData += decipher.final('utf8');
+  return decryptedData;
+}
+
+module.exports = { encrypt, decrypt };

package/src/milodb.js

@@ -0,0 +1,102 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { encrypt, decrypt } = require('./encrypt');
+
+class MiloDB {
+  constructor(dbPath = path.join(__dirname, 'db'), encryptData = false) {
+    // Use the root folder for dbPath if not provided
+    this.dbPath = dbPath;
+    this.encryptData = encryptData;
+    fs.ensureDirSync(this.dbPath); // Ensure that the DB path exists
+  }
+
+  // Create a new table (i.e., a new JSON file)
+  async createTable(tableName) {
+    const tablePath = path.join(this.dbPath, `${tableName}.json`);
+    if (fs.existsSync(tablePath)) {
+      throw new Error(`Table ${tableName} already exists.`);
+    }
+    await fs.writeJson(tablePath, [], { spaces: 2 });
+    console.log(`Table ${tableName} created successfully.`);
+  }
+
+  // Add a record to a table
+  async addRecord(tableName, record) {
+    const tablePath = path.join(this.dbPath, `${tableName}.json`);
+    if (!fs.existsSync(tablePath)) {
+      throw new Error(`Table ${tableName} does not exist.`);
+    }
+    const table = await fs.readJson(tablePath);
+    
+    // Apply encryption if needed
+    if (this.encryptData) {
+      record = encrypt(JSON.stringify(record));
+    }
+
+    table.push(record);
+    await fs.writeJson(tablePath, table, { spaces: 2 });
+    console.log('Record added successfully.');
+  }
+
+  // Edit a record in a table
+  async editRecord(tableName, recordId, updatedRecord) {
+    const tablePath = path.join(this.dbPath, `${tableName}.json`);
+    if (!fs.existsSync(tablePath)) {
+      throw new Error(`Table ${tableName} does not exist.`);
+    }
+    const table = await fs.readJson(tablePath);
+    const index = table.findIndex((rec) => this.decryptIfNeeded(rec).id === recordId);
+    if (index === -1) {
+      throw new Error(`Record with ID ${recordId} not found.`);
+    }
+    
+    // Apply encryption if needed
+    table[index] = this.encryptIfNeeded(updatedRecord);
+    await fs.writeJson(tablePath, table, { spaces: 2 });
+    console.log('Record updated successfully.');
+  }
+
+  // Delete a record from a table
+  async deleteRecord(tableName, recordId) {
+    const tablePath = path.join(this.dbPath, `${tableName}.json`);
+    if (!fs.existsSync(tablePath)) {
+      throw new Error(`Table ${tableName} does not exist.`);
+    }
+    const table = await fs.readJson(tablePath);
+    const index = table.findIndex((rec) => this.decryptIfNeeded(rec).id === recordId);
+    if (index === -1) {
+      throw new Error(`Record with ID ${recordId} not found.`);
+    }
+    table.splice(index, 1);
+    await fs.writeJson(tablePath, table, { spaces: 2 });
+    console.log('Record deleted successfully.');
+  }
+
+  // Get all records from a table
+  async getRecords(tableName) {
+    const tablePath = path.join(this.dbPath, `${tableName}.json`);
+    if (!fs.existsSync(tablePath)) {
+      throw new Error(`Table ${tableName} does not exist.`);
+    }
+    const table = await fs.readJson(tablePath);
+    return table.map((record) => this.decryptIfNeeded(record));
+  }
+
+  // Helper function to decrypt a record if encryption is enabled
+  decryptIfNeeded(record) {
+    if (this.encryptData) {
+      return JSON.parse(decrypt(record));
+    }
+    return JSON.parse(record);
+  }
+
+  // Helper function to encrypt a record if encryption is enabled
+  encryptIfNeeded(record) {
+    if (this.encryptData) {
+      return encrypt(JSON.stringify(record));
+    }
+    return JSON.stringify(record);
+  }
+}
+
+module.exports = MiloDB;