database-local 1.0.0

package/constants.js

@@ -0,0 +1,22 @@
+export const DEFAULT_DB_PATH = './databases';
+export const DEFAULT_ID_CONFIG = {
+    type: String,
+    required: true
+};
+
+export const FILTER_OPERATORS = {
+    $gt: (value, target) => value > target,
+    $lt: (value, target) => value < target,
+    $gte: (value, target) => value >= target,
+    $lte: (value, target) => value <= target,
+    $eq: (value, target) => value === target,
+    $neq: (value, target) => value !== target,
+    $in: (value, target) => value.includes(target),
+    $nin: (value, target) => !value.includes(target),
+    $regex: (value, target) => value.match(target),
+    $exists: (value) => value !== undefined
+};
+
+export const RESERVED_KEYS = ['$id', '$ref'];
+export const QUERY_SPECIAL_KEYS = ['$limit'];
+export const OPERATOR_PREFIX = '$';

package/core/Collection.js

@@ -0,0 +1,140 @@
+import SchemaValidator from '../validators/SchemaValidator.js';
+import Query from './Query.js';
+import FileHandler from '../utils/FileHandler.js';
+import ObjectUtils from '../utils/ObjectUtils.js';
+import { ObjectId } from '../utils/ObjectId.js';
+
+export default class Collection {
+    constructor(name, schema, dbPath) {
+        this.name = name;
+        this.schema = schema;
+        this.filePath = FileHandler.resolvePath(dbPath, `${name}.json`);
+        this.validator = new SchemaValidator(schema);
+        this.data = this.#loadData();
+        this.idGenerator = this.#createIdGenerator();
+    }
+
+    #loadData() {
+        return FileHandler.readJSON(this.filePath);
+    }
+
+    #save() {
+        FileHandler.writeJSON(this.filePath, this.data);
+    }
+
+    #createIdGenerator() {
+        const idConfig = this.schema._id || {};
+        if (typeof idConfig.default === 'function') {
+            return idConfig.default;
+        }
+        return () => new ObjectId().toString();
+    }
+
+    #enhanceDocument(doc) {
+        return {
+            ...doc,
+            update: (values) => this.updateOne(doc._id, values),
+            remove: () => this.deleteOne(doc._id),
+            save: () => this.saveOne(doc)
+        };
+    }
+
+    #enhanceResults(results) {
+        if (Array.isArray(results)) {
+            return results.map(doc => this.#enhanceDocument(doc));
+        }
+        return results ? this.#enhanceDocument(results) : null;
+    }
+
+    find(query = {}) {
+        const queryEngine = new Query(this.data);
+        const results = queryEngine.filter(query);
+        return this.#enhanceResults(results);
+    }
+
+    findOne(query = {}) {
+        const results = this.find(query);
+        return Array.isArray(results) ? results[0] : results;
+    }
+
+    create(data) {
+        const validatedData = this.validator.validate({
+            ...data,
+            _id: data._id || this.idGenerator()
+        });
+
+        // Check for duplicate IDs
+        if (this.data.some(doc => doc._id === validatedData._id)) {
+            throw new Error('Duplicate ID detected');
+        }
+
+        return {
+            data: validatedData,
+            save: () => {
+                this.data.unshift(validatedData);
+                this.#save();
+                return this.#enhanceDocument(validatedData);
+            }
+        };
+    }
+
+    updateOne(id, updates) {
+        const doc = this.data.find(item => item._id === id);
+
+        if (!doc) {
+            throw new Error(`Document with id ${id} not found`);
+        }
+
+        const updated = this.validator.mergeObjects(doc, updates, this.schema);
+
+        return {
+            data: updated,
+            save: () => {
+                const index = this.data.findIndex(item => item._id === id);
+                this.data[index] = updated;
+                this.#save();
+                return this.#enhanceDocument(updated);
+            }
+        };
+    }
+
+    deleteOne(id) {
+        const initialLength = this.data.length;
+        this.data = this.data.filter(item => item._id !== id);
+
+        if (this.data.length === initialLength) {
+            throw new Error(`Document with id ${id} not found`);
+        }
+
+        this.#save();
+    }
+
+    deleteMany(query) {
+        const queryEngine = new Query(this.data);
+        const toDelete = queryEngine.filter(query);
+        const deleteIds = new Set(toDelete.map(doc => doc._id));
+
+        const initialLength = this.data.length;
+        this.data = this.data.filter(doc => !deleteIds.has(doc._id));
+
+        this.#save();
+        return initialLength - this.data.length;
+    }
+
+    saveOne(data) {
+        const index = this.data.findIndex(item => item._id === data._id);
+
+        if (index === -1) {
+            throw new Error(`Document with id ${data._id} not found`);
+        }
+
+        this.data[index] = data;
+        this.#save();
+        return this.#enhanceDocument(data);
+    }
+
+    clear() {
+        this.data = [];
+        this.#save();
+    }
+}

package/core/Database.js

@@ -0,0 +1,48 @@
+import Collection from './Collection.js';
+import FileHandler from '../utils/FileHandler.js';
+import { ObjectId } from '../utils/ObjectId.js';
+export { DEFAULT_DB_PATH, DEFAULT_ID_CONFIG } from '../constants.js';
+
+export class Database {
+    constructor(options = {}) {
+        this.path = options.path || DEFAULT_DB_PATH;
+        this.readOnFind = options.readOnFind || false;
+        this.collections = new Map();
+
+        FileHandler.ensureDirectory(this.path);
+        this.Schema = this.createCollection.bind(this);
+    }
+
+    createCollection(name, schema = {}) {
+        // Ensure _id configuration
+        if (!schema._id) {
+            schema._id = { ...DEFAULT_ID_CONFIG, default: () => new ObjectId().toString() };
+        }
+
+        const collection = new Collection(name, schema, this.path);
+        this.collections.set(name, collection);
+
+        return collection;
+    }
+
+    getCollection(name) {
+        return this.collections.get(name);
+    }
+
+    removeCollection(name) {
+        this.collections.delete(name);
+    }
+
+    get Types() {
+        return {
+            ObjectId: () => new ObjectId().toString(),
+            String,
+            Number,
+            Boolean,
+            Date,
+            Array,
+            Object
+        };
+    }
+}
+export default Database;

package/core/Query.js

@@ -0,0 +1,117 @@
+import ObjectUtils from '../utils/ObjectUtils.js';
+import { FILTER_OPERATORS, RESERVED_KEYS, QUERY_SPECIAL_KEYS, OPERATOR_PREFIX } from '../constants.js';
+
+export default class Query {
+    constructor(data) {
+        this.data = data || [];
+    }
+
+    filter(query) {
+        if (!query || (typeof query === 'object' && Object.keys(query).length === 0)) {
+            return [...this.data];
+        }
+
+        const queryType = ObjectUtils.getType(query);
+
+        const handlers = {
+            function: () => this.data.filter(query),
+            object: () => this.#filterByObject(query),
+            string: () => this.#findById(query),
+            number: () => this.#findById(query)
+        };
+
+        return handlers[queryType]?.() || [];
+    }
+
+    findOne(query) {
+        const results = this.filter(query);
+        return Array.isArray(results) ? results[0] : results;
+    }
+
+    #findById(id) {
+        return this.data.filter(item => item._id === id);
+    }
+
+    #filterByObject(query) {
+        const { operators, conditions } = this.#separateQueryParts(query);
+
+        let results = this.data;
+
+        // Apply simple conditions first
+        if (Object.keys(conditions).length > 0) {
+            results = results.filter(item =>
+                Object.entries(conditions).every(([key, value]) => {
+                    if (typeof value === 'object' && value !== null) return true;
+                    return item[key] === value;
+                })
+            );
+        }
+
+        // Apply operators
+        if (Object.keys(operators).length > 0) {
+            results = this.#applyOperators(results, operators);
+        }
+
+        return results;
+    }
+
+    #separateQueryParts(query) {
+        const operators = {};
+        const conditions = {};
+
+        for (const [key, value] of Object.entries(query)) {
+            if (QUERY_SPECIAL_KEYS.includes(key)) {
+                operators[key] = value;
+            } else if (this.#hasOperators(value)) {
+                operators[key] = value;
+            } else {
+                conditions[key] = value;
+            }
+        }
+
+        return { operators, conditions };
+    }
+
+    #hasOperators(value) {
+        if (typeof value !== 'object' || value === null) return false;
+        return Object.keys(value).some(key => key.startsWith(OPERATOR_PREFIX));
+    }
+
+    #applyOperators(data, operators) {
+        let results = data;
+        const limit = operators.$limit;
+
+        delete operators.$limit;
+
+        for (const [field, operations] of Object.entries(operators)) {
+            if (RESERVED_KEYS.includes(field)) continue;
+
+            if (typeof operations === 'object') {
+                results = results.filter(item =>
+                    this.#evaluateOperators(item, field, operations)
+                );
+            }
+        }
+
+        return this.#applyLimit(results, limit);
+    }
+
+    #evaluateOperators(item, field, operations) {
+        const value = ObjectUtils.getNestedProperty(item, field);
+
+        return Object.entries(operations).every(([operator, target]) => {
+            const filterFn = FILTER_OPERATORS[operator];
+            return filterFn ? filterFn(value, target) : true;
+        });
+    }
+
+    #applyLimit(data, limit) {
+        if (typeof limit !== 'number' || limit < 1) return data;
+
+        if (limit === 1) {
+            return data.length > 0 ? data[0] : null;
+        }
+
+        return data.slice(0, limit);
+    }
+}

package/index.js

@@ -0,0 +1,3 @@
+import Database from './core/Database.js';
+export { ObjectId } from './utils/ObjectId.js';
+export default Database;

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "database-local",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module"
+}

package/utils/FileHandler.js

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import path from 'path';
+
+export default class FileHandler {
+    static ensureDirectory(dirPath) {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+
+    static readJSON(filePath) {
+        try {
+            const data = fs.readFileSync(filePath, 'utf8');
+            return JSON.parse(data);
+        } catch (error) {
+            return [];
+        }
+    }
+
+    static writeJSON(filePath, data) {
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+        return data;
+    }
+
+    static resolvePath(basePath, filename) {
+        return path.resolve(basePath, filename);
+    }
+}

package/utils/ObjectId.js

@@ -0,0 +1,38 @@
+export class ObjectId {
+    constructor(id = null) {
+        if (id instanceof ObjectId) return id;
+
+        this.timestamp = Math.floor(Date.now() / 1000);
+        this.machineId = Math.floor(Math.random() * 0xFFFFFF);
+        this.processId = Math.floor(Math.random() * 0xFFFF);
+        this.counter = ObjectId.increment();
+
+        this.value = this.generateId();
+    }
+
+    static increment() {
+        ObjectId.counter = ((ObjectId.counter || Math.floor(Math.random() * 0xFFFFFF)) + 1) % 0xFFFFFF;
+        return ObjectId.counter;
+    }
+
+    generateId() {
+        return [
+            this.timestamp.toString(16).padStart(8, '0'),
+            this.machineId.toString(16).padStart(6, '0'),
+            this.processId.toString(16).padStart(4, '0'),
+            this.counter.toString(16).padStart(6, '0')
+        ].join('');
+    }
+
+    toString() {
+        return this.value;
+    }
+
+    toJSON() {
+        return this.toString();
+    }
+
+    static isValid(id) {
+        return /^[0-9a-fA-F]{24}$/.test(id);
+    }
+}

package/utils/ObjectUtils.js

@@ -0,0 +1,31 @@
+export default class ObjectUtils {
+    static getType(value) {
+        if (value === null) return 'null';
+        if (value === undefined) return 'undefined';
+
+        const type = typeof value;
+        return type === 'object' || type === 'function'
+            ? Object.prototype.toString.call(value).slice(8, -1).toLowerCase()
+            : type;
+    }
+
+    static getNestedProperty(obj, path) {
+        return path.split('.').reduce((current, key) => current?.[key], obj);
+    }
+
+    static isOperator(value) {
+        return typeof value === 'string' && value.startsWith('$');
+    }
+
+    static deepClone(obj) {
+        return JSON.parse(JSON.stringify(obj));
+    }
+
+    static defineProperty(obj, key, value) {
+        Object.defineProperty(obj, key, {
+            value,
+            enumerable: false,
+            configurable: true
+        });
+    }
+}

package/validators/SchemaValidator.js

@@ -0,0 +1,140 @@
+import TypeChecker from './TypeChecker.js';
+import ObjectUtils from '../utils/ObjectUtils.js';
+import { RESERVED_KEYS } from '../constants.js';
+
+export default class SchemaValidator {
+    constructor(schema) {
+        this.schema = schema;
+    }
+
+    validate(data) {
+        return this.#validateObject(data, this.schema);
+    }
+
+    #validateObject(data, schema) {
+        const validated = {};
+
+        for (const [key, config] of Object.entries(schema)) {
+            const value = data?.[key];
+            const typeConfig = this.#normalizeConfig(config, key);
+
+            validated[key] = this.#validateField(key, value, typeConfig);
+        }
+
+        return validated;
+    }
+
+    #normalizeConfig(config, key) {
+        if (typeof config === 'function') {
+            return { type: config };
+        }
+
+        // Si el config es un objeto plano sin type, asumimos que es un Object
+        if (typeof config === 'object' && config !== null && !Array.isArray(config) && !config.type) {
+            // Verificar si tiene propiedades (es un objeto anidado)
+            if (Object.keys(config).length > 0) {
+                return { type: Object, nested: config };
+            }
+        }
+
+        const { type, ...options } = config;
+
+        if (!type) {
+            throw new Error(`Type definition is required for field "${key}"`);
+        }
+
+        return { type, ...options };
+    }
+
+    #validateField(key, value, config) {
+        // Handle default values
+        if (value === undefined) {
+            if (config.default !== undefined) {
+                return TypeChecker.getDefaultValue(config);
+            }
+            if (config.required) {
+                throw new Error(`Field "${key}" is required`);
+            }
+            return undefined;
+        }
+
+        // Handle null values
+        if (value === null) {
+            TypeChecker.checkNullable(value, config);
+            return null;
+        }
+
+        // Validate type
+        const validatedValue = this.#validateType(key, value, config);
+
+        // Validate enum
+        if (config.enum) {
+            if (!TypeChecker.validateEnum(validatedValue, config.enum)) {
+                throw new Error(
+                    `Field "${key}" must be one of: ${config.enum.join(', ')}`
+                );
+            }
+        }
+
+        return validatedValue;
+    }
+
+    #validateType(key, value, config) {
+        const { type } = config;
+
+        // Si tiene un esquema anidado, validar como objeto
+        if (config.nested) {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                throw new Error(`Field "${key}" must be an object`);
+            }
+            return this.#validateObject(value, config.nested);
+        }
+
+        if (Array.isArray(type)) {
+            if (!Array.isArray(value)) {
+                throw new Error(`Field "${key}" must be an array`);
+            }
+            return value.map((item, index) => this.#validateArrayItem(key, item, type[0], index));
+        }
+
+        if (typeof type === 'object' && !Array.isArray(type)) {
+            return this.#validateObject(value, type);
+        }
+
+        if (!TypeChecker.isValidType(value, type)) {
+            const expectedType = typeof type === 'function' ? type.name : type;
+            const actualType = ObjectUtils.getType(value);
+            throw new Error(
+                `Field "${key}" expected ${expectedType} but got ${actualType}`
+            );
+        }
+
+        return value;
+    }
+
+    #validateArrayItem(key, item, type, index) {
+        if (typeof type === 'object' && !Array.isArray(type)) {
+            return this.#validateObject(item, type);
+        }
+
+        if (!TypeChecker.isValidType(item, type)) {
+            throw new Error(
+                `Field "${key}[${index}]" has invalid type`
+            );
+        }
+
+        return item;
+    }
+
+    mergeObjects(base, updates, schema) {
+        const merged = { ...base };
+
+        for (const [key, value] of Object.entries(updates)) {
+            if (value !== undefined) {
+                merged[key] = value;
+            }
+        }
+
+        return this.validate(merged);
+    }
+}

package/validators/TypeChecker.js

@@ -0,0 +1,38 @@
+import ObjectUtils from '../utils/ObjectUtils.js';
+
+export default class TypeChecker {
+    static isValidType(value, type) {
+        const valueType = ObjectUtils.getType(value);
+
+        if (typeof type === 'function') {
+            return value instanceof type || valueType === type.name.toLowerCase();
+        }
+
+        return valueType === type;
+    }
+
+    static validateEnum(value, allowedValues) {
+        return allowedValues.includes(value);
+    }
+
+    static checkRequired(value, config) {
+        if (value === undefined && config.required) {
+            throw new Error(`Required value is missing`);
+        }
+    }
+
+    static checkNullable(value, config) {
+        if (value === null && !config.nullable) {
+            throw new Error('Null value is not allowed');
+        }
+    }
+
+    static getDefaultValue(config) {
+        if (config.default !== undefined) {
+            return typeof config.default === 'function'
+                ? config.default()
+                : config.default;
+        }
+        return undefined;
+    }
+}