kive.db ✨

A modern, fast, and efficient key-value database for Node.js

Features

• 🚀 Blazing fast performance with memory caching
• 📝 Schema validation with custom rules
• 🔍 Powerful query builder
• 💾 Persistent storage with atomic writes
• 🧵 Concurrent access support
• 📦 Zero-dependency (optional dependencies for advanced features)

Installation

npm install kive.db@latest

Quick Start (ES Modules)

import { KiveDB, Schema } from 'kive.db';

// Initialize with custom options
const db = new KiveDB({
  storagePath: './mydata', // Custom storage location
  cacheSize: 2000,        // Increase cache size
});

// Define a schema
const blogSchema = new Schema({
  title: { type: String, required: true },
  content: String,
  tags: [String],
  views: { type: Number, default: 0 },
  publishedAt: { type: Date, default: Date.now }
});

// Create a model
const Blog = db.model('Blog', blogSchema);

// Add middleware
blogSchema.pre('save', async (data) => {
  console.log(`Saving blog: ${data.title}`);
});

// Usage example
async function main() {
  const article = await Blog.create({
    title: 'Getting Started with kive.db',
    content: '...',
    tags: ['database', 'nodejs']
  });

  console.log('Created article:', article);

  // Find articles with more than 100 views
  const popular = await Blog.find()
    .where('views').gt(100)
    .limit(5)
    .exec();

  console.log('Popular articles:', popular);
}

main().catch(console.error);

CommonJS Usage

const { KiveDB, Schema } = require('kive.db');
// ... same API as ESM version

API Reference

new KiveDB(options)

Create a new database instance.

Options:

• storagePath: Path to store data files (default: './data')
• cacheSize: Maximum items in cache (default: 1000)
• writeBufferSize: Bytes to buffer before writing (default: 16384)

Schema(definition)

Define a schema for your data.

Definition properties:

• type: Data type (String, Number, Date, etc.)
• required: Mark field as required
• default: Default value
• validate: Custom validation function/regex

Model API

• create(data): Create new document
• findById(id): Find by primary key
• find([query]): Create query builder
• updateOne(query, update): Update first matching document
• deleteOne(query): Delete first matching document
• compact(): Optimize storage

Query Builder

Chainable methods:

• where(field): Field to query
• equals(value): Exact match
• gt(value): Greater than
• lt(value): Less than
• in(array): Match any value in array
• limit(n): Maximum results
• skip(n): Skip first n results
• exec(): Execute query
• findOne(): Get first result

Performance Tips

1. Increase cache size for read-heavy applications:

   const db = new KiveDB({ cacheSize: 5000 });

2. Batch writes by default - no need to manually batch operations.

3. Run compaction periodically for large datasets:

   await Blog.compact();

4. Use indexes for frequently queried fields (automatic for _id).

License

This project is licensed under the Apache-2.0 License. See the LICENSE file for details.

Contact

If you have any questions, feel free to reach out to the author:

• Name: Iscordian
• Email: [email protected]
• Discord: iscordian.dev
• Discord Server: https://discord.gg/GQBWcyR9Cp