🗄️ Rockdex DB

// Create a database instance
const RockdexDB = require('@odion-cloud/rockdex-db');
const db = new RockdexDB({
    storageMode: 'memory',
    logging: true
});

// Create table and insert data
db.createTable('users');
db.insert('users', {
    name: 'John Doe',
    email: 'john@example.com',
    age: 30
});

// Query with advanced conditions
const adults = db
    .whereOperator('age', '>=', 18)
    .orderBy('name')
    .get('users');

console.log('Adult users:', adults);

            // Enable performance optimizations
            const db = new RockdexDB({
                storageMode: 'memory',        // Works with both 'memory' and 'file'
                performance: true,            // Enable all optimizations
    autoIndex: true,              // Auto-create indexes
    chunkSize: 10000,             // Records per memory chunk
    maxMemoryChunks: 5,           // Max chunks in RAM
    compression: true,            // Enable compression
    logging: true                 // Performance logging
});

// Manual index creation for critical queries
db.createIndex('users', 'email');     // Fast email lookups
db.createIndex('orders', 'userId');   // Fast user order queries
db.createIndex('products', 'price');  // Fast price range searches

// Handle millions of records without memory issues
const db = new RockdexDB({
    chunkSize: 10000,         // 10K records per chunk
    maxMemoryChunks: 5        // Keep max 5 chunks in RAM
});

// Process large datasets efficiently
const millionRecords = generateLargeDataset(1000000);
await db.bulkInsert('analytics', millionRecords);

// Lightning-fast queries on large datasets
const results = await db.whereOperator('score', '>', 800)
                       .where('category', 'premium') 
                       .limit(100)
                       .get('analytics');
// Query time: ~0.8ms on 1M records!

// Get detailed performance metrics
const metrics = db.getPerformanceMetrics();
console.log(metrics);
// {
//   averageQueryTime: '0.45ms',
//   totalQueries: 1250,
//   indexUsage: 892,
//   cacheHitRate: 0.85,
//   tablesWithIndexes: 3,
//   totalIndexes: 8
// }

// Run built-in benchmarks
await db.benchmark(100000);  // Test with 100K records

// 🏆 BENCHMARK RESULTS:
// ├─ Test Records: 100,000
// ├─ Array Search: 45.67ms (2,456 results)
// ├─ RockdexDB Search: 1.23ms (2,456 results)  
// ├─ 🚄 Speed Improvement: 37.1x faster
// ├─ 📈 Efficiency Gain: 97.3% improvement
// └─ 🧠 Memory Optimized: 10 chunks loaded

// Performance-optimized bulk operations
const largeDataset = [];
for (let i = 0; i < 100000; i++) {
    largeDataset.push({
        id: i,
        name: `User ${i}`,
        email: `user${i}@example.com`,
        department: `Dept${Math.floor(i / 1000)}`,
        salary: Math.floor(Math.random() * 100000) + 30000
    });
}

// Optimized bulk insert with chunking
console.time('Bulk Insert');
await db.bulkInsert('employees', largeDataset);
console.timeEnd('Bulk Insert');
// Bulk Insert: ~890ms for 100K records

// Lightning-fast indexed queries
const highEarners = await db.whereOperator('salary', '>', 80000)
                           .where('department', 'Dept5')
                           .orderBy('salary', 'DESC')
                           .limit(50)
                           .get('employees');
// Query time: ~1.2ms with indexes!

// Schema with indexing optimization
const optimizedSchema = {
    id: { type: 'number', required: true, indexed: true },        // Primary key
    email: { type: 'string', required: true, indexed: true },     // Fast lookups
    age: { type: 'number', indexed: true },                       // Range queries
    department: { type: 'string', indexed: true },               // Filtering
    name: { type: 'string', indexed: false },                    // No index needed
    bio: { type: 'string', indexed: false }                      // Large text field
};

db.createTable('users', optimizedSchema);
// ✅ Automatically creates indexes for: id, email, age, department
// ✅ Skips indexing for: name, bio (saves memory)

# Install via npm
npm install @odion-cloud/rockdex-db

# Or install via yarn  
yarn add @odion-cloud/rockdex-db

<!-- Include via CDN -->
<script src="https://unpkg.com/@odion-cloud/rockdex-db@latest/rockdex-db.min.js"></script>

<script>
// Use in browser (memory mode recommended)
const db = new RockdexDB({
    storageMode: 'memory',
    logging: true
});
</script>

const RockdexDB = require('@odion-cloud/rockdex-db');

// Create database instance
const db = new RockdexDB({
    storageMode: 'memory',
    logging: true,
    timestamps: true
});

// Create a table
db.createTable('users');

// Insert data
db.insert('users', {
    name: 'John Doe',
    email: 'john@example.com',
    age: 30
});

// Query data
const users = await db.get('users');
console.log('All users:', users);

// Advanced queries
const adults = await db
    .whereOperator('age', '>=', 18)
    .orderBy('name')
    .get('users');

console.log('Adult users:', adults);

// Define schema for validation
const userSchema = {
    name: { type: 'string', required: true },
    email: { type: 'string', required: true, pattern: /^\S+@\S+\.\S+$/ },
    age: { type: 'number', min: 0, max: 150 }
};

// Create table with schema
db.createTable('validated_users', userSchema);

try {
    db.insert('validated_users', {
        name: 'Jane Doe',
        email: 'jane@example.com',
        age: 25
    });
    console.log('User inserted successfully!');
} catch (error) {
    console.error('Validation error:', error.message);
}

// 1. Create database folder and files manually
// mkdir ./database
// touch ./database/users.rdb
// touch ./database/products.rdb

// 2. Configure for file mode
const db = new RockdexDB({
    storageMode: 'file',
    storagePath: './database',
    storageTable: ['users.rdb', 'products.rdb']
});

// 3. Use normally - data persists to files
db.insert('users', { name: 'John', email: 'john@example.com' });
db.insert('products', { name: 'Laptop', price: 999 });

// 4. Export/import for backups
const userData = db.getTableExport('users');
// Save userData to backup or transfer to another system

const RockdexDB = require('@odion-cloud/rockdex-db');

// Initialize e-commerce database
const db = new RockdexDB({
    storageMode: 'file',
    storagePath: './ecommerce-db',
    storageTable: ['products.rdb', 'customers.rdb', 'orders.rdb'],
    timestamps: true,
    logging: true
});

// Product schema
const productSchema = {
    name: { type: 'string', required: true },
    price: { type: 'number', required: true, min: 0 },
    category: { type: 'string', required: true },
    stock: { type: 'number', required: true, min: 0 },
    sku: { type: 'string', required: true }
};

db.createTable('products', productSchema);
db.createTable('customers');
db.createTable('orders');

// Add products
db.insert('products', {
    name: 'Gaming Laptop',
    price: 1299.99,
    category: 'Electronics',
    stock: 25,
    sku: 'LAPTOP-GAMING-001'
});

db.insert('products', {
    name: 'Wireless Mouse',
    price: 49.99,
    category: 'Electronics', 
    stock: 100,
    sku: 'MOUSE-WIRELESS-001'
});

// Find products by category and price range
const affordableElectronics = await db
    .where('category', 'Electronics')
    .whereOperator('price', '<', 100)
    .whereOperator('stock', '>', 0)
    .orderBy('price', 'ASC')
    .get('products');

console.log('Affordable electronics:', affordableElectronics);

// Customer registration
db.insert('customers', {
    name: 'Alice Johnson',
    email: 'alice@example.com',
    address: '123 Main St, Anytown USA',
    memberSince: new Date().toISOString()
});

// Order processing with transaction
db.transaction(db => {
    const customerId = db.getLastInsertId();
    
    // Create order
    db.insert('orders', {
        customerId: customerId,
        products: ['LAPTOP-GAMING-001'],
        total: 1299.99,
        status: 'pending'
    });
    
    // Update inventory
    db.where('sku', 'LAPTOP-GAMING-001')
      .update('products', { stock: 24 });
});

console.log('Order processed successfully!');

// User management with roles and permissions
const db = new RockdexDB({
    storageMode: 'memory',
    timestamps: true,
    softDelete: true  // Enable soft deletion
});

const userSchema = {
    username: { type: 'string', required: true },
    email: { type: 'string', required: true, pattern: /^\S+@\S+\.\S+$/ },
    role: { type: 'string', required: true },
    active: { type: 'boolean', required: true }
};

db.createTable('users', userSchema);
db.createTable('sessions');
db.createTable('audit_log');

// Add audit trigger
db.createTrigger('users', 'afterUpdate', ({ OLD, NEW }) => {
    db.insert('audit_log', {
        action: 'user_updated',
        userId: NEW.id,
        changes: { 
            old: OLD,
            new: NEW
        },
        timestamp: new Date().toISOString()
    });
});

// Create users
const users = [
    { username: 'admin', email: 'admin@company.com', role: 'admin', active: true },
    { username: 'john_doe', email: 'john@company.com', role: 'user', active: true },
    { username: 'jane_smith', email: 'jane@company.com', role: 'moderator', active: true }
];

users.forEach(user => db.insert('users', user));

// Find all active moderators
const moderators = await db
    .where('role', 'moderator')
    .where('active', true)
    .get('users');

// User login simulation
function loginUser(username) {
    const user = db.where('username', username).getOne('users');
    
    if (user && user.active) {
        // Create session
        db.insert('sessions', {
            userId: user.id,
            token: 'session_' + Date.now(),
            expiresAt: new Date(Date.now() + 24*60*60*1000).toISOString()
        });
        
        return { success: true, user, message: 'Login successful' };
    }
    
    return { success: false, message: 'Invalid credentials' };
}

const loginResult = loginUser('john_doe');
console.log('Login result:', loginResult);

// Analytics with aggregations and reporting
const db = new RockdexDB({
    storageMode: 'memory',
    performance: true,  // Enable performance optimizations
    autoIndex: true     // Auto-create indexes
});

db.createTable('page_views');
db.createTable('user_events');

// Simulate analytics data
function generateAnalyticsData() {
    const pages = ['/home', '/products', '/about', '/contact', '/blog'];
    const events = ['click', 'scroll', 'form_submit', 'download'];
    
    for (let i = 0; i < 10000; i++) {
        // Page views
        db.insert('page_views', {
            page: pages[Math.floor(Math.random() * pages.length)],
            userId: Math.floor(Math.random() * 1000),
            timestamp: new Date(Date.now() - Math.random() * 30*24*60*60*1000).toISOString(),
            duration: Math.floor(Math.random() * 300) + 10,
            source: Math.random() > 0.5 ? 'organic' : 'paid'
        });
        
        // User events  
        db.insert('user_events', {
            event: events[Math.floor(Math.random() * events.length)],
            userId: Math.floor(Math.random() * 1000),
            value: Math.floor(Math.random() * 100),
            timestamp: new Date(Date.now() - Math.random() * 30*24*60*60*1000).toISOString()
        });
    }
}

// Generate test data
generateAnalyticsData();

// Analytics queries
const totalPageViews = db.count('page_views');
const avgDuration = db.avg('page_views', 'duration');
const topPages = db.groupBy('page_views', 'page');

// Popular pages ranking
const pageStats = Object.entries(topPages)
    .map(([page, views]) => ({ page, count: views.length }))
    .sort((a, b) => b.count - a.count)
    .slice(0, 5);

console.log('Analytics Report:');
console.log('Total page views:', totalPageViews);
console.log('Average duration:', Math.round(avgDuration), 'seconds');
console.log('Top pages:', pageStats);

// User behavior analysis
const activeUsers = await db
    .whereOperator('timestamp', '>', new Date(Date.now() - 7*24*60*60*1000).toISOString())
    .distinct('user_events', 'userId');

console.log('Active users (last 7 days):', activeUsers.length);

const crypto = require('crypto');

// Simple encryption helpers
function encrypt(text, password) {
    const cipher = crypto.createCipher('aes-256-cbc', password);
    let encrypted = cipher.update(text, 'utf8', 'hex');
    encrypted += cipher.final('hex');
    return encrypted;
}

function decrypt(encryptedText, password) {
    const decipher = crypto.createDecipher('aes-256-cbc', password);
    let decrypted = decipher.update(encryptedText, 'hex', 'utf8');
    decrypted += decipher.final('utf8');
    return decrypted;
}

// Database with manual encryption
const db = new RockdexDB({ storageMode: 'memory' });
db.createTable('secrets');

const SECRET_KEY = 'your-secret-password';

// Store encrypted sensitive data
const sensitiveData = {
    username: 'admin',
    password: 'super-secret-password',
    apiKey: 'sk-1234567890abcdef'
};

const encryptedData = encrypt(JSON.stringify(sensitiveData), SECRET_KEY);

db.insert('secrets', {
    id: 1,
    data: encryptedData,
    type: 'credentials'
});

// Retrieve and decrypt
const secret = db.where('id', 1).getOne('secrets');
const decryptedData = JSON.parse(decrypt(secret.data, SECRET_KEY));

console.log('Decrypted sensitive data:', decryptedData);

// Complete backup and restore workflow
const db = new RockdexDB({
    storageMode: 'file',
    storagePath: './app-data',
    storageTable: ['users.rdb', 'posts.rdb', 'settings.rdb']
});

// Add some data
db.insert('users', { name: 'John', email: 'john@example.com' });
db.insert('posts', { title: 'Hello World', content: 'My first post' });

// Create full database backup
const backup = db.backup();
console.log('Backup created:', backup.timestamp);

// Export individual tables
const usersExport = db.getTableExport('users');
const postsExport = db.getTableExport('posts');

// Save to files (Node.js)
const fs = require('fs');
fs.writeFileSync('./backup-users.json', usersExport);
fs.writeFileSync('./backup-posts.json', postsExport);

// Simulate data loss
db.truncate('users');
db.truncate('posts');
console.log('Data cleared');

// Restore from backup
db.restore(backup);
console.log('Data restored from backup');

// Or restore individual tables
const restoredUsers = fs.readFileSync('./backup-users.json', 'utf8');
db.importTable('users', restoredUsers);

console.log('Users restored:', db.count('users'));