@wxn0brp/db 0.0.5 → 0.0.6

package/dist/esm/gen.js

@@ -0,0 +1,75 @@
+const usedIdsMap = new Map();
+/**
+ * Generates a unique identifier based on specified parts.
+ */
+export default function genId(parts = null, fill = 1) {
+    parts = changeInputToPartsArray(parts, fill);
+    const time = getTime();
+    const id = getUniqueRandom(time, parts);
+    return id;
+}
+/**
+ * Generates a unique random identifier based on time and parts.
+ * @param time - The current time in a base36 string format.
+ * @param parts - An array of parts to be used for generating the identifier.
+ * @param s - Recursion counter for handling collision (default: 0).
+ * @returns {string} The unique random identifier.
+ */
+function getUniqueRandom(time, partsA, s = 0) {
+    const parts = partsA.map(l => getRandom(l));
+    const id = [time, ...parts].join("-");
+    if (usedIdsMap.has(id)) {
+        s++;
+        if (s < 25)
+            return getUniqueRandom(time, partsA, s);
+        partsA = addOneToPods(partsA);
+        time = getTime();
+        return getUniqueRandom(time, partsA);
+    }
+    usedIdsMap.set(id, Date.now() + 2000);
+    usedIdsMap.forEach((value, key) => {
+        if (value < Date.now())
+            usedIdsMap.delete(key);
+    });
+    return id;
+}
+/**
+ * Generates a random string of base36 characters.
+ */
+function getRandom(unix) {
+    return (Math.floor(Math.random() * Math.pow(36, unix))).toString(36);
+}
+/**
+ * Gets the current time in a base36 string format.
+ */
+function getTime() {
+    return Math.floor(new Date().getTime() / 1000).toString(36);
+}
+/**
+ * Adds one to each part of the input array.
+ */
+function addOneToPods(array) {
+    const sum = array.reduce((acc, current) => acc + current, 0);
+    const num = sum + 1;
+    const len = array.length;
+    const result = [];
+    const quotient = Math.floor(num / len);
+    const remainder = num % len;
+    for (let i = 0; i < len; i++) {
+        if (i < remainder)
+            result.push(quotient + 1);
+        else
+            result.push(quotient);
+    }
+    return result;
+}
+/**
+ * Converts input to an array of parts.
+ */
+function changeInputToPartsArray(parts = null, fill = 1) {
+    if (Array.isArray(parts))
+        return parts;
+    if (typeof parts == "number")
+        return Array(parts).fill(fill);
+    return [1, 1];
+}

package/dist/esm/graph.d.ts

@@ -0,0 +1,47 @@
+import DataBase from "./database.js";
+import Data from "./types/data.js";
+/**
+ * A class representing a graph database.
+ * @class
+ */
+declare class Graph {
+    db: DataBase;
+    constructor(databaseFolder: string);
+    /**
+     * Adds an edge between two nodes.
+     */
+    add(collection: string, nodeA: string, nodeB: string): Promise<Data>;
+    /**
+     * Removes an edge between two nodes.
+     */
+    remove(collection: string, nodeA: string, nodeB: string): Promise<boolean>;
+    /**
+     * Finds all edges with either node equal to `node`.
+     */
+    find(collection: string, node: string): Promise<Data[]>;
+    /**
+     * Finds one edge with either node equal to `nodeA` and the other equal to `nodeB`.
+     */
+    findOne(collection: any, nodeA: any, nodeB: any): Promise<Data>;
+    /**
+     * Gets all edges in the database.
+     */
+    getAll(collection: any): Promise<Data[]>;
+    /**
+     * Get the names of all available databases.
+     */
+    getCollections(): Promise<string[]>;
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    checkCollection(collection: any): Promise<void>;
+    /**
+     * Check if a collection exists.
+     */
+    issetCollection(collection: any): Promise<boolean>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection: any): void;
+}
+export default Graph;

package/dist/esm/graph.js

@@ -0,0 +1,85 @@
+import DataBase from "./database.js";
+/**
+ * A class representing a graph database.
+ * @class
+ */
+class Graph {
+    db;
+    constructor(databaseFolder) {
+        this.db = new DataBase(databaseFolder);
+    }
+    /**
+     * Adds an edge between two nodes.
+     */
+    async add(collection, nodeA, nodeB) {
+        const sortedNodes = [nodeA, nodeB].sort();
+        return await this.db.add(collection, {
+            a: sortedNodes[0],
+            b: sortedNodes[1]
+        }, false);
+    }
+    /**
+     * Removes an edge between two nodes.
+     */
+    async remove(collection, nodeA, nodeB) {
+        const sortedNodes = [nodeA, nodeB].sort();
+        const query = { a: sortedNodes[0], b: sortedNodes[1] };
+        return await this.db.removeOne(collection, query);
+    }
+    /**
+     * Finds all edges with either node equal to `node`.
+     */
+    async find(collection, node) {
+        const edges = [];
+        const edgesByANode = await this.db.find(collection, { a: node });
+        const edgesByBNode = await this.db.find(collection, { b: node });
+        if (edgesByANode)
+            edges.push(...edgesByANode);
+        if (edgesByBNode)
+            edges.push(...edgesByBNode);
+        return edges;
+    }
+    /**
+     * Finds one edge with either node equal to `nodeA` and the other equal to `nodeB`.
+     */
+    async findOne(collection, nodeA, nodeB) {
+        const edgeAB = await this.db.findOne(collection, { a: nodeA, b: nodeB });
+        if (edgeAB)
+            return edgeAB;
+        const edgeBA = await this.db.findOne(collection, { a: nodeB, b: nodeA });
+        if (edgeBA)
+            return edgeBA;
+        return null;
+    }
+    /**
+     * Gets all edges in the database.
+     */
+    async getAll(collection) {
+        return await this.db.find(collection, {});
+    }
+    /**
+     * Get the names of all available databases.
+     */
+    async getCollections() {
+        return await this.db.getCollections();
+    }
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async checkCollection(collection) {
+        await this.db.checkCollection(collection);
+    }
+    /**
+     * Check if a collection exists.
+     */
+    async issetCollection(collection) {
+        return await this.db.issetCollection(collection);
+    }
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection) {
+        this.db.removeCollection(collection);
+    }
+}
+export default Graph;

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+import DataBase from "./database.js";
+import Graph from "./graph.js";
+import DataBaseRemote from "./remote/client/database.js";
+import GraphRemote from "./remote/client/graph.js";
+import genId from "./gen.js";
+import Relation from "./relation.js";
+export { DataBase, Graph, DataBaseRemote, GraphRemote, Relation, genId };

package/{index.js → dist/esm/index.js}

@@ -4,12 +4,4 @@ import DataBaseRemote from "./remote/client/database.js";
 import GraphRemote from "./remote/client/graph.js";
 import genId from "./gen.js";
 import Relation from "./relation.js";
-
-export {
-    DataBase,
-    Graph,
-    DataBaseRemote,
-    GraphRemote,
-    Relation,
-    genId
-};
+export { DataBase, Graph, DataBaseRemote, GraphRemote, Relation, genId };

package/dist/esm/relation.d.ts

@@ -0,0 +1,64 @@
+import DataBase from "./database.js";
+import { ArgOrFunc } from "./types/arg.js";
+import { DbFindOpts } from "./types/options.js";
+export interface Databases {
+    [key: string]: DataBase;
+}
+declare class Relation {
+    databases: Databases;
+    constructor(databases: Databases);
+    /**
+    * Resolves the relation path in format 'dbName.collectionName'
+    */
+    _resolvePath(path: string): {
+        db: DataBase;
+        collection: string;
+    };
+    /**
+     * Processes relations for a single item
+     * @param {Object} item - Item to process relations for
+     * @param {Object} relations - Relations configuration
+     * @returns {Promise<Object>} Processed item with resolved relations
+     */
+    _processItemRelations(item: Object, relations: Object): Promise<{
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    }>;
+    /**
+     * Finds items with relations
+     * @param path - Path in format 'dbName.collectionName'
+     * @param search - Search query or function
+     * @param relations - Relations configuration
+     * @param options - Search options
+     */
+    find(path: string, search: ArgOrFunc, relations?: {}, options?: DbFindOpts): Promise<{
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    }[]>;
+    /**
+     * Finds one item with relations
+     * @param path - Path in format 'dbName.collectionName'
+     * @param search - Search query or function
+     * @param relations - Relations configuration
+     */
+    findOne(path: string, search: ArgOrFunc, relations?: Object): Promise<{
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    }>;
+}
+export default Relation;

package/dist/esm/relation.js

@@ -0,0 +1,65 @@
+class Relation {
+    databases;
+    constructor(databases) {
+        this.databases = databases;
+    }
+    /**
+    * Resolves the relation path in format 'dbName.collectionName'
+    */
+    _resolvePath(path) {
+        const sanitizedPath = path.replace(/\\\./g, '\uffff');
+        const separatorIndex = sanitizedPath.indexOf('.');
+        if (separatorIndex === -1)
+            throw new Error(`Invalid path format "${path}". Expected format 'dbName.collectionName'.`);
+        const dbName = sanitizedPath.slice(0, separatorIndex).replace(/\uffff/g, '.');
+        const collectionName = sanitizedPath.slice(separatorIndex + 1).replace(/\uffff/g, '.');
+        if (!this.databases[dbName])
+            throw new Error(`Database "${dbName}" not found`);
+        return { db: this.databases[dbName], collection: collectionName };
+    }
+    /**
+     * Processes relations for a single item
+     * @param {Object} item - Item to process relations for
+     * @param {Object} relations - Relations configuration
+     * @returns {Promise<Object>} Processed item with resolved relations
+     */
+    async _processItemRelations(item, relations) {
+        const result = { ...item };
+        for (const [field, relationConfig] of Object.entries(relations)) {
+            const { from, localField, foreignField, as, multiple = false } = relationConfig;
+            const { db, collection } = this._resolvePath(from);
+            const searchQuery = { [foreignField]: item[localField] };
+            const fn = multiple ? db.find : db.findOne;
+            const relatedItem = await fn(collection, searchQuery);
+            result[as || field] = relatedItem;
+        }
+        return result;
+    }
+    /**
+     * Finds items with relations
+     * @param path - Path in format 'dbName.collectionName'
+     * @param search - Search query or function
+     * @param relations - Relations configuration
+     * @param options - Search options
+     */
+    async find(path, search, relations = {}, options = {}) {
+        const { db, collection } = this._resolvePath(path);
+        const items = await db.find(collection, search, {}, options);
+        const results = await Promise.all(items.map(item => this._processItemRelations(item, relations)));
+        return results;
+    }
+    /**
+     * Finds one item with relations
+     * @param path - Path in format 'dbName.collectionName'
+     * @param search - Search query or function
+     * @param relations - Relations configuration
+     */
+    async findOne(path, search, relations = {}) {
+        const { db, collection } = this._resolvePath(path);
+        const item = await db.findOne(collection, search);
+        if (!item)
+            return null;
+        return await this._processItemRelations(item, relations);
+    }
+}
+export default Relation;

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

@@ -0,0 +1,71 @@
+import CollectionManager from "../../CollectionManager.js";
+import { Remote, RequestData } from "./remote.js";
+import { Arg, ArgOrFunc } from "../../types/arg";
+import { DbFindOpts, FindOpts } from "../../types/options.js";
+import { Context } from "../../types/types";
+/**
+ * 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(type: string, data: RequestData): Promise<any>;
+    /**
+     * Create a new instance of a CollectionManager class.
+     */
+    c(collection: string): CollectionManager;
+    /**
+     * 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: any): Promise<any>;
+    /**
+     * Add data to a database.
+     */
+    add(collection: any, data: any, id_gen?: boolean): Promise<any>;
+    /**
+     * Find data in a database.
+     */
+    find(collection: string, search: ArgOrFunc, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<any>;
+    /**
+     * Find one data entry in a database.
+     */
+    findOne(collection: string, search: ArgOrFunc, context?: Context, findOpts?: FindOpts): Promise<any>;
+    /**
+     * Update data in a database.
+     */
+    update(collection: string, search: ArgOrFunc, arg: ArgOrFunc, context?: Context): Promise<any>;
+    /**
+     * Update one data entry in a database.
+     */
+    updateOne(collection: string, search: ArgOrFunc, arg: ArgOrFunc, context?: Context): Promise<any>;
+    /**
+     * Remove data from a database.
+     */
+    remove(collection: string, search: ArgOrFunc, context?: Context): Promise<any>;
+    /**
+     * Remove one data entry from a database.
+     */
+    removeOne(collection: string, search: ArgOrFunc, context?: Context): Promise<any>;
+    /**
+     * 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<any>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(name: string): Promise<any>;
+}
+export default DataBaseRemote;

package/dist/esm/remote/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 procesed = serializeFunctions(data);
+        data = {
+            keys: procesed.keys,
+            ...procesed.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, arg, context = {}) {
+        const searchStr = typeof search === "function" ? search.toString() : search;
+        const argStr = typeof arg === "function" ? arg.toString() : arg;
+        return await this._request("update", { collection, search: searchStr, arg: argStr, context });
+    }
+    /**
+     * Update one data entry in a database.
+     */
+    async updateOne(collection, search, arg, context = {}) {
+        const searchStr = typeof search === "function" ? search.toString() : search;
+        const argStr = typeof arg === "function" ? arg.toString() : arg;
+        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.
+     */
+    removeCollection(name) {
+        return this._request("removeCollection", { name });
+    }
+}
+export default DataBaseRemote;

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

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

package/dist/esm/remote/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/remote/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;