dimond-db 1.0.0

package/src/database/Collection.js

@@ -0,0 +1,401 @@
+import { QueryEngine } from '../engine/QueryEngine.js';
+import { StorageEngine } from '../engine/StorageEngine.js';
+import { generateId } from '../utils/idGenerator.js';
+import { deepClone } from '../utils/deepClone.js';
+import {
+    validateDocument,
+    validateDocuments,
+    validateFilter,
+    validateUpdate
+} from '../utils/validator.js';
+import {
+    DuplicateKeyError,
+    ValidationError,
+    QueryError
+} from '../errors/DatabaseError.js';
+import { setNestedValue, deleteNestedValue, getNestedValue } from '../query/operators.js';
+
+/**
+ * Collection - Represents a collection of documents
+ */
+export class Collection {
+    /**
+     * @param {string} name - Collection name
+     * @param {StorageEngine} storageEngine - Storage engine instance
+     * @param {Database} database - Database instance
+     */
+    constructor(name, storageEngine, database) {
+        this.name = name;
+        this.storageEngine = storageEngine;
+        this.database = database;
+        this.documents = [];
+        this.loaded = false;
+    }
+
+    /**
+     * Loads the collection from disk
+     */
+    async load() {
+        if (!this.loaded) {
+            // Ensure database is initialized first
+            await this.database.ensureInitialized();
+            this.documents = await this.storageEngine.readCollection(this.name);
+            this.loaded = true;
+        }
+    }
+
+    /**
+     * Persists the collection to disk
+     */
+    async persist() {
+        await this.storageEngine.writeCollection(this.name, this.documents);
+    }
+
+    /**
+     * Inserts a single document
+     * @param {Object} doc - Document to insert
+     * @returns {Promise<Object>} Result object with insertedId
+     */
+    async insertOne(doc) {
+        await this.load();
+
+        validateDocument(doc);
+
+        const document = deepClone(doc);
+
+        // Generate _id if not provided
+        if (!document._id) {
+            document._id = generateId();
+        }
+
+        // Check for duplicate _id
+        if (this.documents.some(d => d._id === document._id)) {
+            throw new DuplicateKeyError(document._id);
+        }
+
+        this.documents.push(document);
+        await this.persist();
+
+        return {
+            acknowledged: true,
+            insertedId: document._id
+        };
+    }
+
+    /**
+     * Inserts multiple documents
+     * @param {Array} docs - Array of documents to insert
+     * @returns {Promise<Object>} Result object with insertedIds
+     */
+    async insertMany(docs) {
+        await this.load();
+
+        validateDocuments(docs);
+
+        const insertedIds = [];
+        const documents = docs.map(doc => {
+            const document = deepClone(doc);
+
+            // Generate _id if not provided
+            if (!document._id) {
+                document._id = generateId();
+            }
+
+            // Check for duplicate _id within the batch
+            if (insertedIds.includes(document._id)) {
+                throw new DuplicateKeyError(document._id);
+            }
+
+            // Check for duplicate _id in existing documents
+            if (this.documents.some(d => d._id === document._id)) {
+                throw new DuplicateKeyError(document._id);
+            }
+
+            insertedIds.push(document._id);
+            return document;
+        });
+
+        this.documents.push(...documents);
+        await this.persist();
+
+        return {
+            acknowledged: true,
+            insertedCount: documents.length,
+            insertedIds
+        };
+    }
+
+    /**
+     * Finds documents matching a filter
+     * @param {Object} filter - Query filter
+     * @returns {Promise<Array>} Array of matching documents
+     */
+    async find(filter = {}) {
+        await this.load();
+
+        validateFilter(filter);
+
+        const results = QueryEngine.find(this.documents, filter);
+        return results.map(doc => deepClone(doc));
+    }
+
+    /**
+     * Finds the first document matching a filter
+     * @param {Object} filter - Query filter
+     * @returns {Promise<Object|null>} The first matching document or null
+     */
+    async findOne(filter = {}) {
+        await this.load();
+
+        validateFilter(filter);
+
+        const result = QueryEngine.findOne(this.documents, filter);
+        return result ? deepClone(result) : null;
+    }
+
+    /**
+     * Updates a single document
+     * @param {Object} filter - Query filter
+     * @param {Object} update - Update operations
+     * @returns {Promise<Object>} Result object with matchedCount and modifiedCount
+     */
+    async updateOne(filter = {}, update) {
+        await this.load();
+
+        validateFilter(filter);
+        validateUpdate(update);
+
+        const docIndex = this.documents.findIndex(doc =>
+            QueryEngine.match(doc, filter)
+        );
+
+        if (docIndex === -1) {
+            return {
+                acknowledged: true,
+                matchedCount: 0,
+                modifiedCount: 0
+            };
+        }
+
+        const originalDoc = JSON.stringify(this.documents[docIndex]);
+        this.applyUpdate(this.documents[docIndex], update);
+        const modified = JSON.stringify(this.documents[docIndex]) !== originalDoc;
+
+        await this.persist();
+
+        return {
+            acknowledged: true,
+            matchedCount: 1,
+            modifiedCount: modified ? 1 : 0
+        };
+    }
+
+    /**
+     * Updates multiple documents
+     * @param {Object} filter - Query filter
+     * @param {Object} update - Update operations
+     * @returns {Promise<Object>} Result object with matchedCount and modifiedCount
+     */
+    async updateMany(filter = {}, update) {
+        await this.load();
+
+        validateFilter(filter);
+        validateUpdate(update);
+
+        const matchingIndices = this.documents
+            .map((doc, index) => QueryEngine.match(doc, filter) ? index : -1)
+            .filter(index => index !== -1);
+
+        let modifiedCount = 0;
+
+        for (const index of matchingIndices) {
+            const originalDoc = JSON.stringify(this.documents[index]);
+            this.applyUpdate(this.documents[index], update);
+            if (JSON.stringify(this.documents[index]) !== originalDoc) {
+                modifiedCount++;
+            }
+        }
+
+        await this.persist();
+
+        return {
+            acknowledged: true,
+            matchedCount: matchingIndices.length,
+            modifiedCount
+        };
+    }
+
+    /**
+     * Applies update operations to a document
+     * @param {Object} document - The document to update
+     * @param {Object} update - Update operations
+     */
+    applyUpdate(document, update) {
+        const operators = Object.keys(update);
+
+        // If no operators, it's a direct replacement (not recommended, but supported)
+        if (!operators.some(key => key.startsWith('$'))) {
+            throw new ValidationError('Update must use update operators ($set, $unset, etc.)');
+        }
+
+        for (const [operator, fields] of Object.entries(update)) {
+            switch (operator) {
+                case '$set':
+                    this.applySet(document, fields);
+                    break;
+                case '$unset':
+                    this.applyUnset(document, fields);
+                    break;
+                case '$inc':
+                    this.applyInc(document, fields);
+                    break;
+                case '$push':
+                    this.applyPush(document, fields);
+                    break;
+                default:
+                    throw new QueryError(`Unknown update operator: ${operator}`);
+            }
+        }
+    }
+
+    /**
+     * Applies $set operator
+     * @param {Object} document - The document to update
+     * @param {Object} fields - Fields to set
+     */
+    applySet(document, fields) {
+        for (const [path, value] of Object.entries(fields)) {
+            setNestedValue(document, path, deepClone(value));
+        }
+    }
+
+    /**
+     * Applies $unset operator
+     * @param {Object} document - The document to update
+     * @param {Object} fields - Fields to unset
+     */
+    applyUnset(document, fields) {
+        for (const path of Object.keys(fields)) {
+            deleteNestedValue(document, path);
+        }
+    }
+
+    /**
+     * Applies $inc operator
+     * @param {Object} document - The document to update
+     * @param {Object} fields - Fields to increment
+     */
+    applyInc(document, fields) {
+        for (const [path, value] of Object.entries(fields)) {
+            if (typeof value !== 'number') {
+                throw new ValidationError('$inc operator requires numeric value');
+            }
+
+            const currentValue = getNestedValue(document, path);
+
+            if (currentValue === undefined) {
+                setNestedValue(document, path, value);
+            } else if (typeof currentValue !== 'number') {
+                throw new ValidationError('$inc can only be applied to numeric fields');
+            } else {
+                setNestedValue(document, path, currentValue + value);
+            }
+        }
+    }
+
+    /**
+     * Applies $push operator
+     * @param {Object} document - The document to update
+     * @param {Object} fields - Fields to push to
+     */
+    applyPush(document, fields) {
+        for (const [path, value] of Object.entries(fields)) {
+            const currentValue = getNestedValue(document, path);
+
+            if (currentValue === undefined) {
+                setNestedValue(document, path, [deepClone(value)]);
+            } else if (!Array.isArray(currentValue)) {
+                throw new ValidationError('$push can only be applied to array fields');
+            } else {
+                currentValue.push(deepClone(value));
+            }
+        }
+    }
+
+    /**
+     * Deletes a single document
+     * @param {Object} filter - Query filter
+     * @returns {Promise<Object>} Result object with deletedCount
+     */
+    async deleteOne(filter = {}) {
+        await this.load();
+
+        validateFilter(filter);
+
+        const docIndex = this.documents.findIndex(doc =>
+            QueryEngine.match(doc, filter)
+        );
+
+        if (docIndex === -1) {
+            return {
+                acknowledged: true,
+                deletedCount: 0
+            };
+        }
+
+        this.documents.splice(docIndex, 1);
+        await this.persist();
+
+        return {
+            acknowledged: true,
+            deletedCount: 1
+        };
+    }
+
+    /**
+     * Deletes multiple documents
+     * @param {Object} filter - Query filter
+     * @returns {Promise<Object>} Result object with deletedCount
+     */
+    async deleteMany(filter = {}) {
+        await this.load();
+
+        validateFilter(filter);
+
+        const initialCount = this.documents.length;
+        this.documents = this.documents.filter(doc =>
+            !QueryEngine.match(doc, filter)
+        );
+
+        const deletedCount = initialCount - this.documents.length;
+
+        await this.persist();
+
+        return {
+            acknowledged: true,
+            deletedCount
+        };
+    }
+
+    /**
+     * Counts documents matching a filter
+     * @param {Object} filter - Query filter
+     * @returns {Promise<number>} Count of matching documents
+     */
+    async countDocuments(filter = {}) {
+        await this.load();
+
+        validateFilter(filter);
+
+        return QueryEngine.find(this.documents, filter).length;
+    }
+
+    /**
+     * Drops the collection
+     */
+    async drop() {
+        await this.storageEngine.deleteCollection(this.name);
+        this.documents = [];
+        this.loaded = false;
+    }
+}

package/src/database/Database.js

@@ -0,0 +1,121 @@
+import { join } from 'path';
+import { StorageEngine } from '../engine/StorageEngine.js';
+import { Collection } from './Collection.js';
+import { validateCollectionName } from '../utils/validator.js';
+import { DatabaseOperationError } from '../errors/DatabaseError.js';
+
+/**
+ * Database - Main database class
+ */
+export class Database {
+    /**
+     * @param {Object} options - Database options
+     * @param {string} options.database - Database name
+     * @param {string} [options.path] - Root path for database storage (defaults to './database')
+     */
+    constructor(options = {}) {
+        if (!options.database) {
+            throw new DatabaseOperationError(
+                'constructor',
+                'Database name is required'
+            );
+        }
+
+        this.name = options.database;
+        this.rootPath = options.path || join(process.cwd(), 'database');
+        this.databasePath = join(this.rootPath, this.name);
+
+        this.storageEngine = new StorageEngine(this.databasePath);
+        this.collections = new Map();
+        this.initialized = false;
+    }
+
+    /**
+     * Initializes the database
+     */
+    async initialize() {
+        if (!this.initialized) {
+            await this.storageEngine.initialize();
+            this.initialized = true;
+        }
+    }
+
+    /**
+     * Gets or creates a collection
+     * @param {string} name - Collection name
+     * @returns {Collection} Collection instance
+     */
+    collection(name) {
+        validateCollectionName(name);
+
+        // Return cached collection if exists
+        if (this.collections.has(name)) {
+            return this.collections.get(name);
+        }
+
+        // Create new collection instance
+        const collection = new Collection(name, this.storageEngine, this);
+        this.collections.set(name, collection);
+
+        return collection;
+    }
+
+    /**
+     * Ensures the database is initialized
+     * @returns {Promise<void>}
+     */
+    async ensureInitialized() {
+        await this.initialize();
+    }
+
+    /**
+     * Lists all collections in the database
+     * @returns {Promise<Array<string>>} Array of collection names
+     */
+    async listCollections() {
+        await this.initialize();
+        return await this.storageEngine.listCollections();
+    }
+
+    /**
+     * Drops the entire database
+     */
+    async dropDatabase() {
+        await this.storageEngine.dropDatabase();
+        this.collections.clear();
+        this.initialized = false;
+    }
+
+    /**
+     * Closes the database connection (clears cache)
+     */
+    async close() {
+        this.collections.clear();
+        this.initialized = false;
+    }
+
+    /**
+     * Gets database statistics
+     * @returns {Promise<Object>} Database statistics
+     */
+    async stats() {
+        await this.initialize();
+
+        const collectionNames = await this.listCollections();
+        let totalDocuments = 0;
+        let totalSize = 0;
+
+        for (const name of collectionNames) {
+            const collection = this.collection(name);
+            const count = await collection.countDocuments();
+            totalDocuments += count;
+        }
+
+        return {
+            database: this.name,
+            collections: collectionNames.length,
+            documents: totalDocuments,
+            path: this.databasePath
+        };
+    }
+}

package/src/engine/QueryEngine.js

@@ -0,0 +1,166 @@
+import { QueryError } from '../errors/DatabaseError.js';
+import { OPERATORS, isOperator, getNestedValue } from '../query/operators.js';
+
+/**
+ * Query Engine - Handles query parsing and document matching
+ */
+export class QueryEngine {
+    /**
+     * Matches a document against a query filter
+     * @param {Object} document - The document to match
+     * @param {Object} filter - The query filter
+     * @returns {boolean} True if the document matches the filter
+     */
+    static match(document, filter = {}) {
+        // Empty filter matches all documents
+        if (!filter || Object.keys(filter).length === 0) {
+            return true;
+        }
+
+        return this.matchConditions(document, filter);
+    }
+
+    /**
+     * Matches a document against multiple conditions
+     * @param {Object} document - The document to match
+     * @param {Object} conditions - The conditions to match
+     * @returns {boolean} True if all conditions match
+     */
+    static matchConditions(document, conditions) {
+        for (const [key, value] of Object.entries(conditions)) {
+            // Handle logical operators
+            if (key === '$and') {
+                if (!this.handleAnd(document, value)) {
+                    return false;
+                }
+            } else if (key === '$or') {
+                if (!this.handleOr(document, value)) {
+                    return false;
+                }
+            } else {
+                // Handle field conditions
+                if (!this.matchField(document, key, value)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Matches a document field against a query value
+     * @param {Object} document - The document to match
+     * @param {string} field - The field name (supports dot notation)
+     * @param {*} queryValue - The value or operator object to match against
+     * @returns {boolean} True if the field matches
+     */
+    static matchField(document, field, queryValue) {
+        const fieldValue = getNestedValue(document, field);
+
+        // If queryValue is an operator object
+        if (typeof queryValue === 'object' && queryValue !== null && !Array.isArray(queryValue)) {
+            const operators = Object.keys(queryValue);
+
+            // Check if any key is an operator
+            const hasOperators = operators.some(key => isOperator(key));
+
+            if (hasOperators) {
+                // Match against all operators
+                for (const [op, opValue] of Object.entries(queryValue)) {
+                    if (isOperator(op)) {
+                        const operatorFn = OPERATORS[op];
+                        if (!operatorFn(fieldValue, opValue)) {
+                            return false;
+                        }
+                    } else if (op.startsWith('$')) {
+                        throw new QueryError(`Unknown operator: ${op}`);
+                    }
+                }
+                return true;
+            }
+        }
+
+        // Direct equality comparison
+        return this.deepEquals(fieldValue, queryValue);
+    }
+
+    /**
+     * Handles $and logical operator
+     * @param {Object} document - The document to match
+     * @param {Array} conditions - Array of condition objects
+     * @returns {boolean} True if all conditions match
+     */
+    static handleAnd(document, conditions) {
+        if (!Array.isArray(conditions)) {
+            throw new QueryError('$and operator requires an array');
+        }
+
+        return conditions.every(condition => this.matchConditions(document, condition));
+    }
+
+    /**
+     * Handles $or logical operator
+     * @param {Object} document - The document to match
+     * @param {Array} conditions - Array of condition objects
+     * @returns {boolean} True if any condition matches
+     */
+    static handleOr(document, conditions) {
+        if (!Array.isArray(conditions)) {
+            throw new QueryError('$or operator requires an array');
+        }
+
+        return conditions.some(condition => this.matchConditions(document, condition));
+    }
+
+    /**
+     * Deep equality comparison
+     * @param {*} a - First value
+     * @param {*} b - Second value
+     * @returns {boolean} True if values are deeply equal
+     */
+    static deepEquals(a, b) {
+        if (a === b) return true;
+
+        if (a === null || b === null) return false;
+        if (a === undefined || b === undefined) return false;
+
+        if (typeof a !== typeof b) return false;
+
+        if (typeof a !== 'object') return false;
+
+        if (Array.isArray(a) !== Array.isArray(b)) return false;
+
+        if (Array.isArray(a)) {
+            if (a.length !== b.length) return false;
+            return a.every((item, index) => this.deepEquals(item, b[index]));
+        }
+
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+
+        if (keysA.length !== keysB.length) return false;
+
+        return keysA.every(key => this.deepEquals(a[key], b[key]));
+    }
+
+    /**
+     * Finds all documents matching a filter
+     * @param {Array} documents - The documents to search
+     * @param {Object} filter - The query filter
+     * @returns {Array} Matching documents
+     */
+    static find(documents, filter = {}) {
+        return documents.filter(doc => this.match(doc, filter));
+    }
+
+    /**
+     * Finds the first document matching a filter
+     * @param {Array} documents - The documents to search
+     * @param {Object} filter - The query filter
+     * @returns {Object|null} The first matching document or null
+     */
+    static findOne(documents, filter = {}) {
+        return documents.find(doc => this.match(doc, filter)) || null;
+    }
+}