@nekodb/client 1.0.0

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "@nekodb/client",
+    "version": "1.0.0",
+    "description": "NekoDB is a lightweight encrypted document database for Node.js, built with real-time WebSocket communication, simple JSON-based storage, and a developer-friendly API. Designed for speed, security, and ease of integration without external database dependencies.",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "keywords": [
+        "database",
+        "nosql",
+        "document-database",
+        "encrypted-database",
+        "realtime-database",
+        "websocket",
+        "json-database",
+        "lightweight",
+        "nodejs",
+        "nekodb"
+    ],
+    "author": "Galang Purnama",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Galang-Purnama/NekoDB.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Galang-Purnama/NekoDB/issues"
+    },
+    "homepage": "https://github.com/Galang-Purnama/NekoDB#readme",
+    "dependencies": {
+        "ws": "^8.16.0"
+    },
+    "files": [
+        "index.js",
+        "auth/",
+        "middleware/",
+        "query/",
+        "schema/",
+        "events/",
+        "helpers/",
+        "connection/",
+        "errors/",
+        "README.md"
+    ]
+}

package/query/builder.js

@@ -0,0 +1,181 @@
+const { FieldQuery } = require('./field');
+
+class QueryBuilder {
+    #db;
+    #collection;
+    #conditions;
+    #projection;
+    #sortFields;
+    #limitVal;
+    #offsetVal;
+    #pageVal;
+    #cursorVal;
+
+    constructor(db, collection) {
+        this.#db = db;
+        this.#collection = collection;
+        this.#conditions = {};
+        this.#projection = null;
+        this.#sortFields = [];
+        this.#limitVal = 0;
+        this.#offsetVal = 0;
+        this.#pageVal = 0;
+        this.#cursorVal = '';
+    }
+
+    where(field) {
+        return new FieldQuery(this, field);
+    }
+
+    eq(field, value) {
+        this.#conditions[field] = value;
+        return this;
+    }
+
+    gt(field, value) {
+        this._addOp(field, '$gt', value);
+        return this;
+    }
+
+    gte(field, value) {
+        this._addOp(field, '$gte', value);
+        return this;
+    }
+
+    lt(field, value) {
+        this._addOp(field, '$lt', value);
+        return this;
+    }
+
+    lte(field, value) {
+        this._addOp(field, '$lte', value);
+        return this;
+    }
+
+    ne(field, value) {
+        this._addOp(field, '$ne', value);
+        return this;
+    }
+
+    in(field, values) {
+        this._addOp(field, '$in', values);
+        return this;
+    }
+
+    nin(field, values) {
+        this._addOp(field, '$nin', values);
+        return this;
+    }
+
+    between(field, min, max) {
+        this._addOp(field, '$gte', min);
+        this._addOp(field, '$lte', max);
+        return this;
+    }
+
+    _addOp(field, op, value) {
+        if (typeof this.#conditions[field] !== 'object' || this.#conditions[field] === null) {
+            this.#conditions[field] = {};
+        }
+        this.#conditions[field][op] = value;
+    }
+
+    select(...fields) {
+        this.#projection = {};
+        for (const f of fields) {
+            this.#projection[f] = 1;
+        }
+        return this;
+    }
+
+    exclude(...fields) {
+        this.#projection = {};
+        for (const f of fields) {
+            this.#projection[f] = 0;
+        }
+        return this;
+    }
+
+    sort(field, order = 'asc') {
+        this.#sortFields.push({ field, order });
+        return this;
+    }
+
+    sortAsc(field) { return this.sort(field, 'asc'); }
+    sortDesc(field) { return this.sort(field, 'desc'); }
+
+    limit(n) {
+        this.#limitVal = n;
+        return this;
+    }
+
+    offset(n) {
+        this.#offsetVal = n;
+        return this;
+    }
+
+    page(n) {
+        this.#pageVal = n;
+        return this;
+    }
+
+    cursor(c) {
+        this.#cursorVal = c;
+        return this;
+    }
+
+    getQuery() {
+        return { ...this.#conditions };
+    }
+
+    getProjection() {
+        return this.#projection ? { ...this.#projection } : null;
+    }
+
+    getPaginationOptions() {
+        const opts = {};
+        if (this.#limitVal > 0) opts.limit = this.#limitVal;
+        if (this.#offsetVal > 0) opts.offset = this.#offsetVal;
+        if (this.#pageVal > 0) opts.page = this.#pageVal;
+        if (this.#cursorVal) opts.cursor = this.#cursorVal;
+        if (this.#sortFields.length > 0) opts.sort = [...this.#sortFields];
+        return opts;
+    }
+
+    async exec() {
+        const query = this.getQuery();
+        const hasQuery = Object.keys(query).length > 0;
+        const hasPagination = this.#limitVal > 0 || this.#pageVal > 0 || this.#cursorVal;
+        const hasProjection = this.#projection !== null;
+
+        if (hasPagination && hasQuery) {
+            return this.#db.searchPaginated(this.#collection, query, this.getPaginationOptions());
+        }
+        if (hasPagination) {
+            return this.#db.listPaginated(this.#collection, {
+                ...this.getPaginationOptions(),
+                filter: hasQuery ? query : null,
+            });
+        }
+        if (hasProjection && hasQuery) {
+            return this.#db.searchProjected(this.#collection, query, this.#projection);
+        }
+        if (hasQuery) {
+            return this.#db.search(this.#collection, query);
+        }
+        return this.#db.list(this.#collection);
+    }
+
+    async count() {
+        return this.#db.count(this.#collection);
+    }
+
+    async first() {
+        const results = await this.limit(1).exec();
+        if (Array.isArray(results)) return results[0] || null;
+        if (results?.data) return results.data[0] || null;
+        return results;
+    }
+}
+
+module.exports = { QueryBuilder };

package/query/field.js

@@ -0,0 +1,21 @@
+class FieldQuery {
+    #builder;
+    #field;
+
+    constructor(builder, field) {
+        this.#builder = builder;
+        this.#field = field;
+    }
+
+    eq(value) { return this.#builder.eq(this.#field, value); }
+    gt(value) { return this.#builder.gt(this.#field, value); }
+    gte(value) { return this.#builder.gte(this.#field, value); }
+    lt(value) { return this.#builder.lt(this.#field, value); }
+    lte(value) { return this.#builder.lte(this.#field, value); }
+    ne(value) { return this.#builder.ne(this.#field, value); }
+    in(values) { return this.#builder.in(this.#field, values); }
+    nin(values) { return this.#builder.nin(this.#field, values); }
+    between(min, max) { return this.#builder.between(this.#field, min, max); }
+}
+
+module.exports = { FieldQuery };

package/query/index.js

@@ -0,0 +1,9 @@
+const { QueryBuilder } = require('./builder');
+const { FieldQuery } = require('./field');
+const operators = require('./operators');
+
+module.exports = {
+    QueryBuilder,
+    FieldQuery,
+    ...operators,
+};

package/query/operators.js

@@ -0,0 +1,19 @@
+function eq(val) { return val; }
+function gt(val) { return { $gt: val }; }
+function gte(val) { return { $gte: val }; }
+function lt(val) { return { $lt: val }; }
+function lte(val) { return { $lte: val }; }
+function ne(val) { return { $ne: val }; }
+function matches(val) { return { $in: val }; }
+function nin(val) { return { $nin: val }; }
+
+module.exports = {
+    eq,
+    gt,
+    gte,
+    lt,
+    lte,
+    ne,
+    matches,
+    nin,
+};

package/schema/index.js

@@ -0,0 +1,7 @@
+const { Schema } = require('./schema');
+const { Types } = require('./types');
+
+module.exports = {
+    Schema,
+    Types,
+};

package/schema/schema.js

@@ -0,0 +1,70 @@
+const { validateDocument } = require('./validator');
+
+class Schema {
+    #fields;
+    #strict;
+
+    constructor(definition = {}, options = {}) {
+        this.#fields = {};
+        this.#strict = options.strict || false;
+
+        for (const [name, rule] of Object.entries(definition)) {
+            if (typeof rule === 'string') {
+                this.#fields[name] = { type: rule, required: false };
+            } else if (typeof rule === 'object' && rule !== null) {
+                this.#fields[name] = {
+                    type: rule.type || 'any',
+                    required: rule.required || false,
+                    default: rule.default,
+                    min: rule.min,
+                    max: rule.max,
+                    minLength: rule.minLength,
+                    maxLength: rule.maxLength,
+                    enum: rule.enum,
+                    match: rule.match,
+                    message: rule.message,
+                };
+            }
+        }
+    }
+
+    validate(doc) {
+        return validateDocument(doc, this.#fields, this.#strict);
+    }
+
+    applyDefaults(doc) {
+        const result = { ...doc };
+        for (const [name, rule] of Object.entries(this.#fields)) {
+            if (result[name] === undefined && rule.default !== undefined) {
+                result[name] = typeof rule.default === 'function' ? rule.default() : rule.default;
+            }
+        }
+        return result;
+    }
+
+    pick(doc, ...fields) {
+        const result = {};
+        for (const f of fields) {
+            if (doc[f] !== undefined) result[f] = doc[f];
+        }
+        return result;
+    }
+
+    omit(doc, ...fields) {
+        const result = { ...doc };
+        for (const f of fields) delete result[f];
+        return result;
+    }
+
+    getFieldNames() {
+        return Object.keys(this.#fields);
+    }
+
+    getRequiredFields() {
+        return Object.entries(this.#fields)
+            .filter(([, rule]) => rule.required)
+            .map(([name]) => name);
+    }
+}
+
+module.exports = { Schema };

package/schema/types.js

@@ -0,0 +1,31 @@
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+const Types = {
+    STRING: 'string',
+    NUMBER: 'number',
+    BOOLEAN: 'boolean',
+    OBJECT: 'object',
+    ARRAY: 'array',
+    ANY: 'any',
+    EMAIL: 'email',
+    UUID: 'uuid',
+};
+
+function isValidType(type) {
+    return Object.values(Types).includes(type);
+}
+
+function checkType(value, type) {
+    if (type === Types.ANY) return true;
+    if (type === Types.ARRAY) return Array.isArray(value);
+    if (type === Types.EMAIL) return typeof value === 'string' && EMAIL_REGEX.test(value);
+    if (type === Types.UUID) return typeof value === 'string' && UUID_REGEX.test(value);
+    return typeof value === type;
+}
+
+module.exports = {
+    Types,
+    isValidType,
+    checkType,
+};

package/schema/validator.js

@@ -0,0 +1,60 @@
+const { checkType } = require('./types');
+
+function validateDocument(doc, fields, strict) {
+    const errors = [];
+
+    for (const [name, rule] of Object.entries(fields)) {
+        const value = doc[name];
+
+        if (value === undefined || value === null) {
+            if (rule.required) {
+                errors.push({ field: name, rule: 'required', message: rule.message || `"${name}" is required` });
+            }
+            continue;
+        }
+
+        if (rule.type !== 'any') {
+            if (!checkType(value, rule.type)) {
+                errors.push({ field: name, rule: 'type', message: `"${name}" expected ${rule.type}, got ${Array.isArray(value) ? 'array' : typeof value}` });
+                continue;
+            }
+        }
+
+        if (rule.type === 'number') {
+            if (rule.min !== undefined && value < rule.min) {
+                errors.push({ field: name, rule: 'min', message: `"${name}" must be >= ${rule.min}` });
+            }
+            if (rule.max !== undefined && value > rule.max) {
+                errors.push({ field: name, rule: 'max', message: `"${name}" must be <= ${rule.max}` });
+            }
+        }
+
+        if (rule.type === 'string') {
+            if (rule.minLength !== undefined && value.length < rule.minLength) {
+                errors.push({ field: name, rule: 'minLength', message: `"${name}" min length is ${rule.minLength}` });
+            }
+            if (rule.maxLength !== undefined && value.length > rule.maxLength) {
+                errors.push({ field: name, rule: 'maxLength', message: `"${name}" max length is ${rule.maxLength}` });
+            }
+            if (rule.match && !rule.match.test(value)) {
+                errors.push({ field: name, rule: 'match', message: `"${name}" format is invalid` });
+            }
+        }
+
+        if (rule.enum && !rule.enum.includes(value)) {
+            errors.push({ field: name, rule: 'enum', message: `"${name}" must be one of: ${rule.enum.join(', ')}` });
+        }
+    }
+
+    if (strict) {
+        for (const key of Object.keys(doc)) {
+            if (!(key in fields)) {
+                errors.push({ field: key, rule: 'strict', message: `Unknown field "${key}"` });
+            }
+        }
+    }
+
+    return { valid: errors.length === 0, errors };
+}
+
+module.exports = { validateDocument };