@wxn0brp/db 0.0.4 → 0.0.6

package/README.md

@@ -20,6 +20,8 @@ import { DataBase, Graph, DataBaseRemote, GraphRemote, Relation, genId } from "@
 
 ## Documentation
 
+Website: [https://wxn0brp.github.io/database/](https://wxn0brp.github.io/database/)
+
 For detailed information, refer to the following resources:
 
 - [DataBase Documentation](./docs/database.md)
@@ -27,4 +29,5 @@ For detailed information, refer to the following resources:
 - [Remote Database and Graph Client Documentation](./docs/remote.md)
 - [Remote Server Documentation](./docs/remote_server.md)
 - [Search Options Documentation](./docs/search_opts.md)
+- [Find Options Documentation](./docs/find_opts.md)
 - [Relation Documentation](./docs/relation.md)

package/dist/cjs/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/cjs/CollectionManager.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+    }
+}
+exports.default = CollectionManager;

package/dist/cjs/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/cjs/action.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const gen_js_1 = __importDefault(require("./gen.js"));
+const format_js_1 = require("./format.js");
+const index_js_1 = require("./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 (!(0, fs_1.existsSync)(folder))
+            (0, fs_1.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 = (0, fs_1.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 (!(0, fs_1.existsSync)(cpath))
+            (0, fs_1.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 (0, fs_1.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 || (0, gen_js_1.default)();
+        const data = (0, format_js_1.stringify)(arg);
+        (0, fs_1.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 (0, index_js_1.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 (0, index_js_1.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 (0, index_js_1.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 (0, index_js_1.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 (0, index_js_1.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 (0, index_js_1.remove)(this._getCollectionPath(collection), arg, context, true);
+    }
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection) {
+        (0, fs_1.rmSync)(this.folder + "/" + collection, { recursive: true, force: true });
+    }
+}
+/**
+ * Get the last file in the specified directory.
+ */
+function getLastFile(path, maxFileSize = 1024 * 1024) {
+    if (!(0, fs_1.existsSync)(path))
+        (0, fs_1.mkdirSync)(path, { recursive: true });
+    const files = getSortedFiles(path);
+    if (files.length == 0) {
+        (0, fs_1.writeFileSync)(path + "/1.db", "");
+        return "1.db";
+    }
+    const last = files[files.length - 1];
+    const info = path + "/" + last.f;
+    if ((0, fs_1.statSync)(info).size < maxFileSize)
+        return last.f;
+    const num = last.i + 1;
+    (0, fs_1.writeFileSync)(path + "/" + num + ".db", "");
+    return num + ".db";
+}
+/**
+ * Get all files in a directory sorted by name.
+ */
+function getSortedFiles(path) {
+    const files = (0, fs_1.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"
+        };
+    });
+}
+exports.default = dbActionC;

package/dist/cjs/database.d.ts

@@ -0,0 +1,77 @@
+import dbActionC from "./action.js";
+import executorC from "./executor.js";
+import CollectionManager from "./CollectionManager.js";
+import { DbFindOpts, DbOpts, FindOpts } from "./types/options.js";
+import { Arg, ArgOrFunc } from "./types/arg.js";
+import Data from "./types/data.js";
+import { Context } from "./types/types.js";
+/**
+ * Represents a database management class for performing CRUD operations.
+ * @class
+ */
+declare class DataBase {
+    dbAction: dbActionC;
+    executor: executorC;
+    constructor(folder: string, options?: DbOpts);
+    /**
+     * Create a new instance of a CollectionManager class.
+     */
+    c(collection: string): CollectionManager;
+    /**
+     * Get the names of all available databases.
+     */
+    getCollections(): Promise<string[]>;
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    checkCollection(collection: string): Promise<void>;
+    /**
+     * Check if a collection exists.
+     */
+    issetCollection(collection: string): Promise<boolean>;
+    /**
+     * Add data to a database.
+     */
+    add(collection: string, data: Arg, id_gen?: boolean): Promise<Data>;
+    /**
+     * Find data in a database.
+     */
+    find(collection: string, search: ArgOrFunc, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<Data[]>;
+    /**
+     * Find one data entry in a database.
+     *
+     * @async
+     * @function
+     * @param {string} collection - Name of the database collection.
+     * @param {function|Object} search - The query. It can be an object or a function.
+     * @param {Object} context - The context object (for functions).
+     * @param {Object} findOpts - Update result object with findOpts options.
+     * @returns {Promise<Object|null>} A Promise that resolves with the first matching data entry.
+     */
+    findOne(collection: string, search: ArgOrFunc, context?: Context, findOpts?: FindOpts): Promise<Data>;
+    /**
+     * Update data in a database.
+     */
+    update(collection: string, search: ArgOrFunc, arg: ArgOrFunc, context?: {}): Promise<boolean>;
+    /**
+     * Update one data entry in a database.
+     */
+    updateOne(collection: string, search: ArgOrFunc, arg: ArgOrFunc, context?: Context): Promise<boolean>;
+    /**
+     * Remove data from a database.
+     */
+    remove(collection: string, search: ArgOrFunc, context?: Context): Promise<boolean>;
+    /**
+     * Remove one data entry from a database.
+     */
+    removeOne(collection: string, search: ArgOrFunc, context?: Context): Promise<boolean>;
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     */
+    updateOneOrAdd(collection: string, search: ArgOrFunc, arg: ArgOrFunc, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection: string): void;
+}
+export default DataBase;

package/dist/cjs/database.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const action_js_1 = __importDefault(require("./action.js"));
+const executor_js_1 = __importDefault(require("./executor.js"));
+const CollectionManager_js_1 = __importDefault(require("./CollectionManager.js"));
+/**
+ * Represents a database management class for performing CRUD operations.
+ * @class
+ */
+class DataBase {
+    dbAction;
+    executor;
+    constructor(folder, options = {}) {
+        this.dbAction = new action_js_1.default(folder, options);
+        this.executor = new executor_js_1.default();
+    }
+    /**
+     * Create a new instance of a CollectionManager class.
+     */
+    c(collection) {
+        return new CollectionManager_js_1.default(this, collection);
+    }
+    /**
+     * Get the names of all available databases.
+     */
+    async getCollections() {
+        return this.dbAction.getCollections();
+    }
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async checkCollection(collection) {
+        this.dbAction.checkCollection(collection);
+    }
+    /**
+     * Check if a collection exists.
+     */
+    async issetCollection(collection) {
+        return this.dbAction.issetCollection(collection);
+    }
+    /**
+     * Add data to a database.
+     */
+    async add(collection, data, id_gen = true) {
+        return await this.executor.addOp(this.dbAction.add.bind(this.dbAction), collection, data, id_gen);
+    }
+    /**
+     * Find data in a database.
+     */
+    async find(collection, search, context = {}, options = {}, findOpts = {}) {
+        return await this.executor.addOp(this.dbAction.find.bind(this.dbAction), collection, search, context, options, findOpts);
+    }
+    /**
+     * Find one data entry in a database.
+     *
+     * @async
+     * @function
+     * @param {string} collection - Name of the database collection.
+     * @param {function|Object} search - The query. It can be an object or a function.
+     * @param {Object} context - The context object (for functions).
+     * @param {Object} findOpts - Update result object with findOpts options.
+     * @returns {Promise<Object|null>} A Promise that resolves with the first matching data entry.
+     */
+    async findOne(collection, search, context = {}, findOpts = {}) {
+        return await this.executor.addOp(this.dbAction.findOne.bind(this.dbAction), collection, search, context, findOpts);
+    }
+    /**
+     * Update data in a database.
+     */
+    async update(collection, search, arg, context = {}) {
+        return await this.executor.addOp(this.dbAction.update.bind(this.dbAction), collection, search, arg, context);
+    }
+    /**
+     * Update one data entry in a database.
+     */
+    async updateOne(collection, search, arg, context = {}) {
+        return await this.executor.addOp(this.dbAction.updateOne.bind(this.dbAction), collection, search, arg, context);
+    }
+    /**
+     * Remove data from a database.
+     */
+    async remove(collection, search, context = {}) {
+        return await this.executor.addOp(this.dbAction.remove.bind(this.dbAction), collection, search, context);
+    }
+    /**
+     * Remove one data entry from a database.
+     */
+    async removeOne(collection, search, context = {}) {
+        return await this.executor.addOp(this.dbAction.removeOne.bind(this.dbAction), collection, search, context);
+    }
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     */
+    async updateOneOrAdd(collection, search, arg, add_arg = {}, context = {}, id_gen = true) {
+        const res = await this.updateOne(collection, search, arg, context);
+        if (!res) {
+            const assignData = [];
+            if (typeof search === "object" && !Array.isArray(search))
+                assignData.push(search);
+            if (typeof arg === "object" && !Array.isArray(arg))
+                assignData.push(arg);
+            if (typeof add_arg === "object" && !Array.isArray(add_arg))
+                assignData.push(add_arg);
+            await this.add(collection, Object.assign({}, ...assignData), id_gen);
+        }
+        return res;
+    }
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection) {
+        this.dbAction.removeCollection(collection);
+    }
+}
+exports.default = DataBase;

package/dist/cjs/executor.d.ts

@@ -0,0 +1,28 @@
+interface Task {
+    func: Function;
+    param: any[];
+    resolve: Function;
+    reject: Function;
+}
+/**
+ * A simple executor for queuing and executing asynchronous operations sequentially.
+ * @class
+ */
+declare class executorC {
+    quote: Task[];
+    isExecuting: boolean;
+    /**
+     * Create a new executor instance.
+     * @constructor
+     */
+    constructor();
+    /**
+     * Add an asynchronous operation to the execution queue.
+     */
+    addOp(func: Function, ...param: any[]): Promise<unknown>;
+    /**
+     * Execute the queued asynchronous operations sequentially.
+     */
+    execute(): Promise<void>;
+}
+export default executorC;