@wxn0brp/db 0.0.4 → 0.0.6

package/dist/cjs/graph.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const database_js_1 = __importDefault(require("./database.js"));
+/**
+ * A class representing a graph database.
+ * @class
+ */
+class Graph {
+    db;
+    constructor(databaseFolder) {
+        this.db = new database_js_1.default(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);
+    }
+}
+exports.default = Graph;

package/{index.d.ts → dist/cjs/index.d.ts}

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

package/dist/cjs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genId = exports.Relation = exports.GraphRemote = exports.DataBaseRemote = exports.Graph = exports.DataBase = void 0;
+const database_js_1 = __importDefault(require("./database.js"));
+exports.DataBase = database_js_1.default;
+const graph_js_1 = __importDefault(require("./graph.js"));
+exports.Graph = graph_js_1.default;
+const database_js_2 = __importDefault(require("./remote/client/database.js"));
+exports.DataBaseRemote = database_js_2.default;
+const graph_js_2 = __importDefault(require("./remote/client/graph.js"));
+exports.GraphRemote = graph_js_2.default;
+const gen_js_1 = __importDefault(require("./gen.js"));
+exports.genId = gen_js_1.default;
+const relation_js_1 = __importDefault(require("./relation.js"));
+exports.Relation = relation_js_1.default;

package/dist/cjs/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/{relation.js → dist/cjs/relation.js}

@@ -1,86 +1,67 @@
-class Relation{
-    constructor(databases){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Relation {
+    databases;
+    constructor(databases) {
         this.databases = databases;
     }
-
-     /**
-     * Resolves the relation path in format 'dbName.collectionName'
-     * @param {string} path - Path in format 'dbName.collectionName' with support for escaped dots (\.)
-     * @returns {Object} Object containing database and collection name
-     * @throws {Error} If database doesn't exist
-     */
-     _resolvePath(path){
+    /**
+    * Resolves the relation path in format 'dbName.collectionName'
+    */
+    _resolvePath(path) {
         const sanitizedPath = path.replace(/\\\./g, '\uffff');
         const separatorIndex = sanitizedPath.indexOf('.');
-
-        if(separatorIndex === -1)
+        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])
+        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){
+    async _processItemRelations(item, relations) {
         const result = { ...item };
-
-        for(const [field, relationConfig] of Object.entries(relations)){
+        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 {string} path - Path in format 'dbName.collectionName'
-     * @param {Object|Function} search - Search query or function
-     * @param {Object} relations - Relations configuration
-     * @param {Object} options - Search options
-     * @returns {Promise<Array>} Array of items with resolved 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={}){
+    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))
-        );
-
+        const results = await Promise.all(items.map(item => this._processItemRelations(item, relations)));
         return results;
     }
-
     /**
      * Finds one item with relations
-     * @param {string} path - Path in format 'dbName.collectionName'
-     * @param {Object|Function} search - Search query or function
-     * @param {Object} relations - Relations configuration
-     * @returns {Promise<Object>} Item with resolved relations
+     * @param path - Path in format 'dbName.collectionName'
+     * @param search - Search query or function
+     * @param relations - Relations configuration
      */
-    async findOne(path, search, relations={}){
+    async findOne(path, search, relations = {}) {
         const { db, collection } = this._resolvePath(path);
         const item = await db.findOne(collection, search);
-
-        if (!item) return null;
-
+        if (!item)
+            return null;
         return await this._processItemRelations(item, relations);
     }
 }
-
-export default Relation;
+exports.default = Relation;

package/dist/cjs/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/cjs/remote/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 procesed = (0, function_js_1.default)(data);
+        data = {
+            keys: procesed.keys,
+            ...procesed.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, 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 });
+    }
+}
+exports.default = DataBaseRemote;

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

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

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

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