LiekoDB Documentation

npm install liekodb

yarn add liekodb

const LiekoDB = require('liekodb');

const db = new LiekoDB({
  storagePath: './storage',
  debug: true
});

const users = db.collection('users');

const db = new LiekoDB({
  storagePath: './storage',      // Storage directory
  autoSaveInterval: 5000,         // Auto-save every 5s
  debug: true                     // Enable detailed logs
});

const db = new LiekoDB({
  databaseUrl: 'http://127.0.0.1:8050',
  token: 'your-auth-token',       // Required for HTTP mode
  poolSize: 10,                   // Connection pool size
  timeout: 15000,                 // Request timeout (ms)
  debug: true
});

const LiekoDB = require('liekodb');

const db = new LiekoDB({
    storagePath: './storage',
    debug: true
});

const users = db.collection('users');

async function basicCRUD() {
    // Insert users
    console.log('=== Inserting users ===');
    await users.insert([
        { username: 'alice', email: 'alice@example.com', age: 28, role: 'admin' },
        { username: 'bob', email: 'bob@example.com', age: 32, role: 'user' },
        { username: 'charlie', email: 'charlie@example.com', age: 25, role: 'user' }
    ]);

    // Find all users
    console.log('\n=== Finding all users ===');
    const { data: allUsers } = await users.find();
    console.log(`Found ${allUsers.foundCount} users`);

    // Find specific user
    console.log('\n=== Finding user by email ===');
    const { data: alice } = await users.findOne({ email: 'alice@example.com' });
    console.log('User:', alice);

    // Update user
    console.log('\n=== Updating user ===');
    await users.update(
        { username: 'alice' },
        { $set: { age: 29 } }
    );

    // Delete user
    console.log('\n=== Deleting user ===');
    await users.delete({ username: 'charlie' });

    // Final count
    const count = await users.count();
    console.log(`\nFinal count: ${count.data} users`);

    await db.close();
}

basicCRUD().catch(console.error);

const LiekoDB = require('liekodb');

const db = new LiekoDB({
    storagePath: './storage',
    debug: true
});

const products = db.collection('products');

async function paginationExample() {
    // Insert sample products
    console.log('=== Inserting products ===');
    const productList = [];
    for (let i = 1; i <= 50; i++) {
        productList.push({
            name: `Product ${i}`,
            price: Math.floor(Math.random() * 1000) + 10,
            category: ['Electronics', 'Clothing', 'Books', 'Home'][Math.floor(Math.random() * 4)],
            stock: Math.floor(Math.random() * 100)
        });
    }
    await products.insert(productList);

    // Paginated query
    console.log('\n=== Page 1 (10 items per page) ===');
    const { data: page1 } = await products.find(
        { price: { $gte: 100 } },
        {
            sort: { price: -1 },
            limit: 10,
            page: 1,
            fields: { name: 1, price: 1, category: 1 }
        }
    );

    console.log(`Found ${page1.foundCount} products on this page`);
    console.log(`Total matching: ${page1.pagination.total}`);
    console.log(`Page ${page1.pagination.page} of ${page1.pagination.totalPages}`);
    console.log(`Has next page: ${page1.pagination.hasNext}`);

    page1.foundDocuments.forEach((product, idx) => {
        console.log(`${idx + 1}. ${product.name} - $${product.price}`);
    });

    // Get next page
    if (page1.pagination.hasNext) {
        console.log('\n=== Page 2 ===');
        const { data: page2 } = await products.find(
            { price: { $gte: 100 } },
            {
                sort: { price: -1 },
                limit: 10,
                page: 2,
                fields: { name: 1, price: 1 }
            }
        );

        page2.foundDocuments.forEach((product, idx) => {
            console.log(`${idx + 1}. ${product.name} - $${product.price}`);
        });
    }

    await db.close();
}

paginationExample().catch(console.error);

const LiekoDB = require('liekodb');

const db = new LiekoDB({
    storagePath: './storage',
    debug: true
});

const orders = db.collection('orders');

async function advancedFiltering() {
    // Insert sample orders
    console.log('=== Inserting orders ===');
    await orders.insert([
        {
            orderId: 'ORD001',
            customer: { name: 'Alice', email: 'alice@example.com', vip: true },
            items: ['laptop', 'mouse', 'keyboard'],
            total: 1250.50,
            status: 'completed',
            shippedAt: '2025-01-05T10:00:00Z'
        },
        {
            orderId: 'ORD002',
            customer: { name: 'Bob', email: 'bob@example.com', vip: false },
            items: ['phone'],
            total: 899.99,
            status: 'pending',
            shippedAt: null
        },
        {
            orderId: 'ORD003',
            customer: { name: 'Charlie', email: 'charlie@gmail.com', vip: true },
            items: ['tablet', 'case'],
            total: 450.00,
            status: 'completed',
            shippedAt: '2025-01-07T14:30:00Z'
        },
        {
            orderId: 'ORD004',
            customer: { name: 'Diana', email: 'diana@example.com', vip: false },
            items: ['headphones'],
            total: 150.00,
            status: 'cancelled',
            shippedAt: null
        },
        {
            orderId: 'ORD005',
            customer: { name: 'Eve', email: 'eve@gmail.com', vip: true },
            items: ['monitor', 'cable', 'adapter'],
            total: 650.00,
            status: 'pending',
            shippedAt: null
        }
    ]);

    // Complex filter 1: VIP customers with completed orders over $500
    console.log('\n=== VIP customers with completed orders > $500 ===');
    const { data: vipOrders } = await orders.find({
        'customer.vip': true,
        status: 'completed',
        total: { $gt: 500 }
    });
    console.log(`Found ${vipOrders.foundCount} orders`);
    vipOrders.foundDocuments.forEach(order => {
        console.log(`- ${order.orderId}: ${order.customer.name} - $${order.total}`);
    });

    // Complex filter 2: Gmail users OR orders with multiple items
    console.log('\n=== Gmail users OR orders with 3+ items ===');
    const { data: complexOrders } = await orders.find({
        $or: [
            { 'customer.email': { $regex: /@gmail\.com$/ } },
            { items: { $exists: true } }
        ]
    });

    const filtered = complexOrders.foundDocuments.filter(order =>
        order.customer.email.includes('@gmail.com') || order.items.length >= 3
    );

    console.log(`Found ${filtered.length} orders`);
    filtered.forEach(order => {
        console.log(`- ${order.orderId}: ${order.items.length} items, ${order.customer.email}`);
    });

    // Complex filter 3: Pending or cancelled, not shipped, under $1000
    console.log('\n=== Pending/Cancelled, not shipped, under $1000 ===');
    const { data: pendingOrders } = await orders.find({
        status: { $in: ['pending', 'cancelled'] },
        shippedAt: null,
        total: { $lt: 1000 }
    });
    console.log(`Found ${pendingOrders.foundCount} orders`);
    pendingOrders.foundDocuments.forEach(order => {
        console.log(`- ${order.orderId}: ${order.status} - $${order.total}`);
    });

    // Complex filter 4: NOT cancelled AND (VIP OR total > $800)
    console.log('\n=== Active orders: VIP or high value ===');
    const { data: activeOrders } = await orders.find({
        status: { $ne: 'cancelled' },
        $or: [
            { 'customer.vip': true },
            { total: { $gte: 800 } }
        ]
    });
    console.log(`Found ${activeOrders.foundCount} orders`);
    activeOrders.foundDocuments.forEach(order => {
        console.log(`- ${order.orderId}: ${order.customer.name} (VIP: ${order.customer.vip}) - $${order.total}`);
    });

    // Complex filter 5: NOR query - exclude both cancelled and low-value orders
    console.log('\n=== Exclude cancelled AND orders under $200 ===');
    const { data: qualityOrders } = await orders.find({
        $nor: [
            { status: 'cancelled' },
            { total: { $lt: 200 } }
        ]
    });
    console.log(`Found ${qualityOrders.foundCount} orders`);
    qualityOrders.foundDocuments.forEach(order => {
        console.log(`- ${order.orderId}: ${order.status} - $${order.total}`);
    });

    await db.close();
}

advancedFiltering().catch(console.error);

const LiekoDB = require('liekodb');

const db = new LiekoDB({
    storagePath: './storage',
    debug: true
});

const profiles = db.collection('profiles');

async function updateOperations() {
    // Insert initial profile
    console.log('=== Inserting profile ===');
    const { data: insertResult } = await profiles.insert({
        username: 'john_doe',
        email: 'john@example.com',
        stats: {
            loginCount: 0,
            lastLogin: null,
            points: 100
        },
        tags: ['new'],
        preferences: {
            theme: 'light',
            notifications: true
        }
    });

    const userId = insertResult.insertedIds[0];

    // $inc - Increment login count
    console.log('\n=== Incrementing login count ===');
    await profiles.updateById(userId, {
        $inc: { 'stats.loginCount': 1 },
        $set: { 'stats.lastLogin': new Date().toISOString() }
    });

    // $push - Add tags
    console.log('\n=== Adding tags ===');
    await profiles.updateById(userId, {
        $push: { tags: 'active' }
    });

    // $addToSet - Add tag without duplicates
    console.log('\n=== Adding unique tag ===');
    await profiles.updateById(userId, {
        $addToSet: { tags: 'verified' }
    });
    await profiles.updateById(userId, {
        $addToSet: { tags: 'verified' }  // Won't create duplicate
    });

    // Multiple operations
    console.log('\n=== Multiple updates ===');
    await profiles.updateById(userId, {
        $inc: { 'stats.points': 50, 'stats.loginCount': 1 },
        $set: { 'preferences.theme': 'dark' },
        $push: { tags: 'premium' }
    });

    // $pull - Remove tag
    console.log('\n=== Removing tag ===');
    await profiles.updateById(userId, {
        $pull: { tags: 'new' }
    });

    // Get final state
    const { data: finalProfile } = await profiles.findById(userId);
    console.log('\n=== Final profile ===');
    console.log(JSON.stringify(finalProfile, null, 2));

    await db.close();
}

updateOperations().catch(console.error);

const LiekoDB = require('liekodb');

const db = new LiekoDB({
    storagePath: './storage',
    autoSaveInterval: 10000,
    debug: true
});

const analytics = db.collection('analytics');

async function bulkOperations() {
    console.log('=== Bulk Insert Performance Test ===');

    // Generate large dataset
    const events = [];
    const startTime = Date.now();

    for (let i = 1; i <= 10000; i++) {
        events.push({
            eventType: ['click', 'view', 'purchase', 'signup'][Math.floor(Math.random() * 4)],
            userId: `user_${Math.floor(Math.random() * 1000)}`,
            timestamp: new Date(Date.now() - Math.random() * 30 * 24 * 60 * 60 * 1000).toISOString(),
            value: Math.floor(Math.random() * 100),
            metadata: {
                device: ['mobile', 'desktop', 'tablet'][Math.floor(Math.random() * 3)],
                country: ['US', 'UK', 'FR', 'DE', 'JP'][Math.floor(Math.random() * 5)]
            }
        });
    }

    console.log(`Generated ${events.length} events in ${Date.now() - startTime}ms`);

    // Bulk insert
    const insertStart = Date.now();
    const { data: insertResult } = await analytics.insert(events);
    console.log(`Inserted ${insertResult.insertedCount} documents in ${Date.now() - insertStart}ms`);

    // Bulk update - mark recent purchases
    console.log('\n=== Bulk Update ===');
    const updateStart = Date.now();
    const recentDate = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();

    const { data: updateResult } = await analytics.update(
        {
            eventType: 'purchase',
            timestamp: { $gte: recentDate }
        },
        { $set: { processed: true } },
        { returnType: 'count' }
    );
    console.log(`Updated ${updateResult.updatedCount} documents in ${Date.now() - updateStart}ms`);

    // Aggregate queries
    console.log('\n=== Statistics ===');

    const { data: byType } = await analytics.find();
    const typeCount = {};
    byType.foundDocuments.forEach(event => {
        typeCount[event.eventType] = (typeCount[event.eventType] || 0) + 1;
    });
    console.log('Events by type:', typeCount);

    const { data: mobileUsers } = await analytics.find({
        'metadata.device': 'mobile',
        eventType: 'purchase'
    });
    console.log(`Mobile purchases: ${mobileUsers.foundCount}`);

    // Cleanup old events
    console.log('\n=== Cleanup ===');
    const oldDate = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000).toISOString();
    const { data: deleteResult } = await analytics.delete({
        timestamp: { $lt: oldDate }
    });
    console.log(`Deleted ${deleteResult.deletedCount} old events`);

    const finalCount = await analytics.count();
    console.log(`Final count: ${finalCount.data} events`);

    await db.close();
}

bulkOperations().catch(console.error);

const LiekoDB = require('liekodb');

const db = new LiekoDB({
    storagePath: './storage',
    debug: true
});

const products = db.collection('products');
const customers = db.collection('customers');
const orders = db.collection('orders');

async function ecommerceExample() {
    // Setup products
    console.log('=== Setting up products ===');
    await products.insert([
        { sku: 'LAPTOP-001', name: 'Pro Laptop', price: 1299.99, stock: 15, category: 'Electronics' },
        { sku: 'MOUSE-001', name: 'Wireless Mouse', price: 29.99, stock: 50, category: 'Accessories' },
        { sku: 'KEYBOARD-001', name: 'Mechanical Keyboard', price: 89.99, stock: 30, category: 'Accessories' },
        { sku: 'MONITOR-001', name: '4K Monitor', price: 449.99, stock: 20, category: 'Electronics' },
        { sku: 'HEADSET-001', name: 'Gaming Headset', price: 79.99, stock: 25, category: 'Accessories' }
    ]);

    // Register customers
    console.log('\n=== Registering customers ===');
    const { data: customer1 } = await customers.insert({
        name: 'Alice Johnson',
        email: 'alice@example.com',
        address: {
            street: '123 Main St',
            city: 'New York',
            country: 'US'
        },
        loyaltyPoints: 0,
        orders: []
    });

    const customerId = customer1.insertedIds[0];

    // Create order
    console.log('\n=== Creating order ===');
    const orderItems = [
        { sku: 'LAPTOP-001', quantity: 1, price: 1299.99 },
        { sku: 'MOUSE-001', quantity: 2, price: 29.99 }
    ];

    const orderTotal = orderItems.reduce((sum, item) =>
        sum + (item.price * item.quantity), 0
    );

    const { data: orderResult } = await orders.insert({
        customerId: customerId,
        items: orderItems,
        total: orderTotal,
        status: 'pending',
        shippingAddress: {
            street: '123 Main St',
            city: 'New York',
            country: 'US'
        }
    });

    const orderId = orderResult.insertedIds[0];

    // Update inventory
    console.log('\n=== Updating inventory ===');
    for (const item of orderItems) {
        await products.update(
            { sku: item.sku },
            { $inc: { stock: -item.quantity } }
        );
    }

    // Add loyalty points (10% of total)
    const pointsEarned = Math.floor(orderTotal * 0.1);
    await customers.updateById(customerId, {
        $inc: { loyaltyPoints: pointsEarned },
        $push: { orders: orderId }
    });

    // Process order
    console.log('\n=== Processing order ===');
    await orders.updateById(orderId, {
        $set: {
            status: 'shipped',
            shippedAt: new Date().toISOString()
        }
    });

    // Generate reports
    console.log('\n=== Sales Report ===');

    // Low stock products
    const { data: lowStock } = await products.find(
        { stock: { $lt: 20 } },
        { sort: { stock: 1 } }
    );
    console.log(`\nLow stock products (${lowStock.foundCount}):`);
    lowStock.foundDocuments.forEach(product => {
        console.log(`- ${product.name}: ${product.stock} units`);
    });

    // Customer summary
    const { data: customer } = await customers.findById(customerId);
    console.log(`\nCustomer: ${customer.name}`);
    console.log(`Loyalty Points: ${customer.loyaltyPoints}`);
    console.log(`Total Orders: ${customer.orders.length}`);

    // Orders by status
    const { data: pendingOrders } = await orders.count({ status: 'pending' });
    const { data: shippedOrders } = await orders.count({ status: 'shipped' });
    console.log(`\nOrders Summary:`);
    console.log(`- Pending: ${pendingOrders}`);
    console.log(`- Shipped: ${shippedOrders}`);

    await db.close();
}

ecommerceExample().catch(console.error);

const LiekoDB = require('liekodb');

const db = new LiekoDB({
    storagePath: './storage',
    debug: true
});

const sessions = db.collection('sessions');
const pageViews = db.collection('pageViews');

async function analyticsExample() {
    // Simulate user sessions
    console.log('=== Generating session data ===');

    const users = ['user_1', 'user_2', 'user_3', 'user_4', 'user_5'];
    const pages = ['/home', '/products', '/about', '/contact', '/checkout'];

    // Create sessions
    for (let i = 0; i < 20; i++) {
        const userId = users[Math.floor(Math.random() * users.length)];
        const startTime = new Date(Date.now() - Math.random() * 24 * 60 * 60 * 1000);
        const duration = Math.floor(Math.random() * 1800) + 60; // 1-30 min

        await sessions.insert({
            userId,
            startTime: startTime.toISOString(),
            endTime: new Date(startTime.getTime() + duration * 1000).toISOString(),
            duration,
            device: ['mobile', 'desktop'][Math.floor(Math.random() * 2)],
            browser: ['Chrome', 'Firefox', 'Safari'][Math.floor(Math.random() * 3)],
            pagesVisited: Math.floor(Math.random() * 10) + 1
        });
    }

    // Generate page views
    for (let i = 0; i < 100; i++) {
        await pageViews.insert({
            userId: users[Math.floor(Math.random() * users.length)],
            page: pages[Math.floor(Math.random() * pages.length)],
            timestamp: new Date(Date.now() - Math.random() * 24 * 60 * 60 * 1000).toISOString(),
            duration: Math.floor(Math.random() * 300) + 10
        });
    }

    // Analytics queries
    console.log('\n=== Dashboard Analytics ===');

    // Total sessions by device
    const { data: allSessions } = await sessions.find();
    const deviceStats = {};
    allSessions.foundDocuments.forEach(session => {
        deviceStats[session.device] = (deviceStats[session.device] || 0) + 1;
    });
    console.log('\nSessions by device:', deviceStats);

    // Active users (sessions in last hour)
    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
    const { data: recentSessions } = await sessions.find({
        startTime: { $gte: oneHourAgo }
    });
    const activeUsers = new Set(recentSessions.foundDocuments.map(s => s.userId));
    console.log(`\nActive users (last hour): ${activeUsers.size}`);

    // Average session duration
    const totalDuration = allSessions.foundDocuments.reduce((sum, s) => sum + s.duration, 0);
    const avgDuration = Math.floor(totalDuration / allSessions.foundCount);
    console.log(`Average session duration: ${Math.floor(avgDuration / 60)}m ${avgDuration % 60}s`);

    // Most visited pages
    const { data: allViews } = await pageViews.find();
    const pageStats = {};
    allViews.foundDocuments.forEach(view => {
        pageStats[view.page] = (pageStats[view.page] || 0) + 1;
    });

    console.log('\nMost visited pages:');
    Object.entries(pageStats)
        .sort((a, b) => b[1] - a[1])
        .forEach(([page, count]) => {
            console.log(`  ${page}: ${count} views`);
        });

    // Long sessions (> 10 minutes)
    const { data: longSessions } = await sessions.find({
        duration: { $gt: 600 }
    });
    console.log(`\nEngaged users (sessions > 10min): ${longSessions.foundCount}`);

    // Mobile vs Desktop engagement
    const { data: mobileSessions } = await sessions.find({ device: 'mobile' });
    const mobileAvg = mobileSessions.foundDocuments.reduce((sum, s) => sum + s.pagesVisited, 0)
        / mobileSessions.foundCount;

    const { data: desktopSessions } = await sessions.find({ device: 'desktop' });
    const desktopAvg = desktopSessions.foundDocuments.reduce((sum, s) => sum + s.pagesVisited, 0)
        / desktopSessions.foundCount;

    console.log(`\nAverage pages per session:`);
    console.log(`  Mobile: ${mobileAvg.toFixed(1)}`);
    console.log(`  Desktop: ${desktopAvg.toFixed(1)}`);

    await db.close();
}

analyticsExample().catch(console.error);