@wxn0brp/db 0.0.5 → 0.0.7

package/remote/client/graph.js

@@ -1,148 +0,0 @@
-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.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 });
-    }
-
-    /**
-     * Remove the specified collection.
-     *
-     * @function
-     * @param {string} collection - The name of the collection.
-     */
-    removeCollection(collection){
-        return this._request("removeCollection", { collection });
-    }
-}
-
-export default GraphRemote;

package/remote/server/auth.js

@@ -1,100 +0,0 @@
-import jwt from "jwt-simple";
-import NodeCache from "node-cache";
-import getSecret from "./secret.js";
-import crypto from "crypto";
-
-const TOKEN_CACHE_TTL = process.env.TOKEN_CACHE_TTL || 900; // 15 minutes
-const cache = new NodeCache({ stdTTL: TOKEN_CACHE_TTL, checkperiod: TOKEN_CACHE_TTL });
-const secret = getSecret();
-
-export async function authMiddleware(req, res, next){
-    const token = req.headers["authorization"];
-    if(!token){
-        return res.status(401).json({ err: true, msg: "Access denied. No token provided." });
-    }
-
-    if(cache.has(token)){
-        req.user = cache.get(token);
-        return next();
-    }
-
-    try{
-        const user = jwt.decode(token, secret);
-        if(!user || !user._id){
-            return res.status(401).json({ err: true, msg: "Invalid token." });
-        }
-
-        const tokenD = await global.db.findOne("token", { token });
-        if(!tokenD){
-            return res.status(401).json({ err: true, msg: "Invalid token." });
-        }
-
-        const userD = await global.db.findOne("user", { _id: user._id });
-        if(!userD){
-            return res.status(401).json({ err: true, msg: "Invalid token." });
-        }
-        
-        req.user = user;
-        cache.set(token, user);
-        next();
-    }catch(err){
-        res.status(400).json({ err: true, msg: "An error occurred during authentication." });
-    }
-}
-
-export async function loginFunction(login, password){
-    const { err, user } = await checkUserAccess(login, password);
-    if(err){
-        return { err: true, msg: "Invalid login or password." };
-    }
-
-    const token = await generateToken({ _id: user._id });
-    cache.set(token, user);
-    return { err: false, token };
-}
-
-export async function generateToken(payload){
-    const token = jwt.encode(payload, secret);
-    await global.db.add("token", { token }, false);
-    return token;
-}
-
-export async function removeToken(token){
-    return await global.db.removeOne("token", { token });
-}
-
-export async function addUserAccess(login, password){
-    if(!/^[a-zA-Z0-9]+$/.test(login)) return { err: true, msg: "Login can only contain letters and numbers." };
-    if(login.length < 3 || login.length > 10) return { err: true, msg: "Login must be between 3 and 10 characters." };
-    if(password.length < 8 || password.length > 300) return { err: true, msg: "Password must be between 8 and 300 characters." };
-
-    const userExists = await global.db.findOne("user", { login });
-    if(userExists) return { err: true, msg: "Login already exists." };
-
-    password = generateHash(password);
-
-    const user = await global.db.add("user", {
-        login,
-        password
-    });
-    return { err: false, user };
-}
-
-export async function checkUserAccess(login, password){
-    const user = await global.db.findOne("user", { login });
-    if(!user) return { err: true, msg: "Invalid login or password." };
-
-    const hash = generateHash(password);
-    if(hash !== user.password) return { err: true, msg: "Invalid login or password." };
-
-    delete user.password;
-    return { err: false, user };
-}
-
-export async function removeUser(idOrLogin){
-    return await global.db.removeOne("user", { $or: [{ _id: idOrLogin }, { login: idOrLogin }] });
-}
-
-function generateHash(password){
-    return crypto.createHash("sha256").update(password).digest("hex");
-}

package/remote/server/db.js

@@ -1,197 +0,0 @@
-import { Router } from "express";
-import parseParam from "./function.js";
-import { isPathSafe } from "./pathUtils.js";
-const router = Router();
-
-router.use((req, res, next) => {
-    if(req.dbType == "database") return next();
-    return res.status(400).json({ err: true, msg: "Invalid data center type." });
-});
-
-router.post("/getCollections", async (req, res) => {
-    try{
-        const db = req.dataCenter;
-        const result = await db.getCollections();
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/checkCollection", async (req, res) => {
-    const { collection } = req.body;
-    if(!collection) return res.status(400).json({ err: true, msg: "collection is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const db = req.dataCenter;
-        await db.checkCollection(collection);
-        res.json({ err: false, result: true });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/issetCollection", async (req, res) => {
-    const { collection } = req.body;
-    if(!collection) return res.status(400).json({ err: true, msg: "collection is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const db = req.dataCenter;
-        const result = await db.issetCollection(collection);
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/add", async (req, res) => {
-    const { collection, data } = req.body;
-    if(!collection || !data) return res.status(400).json({ err: true, msg: "collection & data is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const db = req.dataCenter;
-        const result = await db.add(collection, data, req.body.id_gen || true);
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/find", async (req, res) => {
-    const { collection, search, context, options, findOpts } = req.body;
-    if(!collection || !search) return res.status(400).json({ err: true, msg: "collection & search is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const parsedSearch = parseParam(search);
-        const db = req.dataCenter;
-        const result = await db.find(collection, parsedSearch, context || {}, options || {}, findOpts || {});
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/findOne", async (req, res) => {
-    const { collection, search, context, findOpts } = req.body;
-    if(!collection || !search) return res.status(400).json({ err: true, msg: "collection & search is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const parsedSearch = parseParam(search);
-        const db = req.dataCenter;
-        const result = await db.findOne(collection, parsedSearch, context || {}, findOpts || {});
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/update", async (req, res) => {
-    const { collection, search, arg, context } = req.body;
-    if(!collection || !search || !arg) return res.status(400).json({ err: true, msg: "collection & search & arg is required" });
-
-    try{
-        const parsedSearch = parseParam(search);
-        const parsedArg = parseParam(arg);
-        const db = req.dataCenter;
-        const result = await db.update(collection, parsedSearch, parsedArg, context || {});
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/updateOne", async (req, res) => {
-    const { collection, search, arg, context } = req.body;
-    if(!collection || !search || !arg) return res.status(400).json({ err: true, msg: "collection & search & arg is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const parsedSearch = parseParam(search);
-        const parsedArg = parseParam(arg);
-        const db = req.dataCenter;
-        const result = await db.updateOne(collection, parsedSearch, parsedArg, context || {});
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/remove", async (req, res) => {
-    const { collection, search, context } = req.body;
-    if(!collection || !search) return res.status(400).json({ err: true, msg: "collection & search is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const parsedSearch = parseParam(search);
-        const db = req.dataCenter;
-        const result = await db.remove(collection, parsedSearch, context || {});
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/removeOne", async (req, res) => {
-    const { collection, search, context } = req.body;
-    if(!collection || !search) return res.status(400).json({ err: true, msg: "collection & search is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const parsedSearch = parseParam(search);
-        const db = req.dataCenter;
-        const result = await db.removeOne(collection, parsedSearch, context || {});
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/updateOneOrAdd", async (req, res) => {
-    const { collection, search, arg, add_arg, context, id_gen } = req.body;
-    if(!collection || !search || !arg) return res.status(400).json({ err: true, msg: "collection & search & arg is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const parsedSearch = parseParam(search);
-        const parsedArg = parseParam(arg);
-        const parsedAddArg = parseParam(add_arg);
-        const db = req.dataCenter;
-        const result = await db.updateOneOrAdd(collection, parsedSearch, parsedArg, parsedAddArg || {}, context || {}, id_gen || true);
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/removeCollection", async (req, res) => {
-    const { name } = req.body;
-    if(!name) return res.status(400).json({ err: true, msg: "name is required" });
-    if(!isPathSafe(baseDir, name)) return res.status(400).json({ err: true, msg: "invalid name" });
-
-    try{
-        const db = req.dataCenter;
-        const result = await db.removeCollection(name);
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-export default router;

package/remote/server/function.js

@@ -1,43 +0,0 @@
-import { createContext, runInContext } from "node:vm";
-
-const sandbox = {
-    console: {
-      log: console.log,
-    },
-    Math,
-    Date,
-    setTimeout: undefined,
-    setInterval: undefined,
-    setImmediate: undefined,
-    clearTimeout: undefined,
-    clearInterval: undefined,
-    clearImmediate: undefined,
-    require: undefined,
-    module: undefined,
-    exports: undefined,
-    process: undefined,
-    Buffer: undefined,
-};
-
-const context = createContext(sandbox);
-
-function changeStringToFunction(func){
-    try{
-        const userFunction = runInContext(`(${func})`, context);
-        return userFunction;
-    }catch(e){
-        throw new Error("Invalid function");
-    }
-}
-
-function parseParam(param){
-    if(typeof param === "string"){
-        const userFunction = changeStringToFunction(param);
-        if(typeof userFunction !== "function") throw new Error("Invalid function");
-        return userFunction;
-    }else{
-        return param;
-    }
-}
-
-export default parseParam;

package/remote/server/graph.js

@@ -1,136 +0,0 @@
-import { Router } from "express";
-import { isPathSafe } from "./pathUtils.js";
-const router = Router();
-
-router.use((req, res, next) => {
-    if(req.dbType == "graph") return next();
-    return res.status(400).json({ err: true, msg: "Invalid data center type." });
-});
-
-router.post("/add", async (req, res) => {
-    const { collection, a, b } = req.body;
-    if(!collection || !a || !b) return res.status(400).json({ err: true, msg: "collection & a & b is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    const db = req.dataCenter;
-    try{
-        const result = await db.add(collection, a, b);
-        res.json({ err: false, result });
-    }catch(err){
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/find", async (req, res) => {
-    const { collection, node } = req.body;
-    if(!collection || !node) return res.status(400).json({ err: true, msg: "collection & node is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    const db = req.dataCenter;
-    try{
-        const result = await db.find(collection, node);
-        res.json({ err: false, result });
-    }catch(err){
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/findOne", async (req, res) => {
-    const { collection, nodeA, nodeB } = req.body;
-    if(!collection || !nodeA || !nodeB) return res.status(400).json({ err: true, msg: "collection & nodeA & nodeB is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    const db = req.dataCenter;
-    try{
-        const result = await db.findOne(collection, nodeA, nodeB);
-        res.json({ err: false, result });
-    }catch(err){
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/getAll", async (req, res) => {
-    const { collection } = req.body;
-    if(!collection) return res.status(400).json({ err: true, msg: "collection is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    const db = req.dataCenter;
-    try{
-        const result = await db.getAll(collection);
-        res.json({ err: false, result });
-    }catch(err){
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/remove", async (req, res) => {
-    const { collection, nodeA, nodeB } = req.body;
-    if(!collection || !nodeA || !nodeB) return res.status(400).json({ err: true, msg: "collection & nodeA & nodeB is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    const db = req.dataCenter;
-    try{
-        const result = await db.remove(collection, nodeA, nodeB);
-        res.json({ err: false, result });
-    }catch(err){
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/getCollections", async (req, res) => {
-    try{
-        const db = req.dataCenter;
-        const result = await db.getCollections();
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/checkCollection", async (req, res) => {
-    const { collection } = req.body;
-    if(!collection) return res.status(400).json({ err: true, msg: "collection is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const db = req.dataCenter;
-        await db.checkCollection(collection);
-        res.json({ err: false, result: true });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/issetCollection", async (req, res) => {
-    const { collection } = req.body;
-    if(!collection) return res.status(400).json({ err: true, msg: "collection is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const db = req.dataCenter;
-        const result = await db.issetCollection(collection);
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-router.post("/removeCollection", async (req, res) => {
-    const { collection } = req.body;
-    if(!collection) return res.status(400).json({ err: true, msg: "collection is required" });
-    if(!isPathSafe(baseDir, collection)) return res.status(400).json({ err: true, msg: "invalid collection" });
-
-    try{
-        const db = req.dataCenter;
-        const result = await db.removeCollection(collection);
-        res.json({ err: false, result });
-    }catch(err){
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-
-export default router;