@wxn0brp/db 0.0.5 → 0.0.7

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

@@ -0,0 +1,188 @@
+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 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 (!existsSync(folder))
+            mkdirSync(folder, { recursive: true });
+    }
+    _getCollectionPath(collection) {
+        return this.folder + "/" + collection + "/";
+    }
+    /**
+     * Get a list of available databases in the specified folder.
+     */
+    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.
+     */
+    checkCollection(collection) {
+        const cpath = this._getCollectionPath(collection);
+        if (!existsSync(cpath))
+            mkdirSync(cpath, { recursive: true });
+    }
+    /**
+     * Check if a collection exists.
+     */
+    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, updater, context = {}) {
+        this.checkCollection(collection);
+        return await _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 _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 _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;

package/dist/esm/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/esm/client/database.js

@@ -0,0 +1,140 @@
+import got from "got";
+import CollectionManager from "../CollectionManager.js";
+import serializeFunctions from "./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 = serializeFunctions(data);
+        data = {
+            keys: processed.keys,
+            ...processed.data
+        };
+        const res = await got.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(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 });
+    }
+}
+export default DataBaseRemote;

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

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

package/dist/esm/client/function.js

@@ -0,0 +1,30 @@
+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 };
+}
+export default serializeFunctions;

package/dist/esm/client/graph.d.ts

@@ -0,0 +1,54 @@
+import { Remote, RequestData } from "./remote";
+/**
+ * A class representing a graph database.
+ * Uses a remote database.
+ * @class
+ */
+declare class GraphRemote {
+    remote: Remote;
+    /**
+     * Create a new database instance.
+     */
+    constructor(remote: Remote);
+    /**
+     * Make a request to the remote database.
+     */
+    _request(type: string, data: RequestData): Promise<any>;
+    /**
+     * Adds an edge between two nodes.
+     */
+    add(collection: string, nodeA: string, nodeB: string): Promise<any>;
+    /**
+     * Removes an edge between two nodes.
+     */
+    remove(collection: string, nodeA: string, nodeB: string): Promise<any>;
+    /**
+     * Finds all edges with either node equal to `node`.
+     */
+    find(collection: string, node: string): Promise<any>;
+    /**
+     * Finds one edge with either node equal to `nodeA` and the other equal to `nodeB`.
+     */
+    findOne(collection: string, nodeA: string, nodeB: string): Promise<any>;
+    /**
+     * Get all edges in the collection.
+     */
+    getAll(collection: string): Promise<any>;
+    /**
+     * Get the names of all available databases.
+     */
+    getCollections(): Promise<any>;
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    checkCollection(collection: string): Promise<any>;
+    /**
+     * Check if a collection exists.
+     */
+    issetCollection(collection: string): Promise<any>;
+    /**
+     * Remove the specified collection.
+     */
+    removeCollection(collection: string): Promise<any>;
+}
+export default GraphRemote;

package/dist/esm/client/graph.js

@@ -0,0 +1,88 @@
+import got from "got";
+/**
+ * A class representing a graph database.
+ * Uses a remote database.
+ * @class
+ */
+class GraphRemote {
+    remote;
+    /**
+     * Create a new database instance.
+     */
+    constructor(remote) {
+        this.remote = remote;
+    }
+    /**
+     * Make a request to the remote database.
+     */
+    async _request(type, data) {
+        data.db = this.remote.name;
+        const res = await got.post(this.remote.url + "/db/graph/" + type, {
+            // @ts-ignore
+            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;
+    }
+    /**
+     * Adds an edge between two nodes.
+     */
+    async add(collection, nodeA, nodeB) {
+        return await this._request("add", { collection, nodeA, nodeB });
+    }
+    /**
+     * Removes an edge between two nodes.
+     */
+    async remove(collection, nodeA, nodeB) {
+        return await this._request("remove", { collection, nodeA, nodeB });
+    }
+    /**
+     * Finds all edges with either node equal to `node`.
+     */
+    async find(collection, node) {
+        return await this._request("find", { collection, node });
+    }
+    /**
+     * Finds one edge with either node equal to `nodeA` and the other equal to `nodeB`.
+     */
+    async findOne(collection, nodeA, nodeB) {
+        return await this._request("findOne", { collection, nodeA, nodeB });
+    }
+    /**
+     * Get all edges in the collection.
+     */
+    async getAll(collection) {
+        return await this._request("getAll", { 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 });
+    }
+    /**
+     * Remove the specified collection.
+     */
+    removeCollection(collection) {
+        return this._request("removeCollection", { collection });
+    }
+}
+export default GraphRemote;

package/dist/esm/client/remote.d.ts

@@ -0,0 +1,16 @@
+export interface Remote {
+    name: string;
+    url: string;
+    auth: string;
+}
+export interface RequestData {
+    collection?: string;
+    db?: string;
+    keys?: string[];
+    [key: string]: any;
+}
+export interface findOptsRemote {
+    select?: string[];
+    exclude?: string[];
+    transform?: string;
+}

package/dist/esm/client/remote.js

@@ -0,0 +1 @@
+export {};