@wxn0brp/db 0.0.4 → 0.0.6

package/dist/cjs/utils/hasFieldsAdvanced.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = hasFieldsAdvanced;
+const hasFields_js_1 = __importDefault(require("./hasFields.js"));
+/**
+ * Checks if an object meets the criteria specified in the fields with operators.
+ */
+function hasFieldsAdvanced(obj, fields) {
+    if (typeof fields !== "object" || fields === null) {
+        throw new Error("Fields must be an object");
+    }
+    if ("$and" in fields) {
+        return fields["$and"].every(subFields => hasFieldsAdvanced(obj, subFields));
+    }
+    if ("$or" in fields) {
+        return fields["$or"].some(subFields => hasFieldsAdvanced(obj, subFields));
+    }
+    // Check various conditions
+    if (!checkConditions(obj, fields))
+        return false;
+    const fieldsSubset = removeAdvancedOperators({ ...fields });
+    return (0, hasFields_js_1.default)(obj, fieldsSubset);
+}
+function removeAdvancedOperators(fields) {
+    const advancedOperators = [
+        "and", "or",
+        "gt", "lt", "gte", "lte", "in", "nin",
+        "exists",
+        "type",
+        "regex",
+        "arrinc", "arrincall", "size",
+        "startsWith", "endsWith",
+        "between",
+        "not",
+        "subset"
+    ].map(operator => "$" + operator);
+    advancedOperators.forEach(operator => delete fields[operator]);
+    return fields;
+}
+function checkConditions(obj, fields) {
+    return (checkComparison(obj, fields) &&
+        checkExistence(obj, fields) &&
+        checkType(obj, fields) &&
+        checkRegex(obj, fields) &&
+        checkArrayConditions(obj, fields) &&
+        checkStringConditions(obj, fields) &&
+        checkBetween(obj, fields) &&
+        checkNot(obj, fields) &&
+        checkSubset(obj, fields));
+}
+function checkComparison(obj, fields) {
+    const comparisonOperators = ["$gt", "$lt", "$gte", "$lte", "$in", "$nin"];
+    for (const operator of comparisonOperators) {
+        if (operator in fields) {
+            for (const entries of Object.entries(fields[operator])) {
+                const [key, value] = entries;
+                switch (operator) {
+                    case "$gt":
+                        if (!(obj[key] > value))
+                            return false;
+                        break;
+                    case "$lt":
+                        if (!(obj[key] < value))
+                            return false;
+                        break;
+                    case "$gte":
+                        if (!(obj[key] >= value))
+                            return false;
+                        break;
+                    case "$lte":
+                        if (!(obj[key] <= value))
+                            return false;
+                        break;
+                    case "$in":
+                        if (!value.includes(obj[key]))
+                            return false;
+                        break;
+                    case "$nin":
+                        if (value.includes(obj[key]))
+                            return false;
+                        break;
+                }
+            }
+        }
+    }
+    return true;
+}
+function checkExistence(obj, fields) {
+    if ("$exists" in fields) {
+        for (const [key, shouldExist] of Object.entries(fields["$exists"])) {
+            if (shouldExist && !(key in obj))
+                return false;
+            if (!shouldExist && (key in obj))
+                return false;
+        }
+    }
+    return true;
+}
+function checkType(obj, fields) {
+    if ("$type" in fields) {
+        for (const [key, type] of Object.entries(fields["$type"])) {
+            if (typeof obj[key] !== type)
+                return false;
+        }
+    }
+    return true;
+}
+function checkRegex(obj, fields) {
+    if ("$regex" in fields) {
+        for (const [key, regex] of Object.entries(fields["$regex"])) {
+            if (!regex.test(obj[key]))
+                return false;
+        }
+    }
+    return true;
+}
+function checkArrayConditions(obj, fields) {
+    if ("$arrinc" in fields) {
+        for (const [key, values] of Object.entries(fields["$arrinc"])) {
+            if (!Array.isArray(obj[key]) || !values.some(val => obj[key].includes(val)))
+                return false;
+        }
+    }
+    if ("$arrincall" in fields) {
+        for (const [key, values] of Object.entries(fields["$arrincall"])) {
+            if (!Array.isArray(obj[key]) || !values.every(val => obj[key].includes(val)))
+                return false;
+        }
+    }
+    if ("$size" in fields) {
+        for (const [key, size] of Object.entries(fields["$size"])) {
+            if (Array.isArray(obj[key]) || typeof obj[key] === "string") {
+                if (obj[key].length !== size)
+                    return false;
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function checkStringConditions(obj, fields) {
+    if ("$startsWith" in fields) {
+        for (const [key, value] of Object.entries(fields["$startsWith"])) {
+            if (typeof obj[key] !== "string" || !obj[key].startsWith(value))
+                return false;
+        }
+    }
+    if ("$endsWith" in fields) {
+        for (const [key, value] of Object.entries(fields["$endsWith"])) {
+            if (typeof obj[key] !== "string" || !obj[key].endsWith(value))
+                return false;
+        }
+    }
+    return true;
+}
+function checkBetween(obj, fields) {
+    if ("$between" in fields) {
+        for (const [key, [min, max]] of Object.entries(fields["$between"])) {
+            if (typeof obj[key] !== "number" || obj[key] < min || obj[key] > max)
+                return false;
+        }
+    }
+    return true;
+}
+function checkNot(obj, fields) {
+    if ("$not" in fields) {
+        return !hasFieldsAdvanced(obj, fields["$not"]);
+    }
+    return true;
+}
+function checkSubset(obj, fields) {
+    if ("$subset" in fields) {
+        const setFields = fields["$subset"];
+        return (0, hasFields_js_1.default)(obj, setFields);
+    }
+    return true;
+}

package/dist/cjs/utils/updateFindObject.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Updates an object with new values from a findOpts object.
+ * @function
+ * @param {Object} obj - The object to update.
+ * @param {Object} findOpts - An object containing options to update the target object.
+ * @param {function} [findOpts.transform] - A function to transform the object before applying the other options.
+ * @param {string[]} [findOpts.select] - An array of fields to select from the target object.
+ * @param {string[]} [findOpts.exclude] - An array of fields to exclude from the target object.
+ * @returns {Object} The updated object.
+ */
+export default function updateFindObject(obj: any, findOpts: any): any;

package/dist/cjs/utils/updateFindObject.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = updateFindObject;
+/**
+ * Updates an object with new values from a findOpts object.
+ * @function
+ * @param {Object} obj - The object to update.
+ * @param {Object} findOpts - An object containing options to update the target object.
+ * @param {function} [findOpts.transform] - A function to transform the object before applying the other options.
+ * @param {string[]} [findOpts.select] - An array of fields to select from the target object.
+ * @param {string[]} [findOpts.exclude] - An array of fields to exclude from the target object.
+ * @returns {Object} The updated object.
+ */
+function updateFindObject(obj, findOpts) {
+    const { transform, select, exclude, } = findOpts;
+    if (typeof transform === "function")
+        obj = transform(obj);
+    if (Array.isArray(exclude)) {
+        exclude.forEach(field => {
+            if (obj.hasOwnProperty(field))
+                delete obj[field];
+        });
+    }
+    if (Array.isArray(select)) {
+        obj = select.reduce((acc, field) => {
+            if (obj.hasOwnProperty(field))
+                acc[field] = obj[field];
+            return acc;
+        }, {});
+    }
+    return obj;
+}

package/dist/cjs/utils/updateObject.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Updates an object with new values.
+ * @function
+ * @param {Object} obj - The object to update.
+ * @param {Object} newVal - An object containing new values to update in the target object.
+ * @returns {Object} The updated object.
+ */
+export default function updateObject(obj: any, newVal: any): any;

package/dist/cjs/utils/updateObject.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = updateObject;
+/**
+ * Updates an object with new values.
+ * @function
+ * @param {Object} obj - The object to update.
+ * @param {Object} newVal - An object containing new values to update in the target object.
+ * @returns {Object} The updated object.
+ */
+function updateObject(obj, newVal) {
+    for (let key in newVal) {
+        if (newVal.hasOwnProperty(key)) {
+            obj[key] = newVal[key];
+        }
+    }
+    return obj;
+}

package/dist/esm/CollectionManager.d.ts

@@ -0,0 +1,43 @@
+import DataBase from "./database.js";
+import DataBaseRemote from "./remote/client/database.js";
+import { Arg, ArgOrFunc } from "./types/arg.js";
+import { DbFindOpts, FindOpts } from "./types/options.js";
+import { Context } from "./types/types.js";
+declare class CollectionManager {
+    db: DataBase | DataBaseRemote;
+    collection: string;
+    constructor(db: DataBase | DataBaseRemote, collection: string);
+    /**
+     * Add data to a database.
+     */
+    add(data: Arg, id_gen?: boolean): Promise<any>;
+    /**
+     * Find data in a database.
+     */
+    find(search: ArgOrFunc, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<any>;
+    /**
+     * Find one data entry in a database.
+     */
+    findOne(search: ArgOrFunc, context?: Context, findOpts?: FindOpts): Promise<any>;
+    /**
+     * Update data in a database.
+     */
+    update(search: ArgOrFunc, arg: ArgOrFunc, context?: Context): Promise<any>;
+    /**
+     * Update one data entry in a database.
+     */
+    updateOne(search: ArgOrFunc, arg: ArgOrFunc, context?: Context): Promise<any>;
+    /**
+     * Remove data from a database.
+     */
+    remove(search: ArgOrFunc, context?: Context): Promise<any>;
+    /**
+     * Remove one data entry from a database.
+     */
+    removeOne(search: ArgOrFunc, context?: Context): Promise<any>;
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     */
+    updateOneOrAdd(search: ArgOrFunc, arg: ArgOrFunc, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<any>;
+}
+export default CollectionManager;

package/dist/esm/CollectionManager.js

@@ -0,0 +1,57 @@
+class CollectionManager {
+    db;
+    collection;
+    constructor(db, collection) {
+        this.db = db;
+        this.collection = collection;
+    }
+    /**
+     * Add data to a database.
+     */
+    async add(data, id_gen = true) {
+        return await this.db.add(this.collection, data, id_gen);
+    }
+    /**
+     * Find data in a database.
+     */
+    async find(search, context = {}, options = {}, findOpts = {}) {
+        return await this.db.find(this.collection, search, context, options, findOpts);
+    }
+    /**
+     * Find one data entry in a database.
+     */
+    async findOne(search, context = {}, findOpts = {}) {
+        return await this.db.findOne(this.collection, search, context, findOpts);
+    }
+    /**
+     * Update data in a database.
+     */
+    async update(search, arg, context = {}) {
+        return await this.db.update(this.collection, search, arg, context);
+    }
+    /**
+     * Update one data entry in a database.
+     */
+    async updateOne(search, arg, context = {}) {
+        return await this.db.updateOne(this.collection, search, arg, context);
+    }
+    /**
+     * Remove data from a database.
+     */
+    async remove(search, context = {}) {
+        return await this.db.remove(this.collection, search, context);
+    }
+    /**
+     * Remove one data entry from a database.
+     */
+    async removeOne(search, context = {}) {
+        return await this.db.removeOne(this.collection, search, context);
+    }
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     */
+    async updateOneOrAdd(search, arg, add_arg = {}, context = {}, id_gen = true) {
+        return await this.db.updateOneOrAdd(this.collection, search, arg, add_arg, context, id_gen);
+    }
+}
+export default CollectionManager;

package/dist/esm/action.d.ts

@@ -0,0 +1,71 @@
+import { Arg, ArgOrFunc } from "./types/arg.js";
+import { DbFindOpts, DbOpts, FindOpts } from "./types/options.js";
+import { Context } from "./types/types";
+import Data from "./types/data.js";
+/**
+ * A class representing database actions on files.
+ * @class
+ */
+declare class dbActionC {
+    folder: string;
+    options: DbOpts;
+    /**
+     * Creates a new instance of dbActionC.
+     * @constructor
+     * @param {string} folder - The folder where database files are stored.
+     * @param {object} options - The options object.
+     */
+    constructor(folder: string, options: DbOpts);
+    _getCollectionPath(collection: string): string;
+    /**
+     * Get a list of available databases in the specified folder.
+     * @returns {string[]} An array of database names.
+     */
+    getCollections(): string[];
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     * @function
+     * @param {string} collection - The collection to check.
+     */
+    checkCollection(collection: string): void;
+    /**
+     * Check if a collection exists.
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @returns {boolean} True if the collection exists, false otherwise.
+     */
+    issetCollection(collection: string): boolean;
+    /**
+     * Add a new entry to the specified database.
+     */
+    add(collection: string, arg: Arg, id_gen?: boolean): Promise<Arg>;
+    /**
+     * Find entries in the specified database based on search criteria.
+     */
+    find(collection: string, arg: ArgOrFunc, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<any[]>;
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    findOne(collection: string, arg: ArgOrFunc, context?: Context, findOpts?: FindOpts): Promise<Data>;
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    update(collection: string, arg: ArgOrFunc, obj: ArgOrFunc, context?: {}): Promise<boolean>;
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    updateOne(collection: string, arg: ArgOrFunc, obj: ArgOrFunc, context?: Context): Promise<boolean>;
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    remove(collection: string, arg: ArgOrFunc, context?: Context): Promise<boolean>;
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    removeOne(collection: string, arg: ArgOrFunc, context?: Context): Promise<boolean>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection: string): void;
+}
+export default dbActionC;

package/dist/esm/action.js

@@ -0,0 +1,194 @@
+import { existsSync, mkdirSync, readdirSync, appendFileSync, rmSync, writeFileSync, statSync } from "fs";
+import gen from "./gen.js";
+import { stringify } from "./format.js";
+import { find as _find, findOne as _findOne, update as _update, remove as _remove } from "./file/index.js";
+/**
+ * A class representing database actions on files.
+ * @class
+ */
+class dbActionC {
+    folder;
+    options;
+    /**
+     * Creates a new instance of dbActionC.
+     * @constructor
+     * @param {string} folder - The folder where database files are stored.
+     * @param {object} options - The options object.
+     */
+    constructor(folder, options) {
+        this.folder = folder;
+        this.options = {
+            maxFileSize: 2 * 1024 * 1024, //2 MB
+            ...options,
+        };
+        if (!existsSync(folder))
+            mkdirSync(folder, { recursive: true });
+    }
+    _getCollectionPath(collection) {
+        return this.folder + "/" + collection + "/";
+    }
+    /**
+     * Get a list of available databases in the specified folder.
+     * @returns {string[]} An array of database names.
+     */
+    getCollections() {
+        const collections = readdirSync(this.folder, { recursive: true, withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => {
+            if (dirent.parentPath === this.folder)
+                return dirent.name;
+            return dirent.parentPath.replace(this.folder + "/", "") + "/" + dirent.name;
+        });
+        return collections;
+    }
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     * @function
+     * @param {string} collection - The collection to check.
+     */
+    checkCollection(collection) {
+        const cpath = this._getCollectionPath(collection);
+        if (!existsSync(cpath))
+            mkdirSync(cpath, { recursive: true });
+    }
+    /**
+     * Check if a collection exists.
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @returns {boolean} True if the collection exists, false otherwise.
+     */
+    issetCollection(collection) {
+        const path = this.folder + "/" + collection;
+        return existsSync(path);
+    }
+    /**
+     * Add a new entry to the specified database.
+     */
+    async add(collection, arg, id_gen = true) {
+        this.checkCollection(collection);
+        const cpath = this._getCollectionPath(collection);
+        const file = cpath + getLastFile(cpath, this.options.maxFileSize);
+        if (id_gen)
+            arg._id = arg._id || gen();
+        const data = stringify(arg);
+        appendFileSync(file, data + "\n");
+        return arg;
+    }
+    /**
+     * Find entries in the specified database based on search criteria.
+     */
+    async find(collection, arg, context = {}, options = {}, findOpts = {}) {
+        options.reverse = options.reverse || false;
+        options.max = options.max || -1;
+        this.checkCollection(collection);
+        const cpath = this._getCollectionPath(collection);
+        const files = getSortedFiles(cpath).map(f => f.f);
+        if (options.reverse)
+            files.reverse();
+        let datas = [];
+        let totalEntries = 0;
+        for (let f of files) {
+            let data = await _find(cpath + f, arg, context, findOpts);
+            if (options.reverse)
+                data.reverse();
+            if (options.max !== -1) {
+                if (totalEntries + data.length > options.max) {
+                    let remainingEntries = options.max - totalEntries;
+                    data = data.slice(0, remainingEntries);
+                    totalEntries = options.max;
+                }
+                else {
+                    totalEntries += data.length;
+                }
+            }
+            datas = datas.concat(data);
+            if (options.max !== -1 && totalEntries >= options.max)
+                break;
+        }
+        return datas;
+    }
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    async findOne(collection, arg, context = {}, findOpts = {}) {
+        this.checkCollection(collection);
+        const cpath = this._getCollectionPath(collection);
+        const files = getSortedFiles(cpath).map(f => f.f);
+        for (let f of files) {
+            let data = await _findOne(cpath + f, arg, context, findOpts);
+            if (data)
+                return data;
+        }
+        return null;
+    }
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    async update(collection, arg, obj, context = {}) {
+        this.checkCollection(collection);
+        return await _update(this._getCollectionPath(collection), arg, obj, context);
+    }
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    async updateOne(collection, arg, obj, context = {}) {
+        this.checkCollection(collection);
+        return await _update(this._getCollectionPath(collection), arg, obj, context, true);
+    }
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    async remove(collection, arg, context = {}) {
+        this.checkCollection(collection);
+        return await _remove(this._getCollectionPath(collection), arg, context);
+    }
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    async removeOne(collection, arg, context = {}) {
+        this.checkCollection(collection);
+        return await _remove(this._getCollectionPath(collection), arg, context, true);
+    }
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection) {
+        rmSync(this.folder + "/" + collection, { recursive: true, force: true });
+    }
+}
+/**
+ * Get the last file in the specified directory.
+ */
+function getLastFile(path, maxFileSize = 1024 * 1024) {
+    if (!existsSync(path))
+        mkdirSync(path, { recursive: true });
+    const files = getSortedFiles(path);
+    if (files.length == 0) {
+        writeFileSync(path + "/1.db", "");
+        return "1.db";
+    }
+    const last = files[files.length - 1];
+    const info = path + "/" + last.f;
+    if (statSync(info).size < maxFileSize)
+        return last.f;
+    const num = last.i + 1;
+    writeFileSync(path + "/" + num + ".db", "");
+    return num + ".db";
+}
+/**
+ * Get all files in a directory sorted by name.
+ */
+function getSortedFiles(path) {
+    const files = readdirSync(path).filter(file => file.endsWith(".db"));
+    if (files.length == 0)
+        return [];
+    const filesWithoutExt = files.map(file => parseInt(file.replace(".db", "")));
+    filesWithoutExt.sort();
+    return filesWithoutExt.map(file => {
+        return {
+            i: file,
+            f: file + ".db"
+        };
+    });
+}
+export default dbActionC;