@wxn0brp/db 0.0.1

package/graph.js

@@ -0,0 +1,130 @@
+import DataBase from "./database.js";
+
+/**
+ * A class representing a graph database.
+ * @class
+ */
+class Graph{
+    /**
+     * Initializes the graph database.
+     * @constructor
+     * @param {string} databaseFolder - The folder where the database is stored.
+     */
+    constructor(databaseFolder){
+        this.db = new DataBase(databaseFolder);
+    }
+
+    /**
+     * Adds an edge between two nodes.
+     * @async
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @param {string} nodeA - The first node.
+     * @param {string} nodeB - The second node.
+     * @returns {Promise<Object>} A promise that resolves with the added edge.
+     */
+    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
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @param {string} nodeA - The first node.
+     * @param {string} nodeB - The second node.
+     * @returns {Promise<boolean>} A promise that resolves when the edge is removed.
+     */
+    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
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @param {string} node - The node to search for.
+     * @returns {Promise<Object[]>} A promise that resolves with the found edges.
+     */
+    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
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @param {string} nodeA - The first node.
+     * @param {string} nodeB - The second node.
+     * @returns {Promise<Object|null>} A promise that resolves with the found edge or null if not found.
+     */
+    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
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @returns {Promise<Object[]>} A promise that resolves with all edges in the database.
+     */
+    async getAll(collection){
+        return await this.db.find(collection, {});
+    }
+
+    /**
+     * Get the names of all available databases.
+     *
+     * @function
+     * @returns {string[]} An array of database names.
+     */
+    async getCollections(){
+        return await this.db.getCollections();
+    }
+
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     *
+     * @function
+     * @param {string} collection - The collection to check.
+     */
+    async checkCollection(collection){
+        await this.dbAction.checkCollection(collection);
+    }
+
+    /**
+     * Check if a collection exists.
+     *
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @returns {boolean} True if the collection exists, false otherwise.
+     */
+    async issetCollection(collection){
+        return await this.dbAction.issetCollection(collection);
+    }
+}
+
+export default Graph;

package/more.js

@@ -0,0 +1,103 @@
+/**
+ * Checks if an object meets the criteria specified in the fields with operators.
+ * @function
+ * @param {Object} obj - The object to check.
+ * @param {Object} fields - Criteria with operators.
+ * @returns {boolean} - Whether the object meets the criteria.
+ * @throws {Error} - If fields is not an object.
+ */
+export function hasFieldsAdvanced(obj, fields){
+    if(typeof fields !== "object" || fields === null){
+        throw new Error("Fields must be an object");
+    }
+    
+    if("$and" in fields){
+        return fields["$and"].every(subFields => hasFieldsAdvanced(obj, subFields));
+    }
+
+    if("$or" in fields){
+        return fields["$or"].some(subFields => hasFieldsAdvanced(obj, subFields));
+    }
+
+    if("$set" in fields){
+        const setFields = fields["$set"];
+        return hasFields(obj, setFields);
+    }
+
+    if("$not" in fields){
+        return !hasFieldsAdvanced(obj, fields["$not"]);
+    }
+
+    return hasFields(obj, fields);
+}
+
+/**
+ * Checks if an object matches the standard field comparison.
+ * @function
+ * @param {Object} obj - The object to check.
+ * @param {Object} fields - Criteria to compare.
+ * @returns {boolean} - Whether the object matches the criteria.
+ */
+export function hasFields(obj, fields){
+    const keys = Object.keys(fields);
+    return keys.every(key => {
+        if(obj[key]){
+            if(typeof fields[key] === "object" && fields[key] !== null){
+                return hasFields(obj[key], fields[key]);
+            }
+            return obj[key] === fields[key];
+        }
+        return false;
+    });
+}
+
+/**
+ * Updates an object with new values.
+ * @function
+ * @param {Object} obj - The object to update.
+ * @param {Object} newVal - An object containing new values to update in the target object.
+ * @returns {Object} The updated object.
+ */
+export function updateObject(obj, newVal){
+    for(let key in newVal){
+        if(newVal.hasOwnProperty(key)){
+            obj[key] = newVal[key];
+        }
+    }
+    return obj;
+}
+
+/**
+ * Updates an object with new values from a findOpts object.
+ * @function
+ * @param {Object} obj - The object to update.
+ * @param {Object} findOpts - An object containing options to update the target object.
+ * @param {function} [findOpts.transform] - A function to transform the object before applying the other options.
+ * @param {string[]} [findOpts.select] - An array of fields to select from the target object.
+ * @param {string[]} [findOpts.exclude] - An array of fields to exclude from the target object.
+ * @returns {Object} The updated object.
+ */
+export function updateFindObject(obj, findOpts){
+    const {
+        transform,
+        select,
+        exclude,
+    } = findOpts;
+
+    if(typeof transform === "function") obj = transform(obj);
+    
+    if(Array.isArray(exclude)){
+        exclude.forEach(field => {
+            if(obj.hasOwnProperty(field)) delete obj[field];
+        });
+    }
+
+    if(Array.isArray(select)){
+        obj = select.reduce((acc, field) => {
+            if(obj.hasOwnProperty(field)) acc[field] = obj[field];
+            return acc;
+        }, {});
+    }
+
+    return obj;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@wxn0brp/db",
+  "version": "0.0.1",
+  "main": "index.js",
+  "description": "A simple file-based database management system with support for CRUD operations, custom queries, and graph structures.",
+  "homepage": "https://github.com/wxn0brP/database",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wxn0brP/database.git"
+  },
+  "keywords": [
+    "database",
+    "file-based",
+    "CRUD",
+    "graph",
+    "query"
+  ],
+  "author": "wxn0brP",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "body-parser": "^1.20.3",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.5",
+    "express": "^4.21.1",
+    "got": "^14.4.2",
+    "json5": "^2.2.3",
+    "jwt-simple": "^0.5.6",
+    "node-cache": "^5.1.2",
+    "readline": "^1.3.0"
+  }
+}

package/remote/client/database.js

@@ -0,0 +1,229 @@
+import got from "got";
+import CollectionManager from "../../CollectionManager.js";
+
+/**
+ * Represents a database management class for performing CRUD operations.
+ * Uses a remote database.
+ * @class
+ */
+class DataBaseRemote{
+    /**
+     * Create a new database instance.
+     * @constructor
+     * @param {object} remote - The remote database object.
+     * @param {string} remote.name - The name of the database.
+     * @param {string} remote.folder - The folder path where the database files are stored.
+     * @param {string} remote.auth - The authentication token.
+     * @param {string} remote.url - The URL of the remote database.
+     */
+    constructor(remote){
+        this.remote = remote;
+    }
+
+    /**
+     * Make a request to the remote database.
+     * @async
+     * @function
+     * @param {string} type - The type of the request.
+     * @param {object} data - The data to send with the request.
+     * @returns {Promise<*>} A Promise that resolves with the result of the request.
+     * @throws {Error} If the request failed.
+     */
+    async _request(type, data){
+        data.db = this.remote.name;
+        const res = await got.post(this.remote.url + "/db/database/" + type, {
+            json: data,
+            headers: {
+                "Authorization": this.remote.auth
+            },
+            responseType: "json"
+        });
+
+        if(res.body.err) throw new Error(res.body.msg);
+        return res.body.result;
+    }
+
+    /**
+     * Create a new instance of a CollectionManager class.
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @returns {CollectionManager} A new instance of CollectionManager.
+     */
+    c(collection){
+        return new CollectionManager(this, collection);
+    }
+
+    /**
+     * Get the names of all available databases.
+     *
+     * @function
+     * @returns {string[]} An array of database names.
+     */
+    async getCollections(){
+        return await this._request("getCollections", {});
+    }
+
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     *
+     * @function
+     * @param {string} collection - The collection to check.
+     */
+    async checkCollection(collection){
+        return await this._request("checkCollection", { collection });
+    }
+
+    /**
+     * Check if a collection exists.
+     *
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @returns {boolean} True if the collection exists, false otherwise.
+     */
+    async issetCollection(collection){
+        return await this._request("issetCollection", { collection });
+    }
+
+    /**
+     * Add data to a database.
+     *
+     * @async
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @param {Object} data - The data to add.
+     * @param {boolean} id_gen - Whether to generate an ID for the entry. Default is true.
+     * @returns {Promise<Object>} A Promise that resolves with the added data.
+     */
+    async add(collection, data, id_gen=true){
+        return await this._request("add", { collection, data, id_gen });
+    }
+
+    /**
+     * Find data in a database.
+     *
+     * @async
+     * @function
+     * @param {string} collection - Name of the database collection.
+     * @param {function|Object} search - The query. It can be an object or a function.
+     * @param {Object} context - The context object (for functions).
+     * @param {Object} options - The options for the search.
+     * @param {number} options.max - The maximum number of entries to return. Default is -1, meaning no limit.
+     * @param {boolean} options.reverse - Whether to reverse the order of returned entries. Default is false.
+     * @param {Object} findOpts - Update result object with findOpts options.
+     * @returns {Promise<Array<Object>>} A Promise that resolves with the matching data.
+     */
+    async find(collection, search, context={}, options={}, findOpts={}){
+        if(typeof search === "function") search = search.toString();
+        return await this._request("find", { collection, search, options, context, findOpts });
+    }
+
+    /**
+     * Find one data entry in a database.
+     *
+     * @async
+     * @function
+     * @param {string} collection - Name of the database collection.
+     * @param {function|Object} search - The query. It can be an object or a function.
+     * @param {Object} context - The context object (for functions).
+     * @param {Object} findOpts - Update result object with findOpts options.
+     * @returns {Promise<Object|null>} A Promise that resolves with the first matching data entry.
+     */
+    async findOne(collection, search, context={}, findOpts={}){
+        if(typeof search === "function") search = search.toString();
+        return await this._request("findOne", { collection, search, context, findOpts });
+    }
+
+    /**
+     * Update data in a database.
+     *
+     * @async
+     * @function
+     * @param {string} collection - Name of the database collection.
+     * @param {function|Object} search - The query. It can be an object or a function.
+     * @param {function|Object} arg - Update arguments.
+     * @param {Object} context - The context object (for functions).
+     * @returns {Promise<boolean>} A Promise that resolves when the data is updated.
+     */
+    async update(collection, search, arg, context={}){
+        if(typeof search === "function") search = search.toString();
+        if(typeof arg === "function") arg = arg.toString();
+        return await this._request("update", { collection, search, arg, context });
+    }
+
+    /**
+     * Update one data entry in a database.
+     *
+     * @async
+     * @function
+     * @param {string} collection - Name of the database collection.
+     * @param {function|Object} search - The query. It can be an object or a function.
+     * @param {function|Object} arg - The query.
+     * @param {Object} context - The context object (for functions).
+     * @returns {Promise<boolean>} A Promise that resolves when the data entry is updated.
+     */
+    async updateOne(collection, search, arg, context={}){
+        if(typeof search === "function") search = search.toString();
+        if(typeof arg === "function") arg = arg.toString();
+        return await this._request("updateOne", { collection, search, arg, context });
+    }
+
+    /**
+     * Remove data from a database.
+     *
+     * @async
+     * @function
+     * @param {string} collection - Name of the database collection.
+     * @param {function|Object} search - The query. It can be an object or a function.
+     * @param {Object} context - The context object (for functions).
+     * @returns {Promise<boolean>} A Promise that resolves when the data is removed.
+     */
+    async remove(collection, search, context={}){
+        if(typeof search === "function") search = search.toString();
+        return await this._request("remove", { collection, search, context });
+    }
+
+    /**
+     * Remove one data entry from a database.
+     *
+     * @async
+     * @function
+     * @param {string} collection - Name of the database collection.
+     * @param {function|Object} search - The query. It can be an object or a function.
+     * @param {Object} context - The context object (for functions).
+     * @returns {Promise<boolean>} A Promise that resolves when the data entry is removed.
+     */
+    async removeOne(collection, search, context={}){
+        if(typeof search === "function") search = search.toString();
+        return await this._request("removeOne", { collection, search, context });
+    }
+
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     *
+     * @param {string} collection - Name of the database collection.
+     * @param {function|Object} search - The query. It can be an object or a function.
+     * @param {function|Object} arg - The search criteria for the update.
+     * @param {function|Object} add_arg - The arguments to be added to the new entry.
+     * @param {Object} context - The context object (for functions).
+     * @param {boolean} id_gen - Whether to generate an ID for the entry. Default is true.
+     * @return {Promise<boolean>} A Promise that resolves to `true` if the entry was updated, or `false` if it was added.
+     */
+    async updateOneOrAdd(collection, search, arg, add_arg={}, context={}, id_gen=true){
+        if(typeof search === "function") search = search.toString();
+        if(typeof arg === "function") arg = arg.toString();
+        if(typeof add_arg === "function") add_arg = add_arg.toString();
+        return await this._request("updateOneOrAdd", { collection, search, arg, add_arg, id_gen, context });
+    }
+
+    /**
+     * Removes a database collection from the file system.
+     *
+     * @param {string} collection - The name of the collection to remove.
+     * @return {void}
+     */
+    removeDb(name){
+        return this._request("removeDb", { name });
+    }
+}
+
+export default DataBaseRemote;

package/remote/client/graph.js

@@ -0,0 +1,139 @@
+import got from "got";
+
+/**
+ * A class representing a graph database.
+ * Uses a remote database.
+ * @class
+ */
+class GraphRemote{
+    /**
+     * Create a new database instance.
+     * @constructor
+     * @param {object} remote - The remote database object.
+     * @param {string} remote.name - The name of the database.
+     * @param {string} remote.folder - The folder path where the database files are stored.
+     * @param {string} remote.auth - The authentication token.
+     * @param {string} remote.url - The URL of the remote database.
+     */
+    constructor(remote){
+        this.remote = remote;
+    }
+
+    /**
+     * Make a request to the remote database.
+     * @async
+     * @function
+     * @param {string} type - The type of the request.
+     * @param {object} data - The data to send with the request.
+     * @returns {Promise<*>} A Promise that resolves with the result of the request.
+     * @throws {Error} If the request failed.
+     */
+    async _request(type, data){
+        data.db = this.remote.name;
+        const res = await got.post(this.remote.url + "/db/graph/" + type, {
+            json: data,
+            headers: {
+                "Authorization": this.remote.auth
+            },
+            responseType: "json"
+        });
+
+        if(res.body.err) throw new Error(res.body.msg);
+        return res.body.result;
+    }
+
+    /**
+     * Adds an edge between two nodes.
+     * @async
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @param {string} nodeA - The first node.
+     * @param {string} nodeB - The second node.
+     * @returns {Promise<Object>} A promise that resolves with the added edge.
+     */
+    async add(collection, nodeA, nodeB){
+        return await this._request("add", { collection, nodeA, nodeB });
+    }
+
+    /**
+     * Removes an edge between two nodes.
+     * @async
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @param {string} nodeA - The first node.
+     * @param {string} nodeB - The second node.
+     * @returns {Promise<boolean>} A promise that resolves when the edge is removed.
+     */
+    async remove(collection, nodeA, nodeB){
+        return await this._request("remove", { collection, nodeA, nodeB });
+    }
+
+    /**
+     * Finds all edges with either node equal to `node`.
+     * @async
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @param {string} node - The node to search for.
+     * @returns {Promise<Object[]>} A promise that resolves with the found edges.
+     */
+    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
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @param {string} nodeA - The first node.
+     * @param {string} nodeB - The second node.
+     * @returns {Promise<Object|null>} A promise that resolves with the found edge or null if not found.
+     */
+    async findOne(collection, nodeA, nodeB){
+        return await this._request("findOne", { collection, nodeA, nodeB });
+    }
+
+    /**
+     * Get all edges in the collection.
+     * @async
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @returns {Promise<Object[]>} A promise that resolves with the found edges.
+     */
+    async getAll(collection){
+        return await this._request("getAll", { collection });
+    }
+
+    /**
+     * Get the names of all available databases.
+     *
+     * @function
+     * @returns {string[]} An array of database names.
+     */
+    async getCollections(){
+        return await this._request("getCollections", {});
+    }
+
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     *
+     * @function
+     * @param {string} collection - The collection to check.
+     */
+    async checkCollection(collection){
+        return await this._request("checkCollection", { collection });
+    }
+
+    /**
+     * Check if a collection exists.
+     *
+     * @function
+     * @param {string} collection - The name of the collection.
+     * @returns {boolean} True if the collection exists, false otherwise.
+     */
+    async issetCollection(collection){
+        return await this._request("issetCollection", { collection });
+    }
+}
+
+export default GraphRemote;

package/remote/client/index.js

@@ -0,0 +1,10 @@
+import databaseC from "./database.js";
+import graphC from "./graph.js";
+
+export async function DataBase(remote){
+    return new databaseC(remote);
+}
+
+export async function Graph(remote){
+    return new graphC(remote);
+}