milodb 1.0.7 → 1.1.1

package/.eslintrc.json

@@ -0,0 +1,19 @@
+{
+  "env": {
+    "node": true,
+    "es2021": true
+  },
+  "extends": "eslint:recommended",
+  "parserOptions": {
+    "ecmaVersion": 12,
+    "sourceType": "module"
+  },
+  "rules": {
+    "indent": ["error", 4],
+    "linebreak-style": ["error", "unix"],
+    "quotes": ["error", "single"],
+    "semi": ["error", "always"],
+    "no-unused-vars": ["warn"],
+    "no-console": ["warn", { "allow": ["warn", "error"] }]
+  }
+} 

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.1] - 2024-03-19
+
+### Changed
+- Updated package metadata
+- Added ESLint configuration
+- Added comprehensive documentation
+- Added benchmark tools
+- Added proper project structure
+
+## [1.0.0] - 2024-03-19
+
+### Added
+- Initial release
+- Basic key-value storage functionality
+- Optional encryption using AES-256-GCM
+- TTL (Time To Live) support
+- Batch operations
+- Advanced search with regex support
+- Database statistics
+- Comprehensive test suite
+- Benchmark tools
+- Documentation 

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MiloDB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -1,141 +1,119 @@
-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.
+# milodb
+
+A simple mini database with optional encryption to store key-value pairs. Features include encryption, TTL support, batch operations, and advanced search capabilities.
+
+## Installation
+
+```bash
+npm install milodb
+```
+
+## Usage
+
+```javascript
+const MinoDB = require('milodb');
+
+// Initialize with an optional password for encryption and flag to enable/disable encryption
+const db = new MinoDB('my-secret-password', true); // true to encrypt data
+
+// Basic operations
+await db.set('name', 'John Doe');
+console.log(await db.get('name'));  // Output: John Doe
+
+// Set with TTL (Time To Live) in milliseconds
+await db.set('temp', 'This will expire', 3600000); // Expires in 1 hour
+
+// Delete an entry
+await db.delete('name');
+console.log(await db.get('name'));  // Output: null
+
+// Clear all entries
+await db.clear();
+
+// Advanced search with options
+const results = await db.search('John', {
+    regex: false,        // Use regex for searching
+    caseSensitive: false, // Case-sensitive search
+    limit: 10           // Limit number of results
+});
+
+// Batch operations
+const batchResults = await db.batch([
+    { type: 'set', key: 'key1', value: 'value1', ttl: 3600000 },
+    { type: 'set', key: 'key2', value: 'value2' },
+    { type: 'delete', key: 'key3' }
+]);
+
+// Get database statistics
+const stats = await db.stats();
+console.log(stats);
+// Output: { total: 2, expired: 0, active: 2 }
+```
+
+## Features:
+- Secure encryption using AES-256-GCM with salt
+- TTL (Time To Live) support for entries
+- Async operations (set, get, delete, list, search)
+- Batch operations support
+- Advanced search with regex and case-sensitivity options
+- Automatic cleanup of expired entries
+- Database statistics
+- Store data in a JSON file
+- Proper error handling and validation
+- Lazy initialization for better performance
+
+## Security Features:
+- Uses PBKDF2 for key derivation
+- Implements salt for each encryption
+- Uses AES-256-GCM for authenticated encryption
+- Proper IV handling
+- Input validation
+
+## Performance Characteristics
+
+The database is designed for simplicity and ease of use, with some performance considerations:
+
+### Memory Usage
+- All data is loaded into memory when the database is initialized
+- Memory usage scales linearly with the number of entries and their size
+- Typical memory usage: ~100-200 bytes per entry (for small values)
+
+### Performance Limits
+- Recommended for up to 100,000 entries with small values
+- Can handle up to 1 million entries, but with increased memory usage and slower operations
+- Not recommended for very large values (>1MB) or millions of entries
+
+### Benchmark
+A benchmark script is included to test performance with large datasets:
+
+```bash
+node benchmark/benchmark.js
+```
+
+The benchmark will:
+- Insert 1 million key-value pairs
+- Measure insertion time and memory usage
+- Verify sample values
+- Clean up the test database
+
+### Performance Tips
+1. Use batch operations for multiple writes
+2. Keep values small when possible
+3. Use TTL to automatically clean up old data
+4. Consider using a more robust database for:
+   - Millions of entries
+   - Very large values
+   - High-frequency writes
+   - Distributed systems
+
+## Error Handling:
+The database will throw errors for:
+- Invalid key types (must be string)
+- Empty keys
+- Undefined values
+- Missing password when encryption is enabled
+- Invalid encryption/decryption operations
+
+## License
+MIT
+

package/benchmark/benchmark.js

@@ -0,0 +1,60 @@
+const fs = require('fs').promises;
+const path = require('path');
+const MinoDB = require('../src/index');
+
+const BENCHMARK_DB_PATH = path.join(__dirname, '..', 'db', 'benchmark-db.json');
+const NUM_ROWS = 1_000_000;
+const SAMPLE_KEYS = [0, Math.floor(NUM_ROWS / 2), NUM_ROWS - 1];
+
+async function cleanup() {
+    try {
+        await fs.unlink(BENCHMARK_DB_PATH);
+    } catch (err) {
+        if (err.code !== 'ENOENT') throw err;
+    }
+}
+
+async function runBenchmark() {
+    console.log(`Benchmark: Inserting ${NUM_ROWS.toLocaleString()} rows...`);
+    await cleanup();
+    const db = new MinoDB(null, false);
+    db.dbPath = BENCHMARK_DB_PATH;
+
+    const start = Date.now();
+    for (let i = 0; i < NUM_ROWS; i++) {
+        await db.set(`key${i}`, `value${i}`);
+        if (i > 0 && i % 100_000 === 0) {
+            console.log(`  Inserted ${i.toLocaleString()} rows...`);
+        }
+    }
+    const end = Date.now();
+    const mem = process.memoryUsage();
+    console.log(`Insert time: ${(end - start) / 1000}s`);
+    console.log(`Memory usage: ${(mem.rss / 1024 / 1024).toFixed(2)} MB (RSS)`);
+
+    // Verify a few values
+    let allCorrect = true;
+    for (const idx of SAMPLE_KEYS) {
+        const key = `key${idx}`;
+        const expected = `value${idx}`;
+        const actual = await db.get(key);
+        if (actual !== expected) {
+            console.error(`  Value mismatch for ${key}: expected ${expected}, got ${actual}`);
+            allCorrect = false;
+        }
+    }
+    if (allCorrect) {
+        console.log('Sample value verification: PASSED');
+    } else {
+        console.log('Sample value verification: FAILED');
+    }
+
+    // Clean up
+    await cleanup();
+    console.log('Benchmark database cleaned up.');
+}
+
+runBenchmark().catch(err => {
+    console.error('Benchmark failed:', err);
+    process.exit(1);
+}); 

package/benchmark/search_edit_benchmark.js

@@ -0,0 +1,143 @@
+const fs = require('fs').promises;
+const path = require('path');
+const MinoDB = require('../src/index');
+
+const BENCHMARK_DB_PATH = path.join(__dirname, '..', 'db', 'benchmark-db.json');
+const NUM_ROWS = 1_000_000;
+const SEARCH_SAMPLES = 1000; // Number of search operations to perform
+const EDIT_SAMPLES = 1000;   // Number of edit operations to perform
+
+async function runSearchEditBenchmark() {
+    console.log('Starting Search and Edit Benchmark...\n');
+
+    // Initialize database
+    const db = new MinoDB(null, false);
+    db.dbPath = BENCHMARK_DB_PATH;
+
+    // Generate test data if it doesn't exist
+    if (!await fileExists(BENCHMARK_DB_PATH)) {
+        console.log(`Creating test database with ${NUM_ROWS.toLocaleString()} entries...`);
+        for (let i = 0; i < NUM_ROWS; i++) {
+            await db.set(`key${i}`, `value${i}`);
+            if (i > 0 && i % 100_000 === 0) {
+                console.log(`  Inserted ${i.toLocaleString()} entries...`);
+            }
+        }
+    }
+
+    // Benchmark Search Operations
+    console.log('\nBenchmarking Search Operations...');
+    const searchTimes = [];
+    const searchPatterns = [
+        'value1',           // Common prefix
+        '999',             // Common suffix
+        '500',             // Middle value
+        'key1',            // Key search
+        'nonexistent'      // No matches
+    ];
+
+    for (const pattern of searchPatterns) {
+        console.log(`\nSearching for pattern: "${pattern}"`);
+        
+        // Basic search
+        const basicStart = Date.now();
+        const basicResults = await db.search(pattern);
+        const basicTime = Date.now() - basicStart;
+        searchTimes.push({ pattern, type: 'basic', time: basicTime, results: Object.keys(basicResults).length });
+        console.log(`  Basic search: ${basicTime}ms, found ${Object.keys(basicResults).length} results`);
+
+        // Regex search
+        const regexStart = Date.now();
+        const regexResults = await db.search(pattern, { regex: true });
+        const regexTime = Date.now() - regexStart;
+        searchTimes.push({ pattern, type: 'regex', time: regexTime, results: Object.keys(regexResults).length });
+        console.log(`  Regex search: ${regexTime}ms, found ${Object.keys(regexResults).length} results`);
+
+        // Case-sensitive search
+        const caseStart = Date.now();
+        const caseResults = await db.search(pattern.toUpperCase(), { caseSensitive: true });
+        const caseTime = Date.now() - caseStart;
+        searchTimes.push({ pattern, type: 'case-sensitive', time: caseTime, results: Object.keys(caseResults).length });
+        console.log(`  Case-sensitive search: ${caseTime}ms, found ${Object.keys(caseResults).length} results`);
+    }
+
+    // Benchmark Edit Operations
+    console.log('\nBenchmarking Edit Operations...');
+    const editTimes = [];
+    
+    // Random edits
+    for (let i = 0; i < EDIT_SAMPLES; i++) {
+        const key = `key${Math.floor(Math.random() * NUM_ROWS)}`;
+        const newValue = `updated_value_${i}`;
+        
+        const start = Date.now();
+        await db.set(key, newValue);
+        const time = Date.now() - start;
+        editTimes.push(time);
+        
+        if (i % 100 === 0) {
+            console.log(`  Completed ${i} edits...`);
+        }
+    }
+
+    // Batch edits
+    console.log('\nBenchmarking Batch Edit Operations...');
+    const batchSize = 100;
+    const batchTimes = [];
+    
+    for (let i = 0; i < EDIT_SAMPLES / batchSize; i++) {
+        const operations = [];
+        for (let j = 0; j < batchSize; j++) {
+            const key = `key${Math.floor(Math.random() * NUM_ROWS)}`;
+            operations.push({
+                type: 'set',
+                key,
+                value: `batch_updated_${i}_${j}`
+            });
+        }
+        
+        const start = Date.now();
+        await db.batch(operations);
+        const time = Date.now() - start;
+        batchTimes.push(time);
+        
+        console.log(`  Completed batch ${i + 1}...`);
+    }
+
+    // Print Results
+    console.log('\nBenchmark Results:');
+    console.log('\nSearch Operations:');
+    searchTimes.forEach(({ pattern, type, time, results }) => {
+        console.log(`  ${type} search for "${pattern}": ${time}ms, found ${results} results`);
+    });
+
+    console.log('\nEdit Operations:');
+    const avgEditTime = editTimes.reduce((a, b) => a + b, 0) / editTimes.length;
+    console.log(`  Average single edit time: ${avgEditTime.toFixed(2)}ms`);
+
+    console.log('\nBatch Edit Operations:');
+    const avgBatchTime = batchTimes.reduce((a, b) => a + b, 0) / batchTimes.length;
+    console.log(`  Average batch edit time (${batchSize} operations): ${avgBatchTime.toFixed(2)}ms`);
+    console.log(`  Average time per operation in batch: ${(avgBatchTime / batchSize).toFixed(2)}ms`);
+
+    // Memory Usage
+    const mem = process.memoryUsage();
+    console.log('\nMemory Usage:');
+    console.log(`  RSS: ${(mem.rss / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`  Heap Total: ${(mem.heapTotal / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`  Heap Used: ${(mem.heapUsed / 1024 / 1024).toFixed(2)} MB`);
+}
+
+async function fileExists(path) {
+    try {
+        await fs.access(path);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+runSearchEditBenchmark().catch(err => {
+    console.error('Benchmark failed:', err);
+    process.exit(1);
+}); 

package/package.json

@@ -1,22 +1,38 @@
 {
   "name": "milodb",
-  "version": "1.0.7",
-  "main": "src/milodb.js",
+  "version": "1.1.1",
+  "description": "A simple mini database with optional encryption to store key-value pairs",
+  "main": "src/index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node test/test.js",
+    "benchmark": "node benchmark/benchmark.js",
+    "benchmark:search": "node benchmark/search_edit_benchmark.js",
+    "lint": "eslint src/ test/ benchmark/",
+    "clean": "rm -rf db/*.json"
   },
-  "keywords": [],
+  "keywords": [
+    "database",
+    "key-value",
+    "encryption",
+    "storage",
+    "json",
+    "simple",
+    "mini"
+  ],
   "author": "",
-  "license": "ISC",
-  "description": "",
-  "dependencies": {
-    "commander": "^12.1.0",
-    "crypto": "^1.0.1",
-    "fs-extra": "^11.2.0",
-    "inquirer": "^12.1.0"
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
   },
-  "bin": {
-    "milodb": "./src/cli.js"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/milodb.git"
   },
-  "preferGlobal": true
+  "bugs": {
+    "url": "https://github.com/yourusername/milodb/issues"
+  },
+  "homepage": "https://github.com/yourusername/milodb#readme",
+  "devDependencies": {
+    "eslint": "^8.0.0"
+  }
 }

package/src/index.js

@@ -0,0 +1,263 @@
+const fs = require('fs').promises;
+const crypto = require('crypto');
+const path = require('path');
+const zlib = require('zlib');
+const { promisify } = require('util');
+
+const gzip = promisify(zlib.gzip);
+const gunzip = promisify(zlib.gunzip);
+
+// Helper function for encryption with salt
+function encrypt(text, password) {
+    if (!password) throw new Error('Password is required for encryption');
+    const salt = crypto.randomBytes(16);
+    const key = crypto.pbkdf2Sync(password, salt, 100000, 32, 'sha256');
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    
+    let encrypted = cipher.update(text, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    const authTag = cipher.getAuthTag();
+    
+    return {
+        encrypted,
+        salt: salt.toString('hex'),
+        iv: iv.toString('hex'),
+        authTag: authTag.toString('hex')
+    };
+}
+
+// Helper function for decryption with salt
+function decrypt(encryptedData, password) {
+    if (!password) throw new Error('Password is required for decryption');
+    const { encrypted, salt, iv, authTag } = encryptedData;
+    
+    const key = crypto.pbkdf2Sync(password, Buffer.from(salt, 'hex'), 100000, 32, 'sha256');
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, Buffer.from(iv, 'hex'));
+    decipher.setAuthTag(Buffer.from(authTag, 'hex'));
+    
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+
+// Helper function to compress data
+async function compress(data) {
+    return await gzip(Buffer.from(data));
+}
+
+// Helper function to decompress data
+async function decompress(data) {
+    return (await gunzip(data)).toString();
+}
+
+// Basic mini database class
+class MinoDB {
+    constructor(password = null, encryptData = true) {
+        this.dbPath = path.join(__dirname, '..', 'db', 'database.json');
+        this.password = password;
+        this.encryptData = encryptData;
+        this.db = {};
+        this.initialized = false;
+    }
+
+    // Initialize the database
+    async init() {
+        if (this.initialized) return;
+        await this.loadDatabase();
+        this.initialized = true;
+    }
+
+    // Load the database from the file
+    async loadDatabase() {
+        try {
+            const rawData = await fs.readFile(this.dbPath, 'utf8');
+            const data = this.encryptData ? decrypt(JSON.parse(rawData), this.password) : rawData;
+            this.db = JSON.parse(data);
+            
+            // Clean expired entries
+            await this.cleanExpired();
+        } catch (err) {
+            if (err.code !== 'ENOENT') throw err;
+            this.db = {};
+        }
+    }
+
+    // Save the database to the file
+    async saveDatabase() {
+        const data = JSON.stringify(this.db, null, 2);
+        let dataToSave;
+        
+        if (this.encryptData) {
+            dataToSave = JSON.stringify(encrypt(data, this.password));
+        } else {
+            dataToSave = data;
+        }
+        
+        await fs.writeFile(this.dbPath, dataToSave, 'utf8');
+    }
+
+    // Validate key and value
+    validateKeyValue(key, value) {
+        if (typeof key !== 'string') throw new Error('Key must be a string');
+        if (key.length === 0) throw new Error('Key cannot be empty');
+        if (value === undefined) throw new Error('Value cannot be undefined');
+    }
+
+    // Add or update an entry (asynchronous)
+    async set(key, value, ttl = null) {
+        await this.init();
+        this.validateKeyValue(key, value);
+        
+        const entry = {
+            value,
+            createdAt: Date.now(),
+            expiresAt: ttl ? Date.now() + ttl : null
+        };
+        
+        this.db[key] = entry;
+        await this.saveDatabase();
+    }
+
+    // Get an entry by key (asynchronous)
+    async get(key) {
+        await this.init();
+        const entry = this.db[key];
+        
+        if (!entry) return null;
+        if (entry.expiresAt && entry.expiresAt < Date.now()) {
+            delete this.db[key];
+            await this.saveDatabase();
+            return null;
+        }
+        
+        return entry.value;
+    }
+
+    // Delete an entry by key (asynchronous)
+    async delete(key) {
+        await this.init();
+        if (this.db[key]) {
+            delete this.db[key];
+            await this.saveDatabase();
+            return true;
+        }
+        return false;
+    }
+
+    // List all entries (asynchronous)
+    async list() {
+        await this.init();
+        await this.cleanExpired();
+        const result = {};
+        for (const [key, entry] of Object.entries(this.db)) {
+            result[key] = entry.value;
+        }
+        return result;
+    }
+
+    // Clear the database (asynchronous)
+    async clear() {
+        await this.init();
+        this.db = {};
+        await this.saveDatabase();
+        return 'Database cleared.';
+    }
+
+    // Search for values (asynchronous)
+    async search(query, options = {}) {
+        await this.init();
+        await this.cleanExpired();
+        
+        const {
+            regex = false,
+            caseSensitive = false,
+            limit = 0
+        } = options;
+        
+        const results = {};
+        let count = 0;
+        
+        for (const [key, entry] of Object.entries(this.db)) {
+            if (limit > 0 && count >= limit) break;
+            
+            const value = entry.value;
+            const searchStr = JSON.stringify(value);
+            let matches = false;
+            
+            if (regex) {
+                const flags = caseSensitive ? '' : 'i';
+                matches = new RegExp(query, flags).test(searchStr);
+            } else {
+                const searchValue = caseSensitive ? query : query.toLowerCase();
+                const compareValue = caseSensitive ? searchStr : searchStr.toLowerCase();
+                matches = compareValue.includes(searchValue);
+            }
+            
+            if (matches) {
+                results[key] = value;
+                count++;
+            }
+        }
+        
+        return results;
+    }
+
+    // Clean expired entries
+    async cleanExpired() {
+        const now = Date.now();
+        let cleaned = false;
+        
+        for (const [key, entry] of Object.entries(this.db)) {
+            if (entry.expiresAt && entry.expiresAt < now) {
+                delete this.db[key];
+                cleaned = true;
+            }
+        }
+        
+        if (cleaned) {
+            await this.saveDatabase();
+        }
+    }
+
+    // Batch operations
+    async batch(operations) {
+        await this.init();
+        const results = [];
+        
+        for (const op of operations) {
+            switch (op.type) {
+                case 'set':
+                    await this.set(op.key, op.value, op.ttl);
+                    results.push({ success: true });
+                    break;
+                case 'delete':
+                    results.push({ success: await this.delete(op.key) });
+                    break;
+                default:
+                    results.push({ success: false, error: 'Invalid operation type' });
+            }
+        }
+        
+        return results;
+    }
+
+    // Get database statistics
+    async stats() {
+        await this.init();
+        await this.cleanExpired();
+        
+        const total = Object.keys(this.db).length;
+        const expired = Object.values(this.db).filter(entry => 
+            entry.expiresAt && entry.expiresAt < Date.now()
+        ).length;
+        
+        return {
+            total,
+            expired,
+            active: total - expired
+        };
+    }
+}
+
+module.exports = MinoDB;

package/test/test.js

@@ -0,0 +1,159 @@
+const assert = require('assert');
+const fs = require('fs').promises;
+const path = require('path');
+const MinoDB = require('../src/index');
+
+// Helper function to clean up test database
+async function cleanup() {
+    try {
+        await fs.unlink(path.join(__dirname, '..', 'db', 'database.json'));
+    } catch (err) {
+        if (err.code !== 'ENOENT') throw err;
+    }
+}
+
+// Helper function to delay execution
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+async function runTests() {
+    console.log('Starting tests...\n');
+
+    // Test 1: Basic Operations
+    console.log('Test 1: Basic Operations');
+    const db = new MinoDB('test-password', true);
+    
+    // Test set and get
+    await db.set('test-key', 'test-value');
+    const value = await db.get('test-key');
+    assert.strictEqual(value, 'test-value', 'Basic set/get failed');
+    console.log('✓ Basic set/get passed');
+
+    // Test delete
+    await db.delete('test-key');
+    const deletedValue = await db.get('test-key');
+    assert.strictEqual(deletedValue, null, 'Delete operation failed');
+    console.log('✓ Delete operation passed');
+
+    // Test 2: TTL Support
+    console.log('\nTest 2: TTL Support');
+    await db.set('temp-key', 'temp-value', 1000); // 1 second TTL
+    const tempValue = await db.get('temp-key');
+    assert.strictEqual(tempValue, 'temp-value', 'TTL set failed');
+    console.log('✓ TTL set passed');
+
+    await delay(1100); // Wait for TTL to expire
+    const expiredValue = await db.get('temp-key');
+    assert.strictEqual(expiredValue, null, 'TTL expiration failed');
+    console.log('✓ TTL expiration passed');
+
+    // Test 3: Batch Operations
+    console.log('\nTest 3: Batch Operations');
+    const batchResults = await db.batch([
+        { type: 'set', key: 'batch1', value: 'value1' },
+        { type: 'set', key: 'batch2', value: 'value2', ttl: 1000 },
+        { type: 'delete', key: 'batch1' }
+    ]);
+    
+    assert.strictEqual(batchResults.length, 3, 'Batch operation count mismatch');
+    assert.strictEqual(batchResults[0].success, true, 'Batch set failed');
+    assert.strictEqual(batchResults[1].success, true, 'Batch set with TTL failed');
+    assert.strictEqual(batchResults[2].success, true, 'Batch delete failed');
+    console.log('✓ Batch operations passed');
+
+    // Test 4: Search Operations
+    console.log('\nTest 4: Search Operations');
+    await db.set('search1', 'hello world');
+    await db.set('search2', 'hello universe');
+    await db.set('search3', 'different text');
+
+    // Test basic search
+    const searchResults = await db.search('hello');
+    assert.strictEqual(Object.keys(searchResults).length, 2, 'Basic search failed');
+    console.log('✓ Basic search passed');
+
+    // Test regex search
+    const regexResults = await db.search('hello', { regex: true });
+    assert.strictEqual(Object.keys(regexResults).length, 2, 'Regex search failed');
+    console.log('✓ Regex search passed');
+
+    // Test case-sensitive search
+    const caseResults = await db.search('HELLO', { caseSensitive: true });
+    assert.strictEqual(Object.keys(caseResults).length, 0, 'Case-sensitive search failed');
+    console.log('✓ Case-sensitive search passed');
+
+    // Test 5: Database Statistics
+    console.log('\nTest 5: Database Statistics');
+    const stats = await db.stats();
+    assert.strictEqual(typeof stats.total, 'number', 'Stats total type mismatch');
+    assert.strictEqual(typeof stats.expired, 'number', 'Stats expired type mismatch');
+    assert.strictEqual(typeof stats.active, 'number', 'Stats active type mismatch');
+    console.log('✓ Database statistics passed');
+
+    // Test 6: Error Handling
+    console.log('\nTest 6: Error Handling');
+    
+    // Test invalid key type
+    try {
+        await db.set(123, 'value');
+        assert.fail('Should have thrown error for invalid key type');
+    } catch (err) {
+        assert.strictEqual(err.message, 'Key must be a string', 'Invalid key type error message mismatch');
+    }
+    console.log('✓ Invalid key type handling passed');
+
+    // Test empty key
+    try {
+        await db.set('', 'value');
+        assert.fail('Should have thrown error for empty key');
+    } catch (err) {
+        assert.strictEqual(err.message, 'Key cannot be empty', 'Empty key error message mismatch');
+    }
+    console.log('✓ Empty key handling passed');
+
+    // Test undefined value
+    try {
+        await db.set('key', undefined);
+        assert.fail('Should have thrown error for undefined value');
+    } catch (err) {
+        assert.strictEqual(err.message, 'Value cannot be undefined', 'Undefined value error message mismatch');
+    }
+    console.log('✓ Undefined value handling passed');
+
+    // Test 7: Encryption
+    console.log('\nTest 7: Encryption');
+    const encDbPath = path.join(__dirname, '..', 'db', 'encryption-test.json');
+    // Clean up before test
+    try { await fs.unlink(encDbPath); } catch (e) {}
+    const EncryptedMinoDB = require('../src/index');
+    const encryptedDb = new EncryptedMinoDB('encryption-password', true);
+    encryptedDb.dbPath = encDbPath;
+    await encryptedDb.set('encrypted-key', 'sensitive-data');
+    
+    // Try to read with wrong password
+    const wrongDb = new EncryptedMinoDB('wrong-password', true);
+    wrongDb.dbPath = encDbPath;
+    try {
+        await wrongDb.get('encrypted-key');
+        assert.fail('Should have thrown error for wrong password');
+    } catch (err) {
+        assert(
+            err.message.includes('decrypt') || 
+            err.message.includes('unable to authenticate') ||
+            err.message.includes('Unsupported state'),
+            'Wrong password error message mismatch'
+        );
+    }
+    console.log('✓ Encryption handling passed');
+    // Clean up after test
+    try { await fs.unlink(encDbPath); } catch (e) {}
+
+    // Cleanup
+    await cleanup();
+    console.log('\nAll tests passed successfully! 🎉');
+}
+
+// Run the tests
+runTests().catch(err => {
+    console.error('Test failed:', err);
+    process.exit(1);
+}); 

package/src/cli.js

@@ -1,86 +0,0 @@
-#!/usr/bin/env node
-
-const path = require('path');
-const fs = require('fs-extra');
-const inquirer = require('inquirer');
-const MiloDB = require(path.join(__dirname, 'milodb'));  // Ensure correct path
-
-// Function to initialize the database
-async function initDatabase() {
-  const dbPath = path.join(process.cwd(), 'db');  // Set the path where the database will be stored
-
-  try {
-    // Ask the user if they want to encrypt the data
-    const { encryptData } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'encryptData',
-        message: 'Do you want to encrypt the data?',
-        default: false
-      }
-    ]);
-
-    // If encryption is chosen, ask for an email to use as a key
-    let email = '';
-    if (encryptData) {
-      const emailAnswer = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'email',
-          message: 'Enter your email to use for encryption:',
-          validate: (input) => input.includes('@') ? true : 'Please enter a valid email address'
-        }
-      ]);
-      email = emailAnswer.email;
-    }
-
-    // Ask if they want to create the "users" table
-    const { createUsersTable } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'createUsersTable',
-        message: 'Do you want to create a default "users" table?',
-        default: true
-      }
-    ]);
-
-    // Create the configuration file with encryption settings
-    const config = {
-      encryptData,
-      email,
-    };
-
-    await fs.writeFile(path.join(process.cwd(), 'milo.config.js'), `module.exports = ${JSON.stringify(config, null, 2)};`, 'utf-8');
-
-    console.log('Configuration saved in milo.config.js');
-    
-    // Create a new instance of MiloDB
-    const db = new MiloDB(dbPath, encryptData); // Pass encryption setting to MiloDB
-
-    // Ensure the database folder exists
-    await fs.ensureDir(dbPath);
-
-    console.log(`Database initialized at: ${dbPath}`);
-
-    // Optionally create the users table
-    if (createUsersTable) {
-      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

@@ -1,24 +0,0 @@
-// 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

@@ -1,102 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const { encrypt, decrypt } = require('./encrypt');
-
-class MiloDB {
-  constructor(dbPath = path.join(process.cwd(), '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;