@wxn0brp/db 0.0.5 → 0.0.7

package/README.md

@@ -20,11 +20,14 @@ 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)
 - [Graph Documentation](./docs/graph.md)
 - [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)
+- [Updater Options Documentation](./docs/updater.md)
 - [Relation Documentation](./docs/relation.md)

package/dist/cjs/CollectionManager.d.ts

@@ -0,0 +1,44 @@
+import DataBase from "./database.js";
+import DataBaseRemote from "./client/database.js";
+import { Arg, Search, Updater } from "./types/arg.js";
+import { DbFindOpts, FindOpts } from "./types/options.js";
+import { Context } from "./types/types.js";
+import Data from "./types/data.js";
+declare class CollectionManager {
+    db: DataBase | DataBaseRemote;
+    collection: string;
+    constructor(db: DataBase | DataBaseRemote, collection: string);
+    /**
+     * Add data to a database.
+     */
+    add<T = Data>(data: Arg, id_gen?: boolean): Promise<T>;
+    /**
+     * Find data in a database.
+     */
+    find<T = Data>(search: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    /**
+     * Find one data entry in a database.
+     */
+    findOne<T = Data>(search: Search, context?: Context, findOpts?: FindOpts): Promise<T>;
+    /**
+     * Update data in a database.
+     */
+    update(search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    /**
+     * Update one data entry in a database.
+     */
+    updateOne(search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    /**
+     * Remove data from a database.
+     */
+    remove(search: Search, context?: Context): Promise<boolean>;
+    /**
+     * Remove one data entry from a database.
+     */
+    removeOne(search: Search, context?: Context): Promise<boolean>;
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     */
+    updateOneOrAdd(search: Search, arg: Search, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
+}
+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, updater, context = {}) {
+        return await this.db.update(this.collection, search, updater, context);
+    }
+    /**
+     * Update one data entry in a database.
+     */
+    async updateOne(search, updater, context = {}) {
+        return await this.db.updateOne(this.collection, search, updater, 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,66 @@
+import { Arg, Search, Updater } from "./types/arg.js";
+import { DbFindOpts, DbOpts, FindOpts } from "./types/options.js";
+import { Context } from "./types/types";
+import { SearchOptions } from "./types/searchOpts.js";
+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 folder - The folder where database files are stored.
+     * @param options - The options object.
+     */
+    constructor(folder: string, options: DbOpts);
+    _getCollectionPath(collection: string): string;
+    /**
+     * Get a list of available databases in the specified folder.
+     */
+    getCollections(): string[];
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    checkCollection(collection: string): void;
+    /**
+     * Check if a collection exists.
+     */
+    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: Search, 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: SearchOptions, 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: Search, updater: Updater, 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: Search, updater: Updater, context?: Context): Promise<boolean>;
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    remove(collection: string, arg: Search, context?: Context): Promise<boolean>;
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    removeOne(collection: string, arg: Search, 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,193 @@
+"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 folder - The folder where database files are stored.
+     * @param 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.
+     */
+    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.
+     */
+    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.
+     */
+    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, updater, context = {}) {
+        this.checkCollection(collection);
+        return await (0, index_js_1.update)(this._getCollectionPath(collection), arg, updater, context);
+    }
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    async updateOne(collection, arg, updater, context = {}) {
+        this.checkCollection(collection);
+        return await (0, index_js_1.update)(this._getCollectionPath(collection), arg, updater, 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/client/database.d.ts

@@ -0,0 +1,72 @@
+import CollectionManager from "../CollectionManager.js";
+import { Remote, RequestData } from "./remote.js";
+import { Arg, Search, Updater } from "../types/arg";
+import { DbFindOpts, FindOpts } from "../types/options.js";
+import { Context } from "../types/types";
+import Data from "../types/data.js";
+/**
+ * Represents a database management class for performing CRUD operations.
+ * Uses a remote database.
+ * @class
+ */
+declare class DataBaseRemote {
+    remote: Remote;
+    constructor(remote: Remote);
+    /**
+     * Make a request to the remote database.
+     */
+    _request<T>(type: string, data: RequestData): Promise<T>;
+    /**
+     * 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<boolean>;
+    /**
+     * Check if a collection exists.
+     */
+    issetCollection(collection: string): Promise<boolean>;
+    /**
+     * Add data to a database.
+     */
+    add<T = Data>(collection: string, data: Arg, id_gen?: boolean): Promise<T>;
+    /**
+     * Find data in a database.
+     */
+    find<T = Data>(collection: string, search: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    /**
+     * Find one data entry in a database.
+     */
+    findOne<T = Data>(collection: string, search: Search, context?: Context, findOpts?: FindOpts): Promise<T>;
+    /**
+     * Update data in a database.
+     */
+    update(collection: string, search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    /**
+     * Update one data entry in a database.
+     */
+    updateOne(collection: string, search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    /**
+     * Remove data from a database.
+     */
+    remove(collection: string, search: Search, context?: Context): Promise<boolean>;
+    /**
+     * Remove one data entry from a database.
+     */
+    removeOne(collection: string, search: Search, 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: Search, arg: Search, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(name: string): Promise<boolean>;
+}
+export default DataBaseRemote;

package/dist/cjs/client/database.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const got_1 = __importDefault(require("got"));
+const CollectionManager_js_1 = __importDefault(require("../CollectionManager.js"));
+const function_js_1 = __importDefault(require("./function.js"));
+/**
+ * Represents a database management class for performing CRUD operations.
+ * Uses a remote database.
+ * @class
+ */
+class DataBaseRemote {
+    remote;
+    constructor(remote) {
+        this.remote = remote;
+    }
+    /**
+     * Make a request to the remote database.
+     */
+    async _request(type, data) {
+        data.db = this.remote.name;
+        const processed = (0, function_js_1.default)(data);
+        data = {
+            keys: processed.keys,
+            ...processed.data
+        };
+        const res = await got_1.default.post(this.remote.url + "/db/database/" + type, {
+            // @ts-ignore: Some jerk can't do the types correctly.
+            body: data,
+            headers: {
+                "Authorization": this.remote.auth
+            },
+            json: true,
+            responseType: "json"
+        });
+        if (res.body.err)
+            throw new Error(res.body.msg);
+        return res.body.result;
+    }
+    /**
+     * 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 await this._request("getCollections", {});
+    }
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async checkCollection(collection) {
+        return await this._request("checkCollection", { collection });
+    }
+    /**
+     * Check if a collection exists.
+     */
+    async issetCollection(collection) {
+        return await this._request("issetCollection", { collection });
+    }
+    /**
+     * Add data to a database.
+     */
+    async add(collection, data, id_gen = true) {
+        return await this._request("add", { collection, data, id_gen });
+    }
+    /**
+     * Find data in a database.
+     */
+    async find(collection, search, context = {}, options = {}, findOpts = {}) {
+        const searchStr = typeof search === "function" ? search.toString() : search;
+        const findOptsRemote = {};
+        if (findOpts.select)
+            findOptsRemote.select = findOpts.select;
+        if (findOpts.exclude)
+            findOptsRemote.exclude = findOpts.exclude;
+        if (findOpts.transform)
+            findOptsRemote.transform = findOpts.transform.toString();
+        return await this._request("find", { collection, search: searchStr, options, context, findOpts });
+    }
+    /**
+     * Find one data entry in a database.
+     */
+    async findOne(collection, search, context = {}, findOpts = {}) {
+        const searchStr = typeof search === "function" ? search.toString() : search;
+        const findOptsRemote = {};
+        if (findOpts.select)
+            findOptsRemote.select = findOpts.select;
+        if (findOpts.exclude)
+            findOptsRemote.exclude = findOpts.exclude;
+        if (findOpts.transform)
+            findOptsRemote.transform = findOpts.transform.toString();
+        return await this._request("findOne", { collection, search: searchStr, context, findOpts });
+    }
+    /**
+     * Update data in a database.
+     */
+    async update(collection, search, updater, context = {}) {
+        const searchStr = typeof search === "function" ? search.toString() : search;
+        const argStr = typeof updater === "function" ? updater.toString() : updater;
+        return await this._request("update", { collection, search: searchStr, arg: argStr, context });
+    }
+    /**
+     * Update one data entry in a database.
+     */
+    async updateOne(collection, search, updater, context = {}) {
+        const searchStr = typeof search === "function" ? search.toString() : search;
+        const argStr = typeof updater === "function" ? updater.toString() : updater;
+        return await this._request("updateOne", { collection, search: searchStr, arg: argStr, context });
+    }
+    /**
+     * Remove data from a database.
+     */
+    async remove(collection, search, context = {}) {
+        const searchStr = typeof search === "function" ? search.toString() : search;
+        return await this._request("remove", { collection, search: searchStr, context });
+    }
+    /**
+     * Remove one data entry from a database.
+     */
+    async removeOne(collection, search, context = {}) {
+        const searchStr = typeof search === "function" ? search.toString() : search;
+        return await this._request("removeOne", { collection, search: searchStr, 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 searchStr = typeof search === "function" ? search.toString() : search;
+        const argStr = typeof arg === "function" ? arg.toString() : arg;
+        return await this._request("updateOneOrAdd", { collection, search: searchStr, arg: argStr, add_arg, id_gen, context });
+    }
+    /**
+     * Removes a database collection from the file system.
+     */
+    async removeCollection(name) {
+        return await this._request("removeCollection", { name });
+    }
+}
+exports.default = DataBaseRemote;

package/dist/cjs/client/function.d.ts

@@ -0,0 +1,5 @@
+declare function serializeFunctions(data: Object): {
+    data: Object;
+    keys: string[];
+};
+export default serializeFunctions;

package/dist/cjs/client/function.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function serializeFunctions(data) {
+    const functionKeys = [];
+    function convertFunctionToString(fn) {
+        return typeof fn === "function" ? fn.toString() : fn;
+    }
+    function traverseAndSerialize(obj, path = "") {
+        Object.keys(obj).forEach((key) => {
+            const value = obj[key];
+            const fullPath = path ? `${path}.${key.replace(/\./g, "[dot]")}` : key;
+            if (typeof value === "function") {
+                functionKeys.push(fullPath);
+                obj[key] = convertFunctionToString(value);
+            }
+            else if (Array.isArray(value)) {
+                value.forEach((item, index) => {
+                    if (typeof item === "function") {
+                        functionKeys.push(`${fullPath}[${index}]`);
+                        value[index] = convertFunctionToString(item);
+                    }
+                });
+            }
+            else if (typeof value === "object" && value !== null) {
+                traverseAndSerialize(value, fullPath);
+            }
+        });
+    }
+    traverseAndSerialize(data);
+    return { data, keys: functionKeys };
+}
+exports.default = serializeFunctions;