@wxn0brp/db 0.0.1

package/remote/server/auth.js

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,197 @@
+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("/removeDb", 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.removeDb(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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,121 @@
+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 });
+    }
+});
+
+export default router;

package/remote/server/gui/css/main.css

@@ -0,0 +1,130 @@
+#app{
+    display: flex;
+    height: 100vh;
+}
+
+nav{
+    width: 200px;
+    max-width: 200px;
+    height: 100vh;
+    background-color: var(--panel);
+}
+
+#database-server-list > li{
+    margin-top: 0.5rem;
+    border-bottom: 1px solid var(--accent);
+    padding-block: 0.5rem;
+}
+
+.database-nav{
+    list-style: none;
+    text-align: left;
+    padding-left: 0.7rem;
+}
+
+.database-nav-meta{
+    list-style: square;
+    text-align: left;
+    padding-left: 1.3rem;
+}
+
+main{
+    flex-grow: 1;
+    height: 100vh;
+    overflow-y: scroll;
+}
+
+#query-div{
+    text-align: left;
+    padding-left: 1rem;
+}
+
+#query-div h2{
+    margin-bottom: 0.7rem;
+}
+
+#query-div label{
+    margin-bottom: 5px;
+    display: block;
+}
+
+input, select, button{
+    background-color: var(--back);
+    border: 1px solid var(--accent);
+    border-radius: 5px;
+    padding: 5px;
+    color: var(--txt);
+}
+
+
+#data-output h1{
+    text-align: center;
+    color: var(--txt);
+}
+
+#data-output div{
+    padding: 10px;
+    text-align: left;
+    border-top: 1px solid var(--border);
+}
+
+#data-output ul{
+    list-style-type: none;
+    padding: 0;
+}
+
+#data-output li{
+    margin: 5px 0;
+}
+
+#data-output pre{
+    white-space: pre-wrap;
+    word-wrap: break-word;
+}
+
+.selectMeta{
+    cursor: pointer;
+}
+
+.selectMeta:hover{
+    text-decoration: underline;
+}
+
+#nav__toggle{
+    display: none;
+}
+
+#popUpContainer > div{
+    display: none;
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    z-index: 10;
+    background-color: var(--back);
+    color: var(--txt);
+    border: 2px solid var(--accent);
+    border-radius: 1rem;
+    padding: 1rem;
+    width: 600px;
+    max-width: 90vw;
+    max-height: 90vh;
+}
+
+@media only screen and (max-width: 600px){
+    nav{
+        position: absolute;
+        top: 0;
+        transition: 0.5s;
+    }
+
+    #nav__toggle{
+        display: block;
+        position: absolute;
+        top: 0;
+        right: 0;
+        margin: 1rem;
+        cursor: pointer;
+        z-index: 99;
+    }
+}

package/remote/server/gui/css/scrool.css

@@ -0,0 +1,81 @@
+:root{
+    --scrollbar-width: 5px;
+}
+
+/* WebKit (Chromium, Chrome, Opera, Safari) */
+::-webkit-scrollbar{
+    width: var(--scrollbar-width);
+}
+
+::-webkit-scrollbar-track{
+    background: var(--back);
+}
+
+::-webkit-scrollbar-thumb{
+    background: var(--accent);
+}
+
+::-webkit-scrollbar-thumb:hover{
+    background: var(--border);
+}
+
+/* Gecko (Firefox) */
+*{
+    scrollbar-width: thin;
+    scrollbar-color: var(--accent) var(--back);
+}
+
+*::-webkit-scrollbar{
+    width: var(--scrollbar-width);
+}
+
+*::-webkit-scrollbar-track{
+    background: var(--back);
+}
+
+*::-webkit-scrollbar-thumb{
+    background-color: var(--accent);
+}
+
+*::-webkit-scrollbar-thumb:hover{
+    background-color: var(--border);
+}
+
+/* Electron */
+html::-webkit-scrollbar{
+    width: var(--scrollbar-width);
+}
+
+html::-webkit-scrollbar-track{
+    background: var(--back);
+}
+
+html::-webkit-scrollbar-thumb{
+    background: var(--accent);
+}
+
+html::-webkit-scrollbar-thumb:hover{
+    background: var(--border);
+}
+
+/* WebView in React Native */
+body{
+    scrollbar-width: var(--scrollbar-width);
+    scrollbar-color: var(--accent) var(--back);
+}
+
+body::-webkit-scrollbar{
+    width: var(--scrollbar-width);
+}
+
+body::-webkit-scrollbar-track{
+    background: var(--back);
+}
+
+body::-webkit-scrollbar-thumb{
+    background-color: var(--accent);
+}
+
+body::-webkit-scrollbar-thumb:hover{
+    background-color: var(--border);
+}