@wxn0brp/db 0.0.5 → 0.0.6

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/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/index.js

@@ -1,63 +0,0 @@
-import express from "express";
-import bodyParser from "body-parser";
-import { authMiddleware, loginFunction } from "./auth.js";
-import dbRouter from "./db.js";
-import graphRouter from "./graph.js";
-import "./initDataBases.js";
-import cors from "cors";
-import { configDotenv } from "dotenv";
-
-configDotenv({ path: ".db.env" });
-const port = process.env.PORT || 14785;
-global.baseDir = process.env.baseDir || process.cwd();
-
-console.log("baseDir", baseDir);
-global.app = express();
-app.get("/", (req, res) => res.send("Server is running."));
-app.use(bodyParser.urlencoded({ extended: true }));
-app.use(bodyParser.json());
-app.use(cors({
-    origin: "*",
-}));
-
-const apiDbRouter = express.Router();
-apiDbRouter.use(authMiddleware);
-apiDbRouter.use(checkRequest);
-
-function checkRequest(req, res, next){
-    const dbName = req.body.db;
-
-    if(!dataCenter[dbName]){
-        return res.status(400).json({ err: true, msg: "Invalid data center." });
-    }
-
-    req.dataCenter = dataCenter[dbName].db;
-    req.dbType = dataCenter[dbName].type;
-
-    next();
-}
-
-apiDbRouter.use("/database", dbRouter);
-apiDbRouter.use("/graph", graphRouter);
-
-app.use("/db/", apiDbRouter);
-app.post("/login", async (req, res) => {
-    const { login, password } = req.body;
-    if(!login || !password) return res.json({ err: true, msg: "Login and password are required" });
-    
-    const { err, token } = await loginFunction(login, password);
-    if(err) return res.json({ err: true, msg: "Invalid login or password." });
-    res.json({ err: false, token });
-});
-
-app.post("/getDbList", authMiddleware, async (req, res) => {
-    const dbsKeys = Object.keys(dataCenter);
-    const dbs = dbsKeys.map(dbName => ({ name: dbName, type: dataCenter[dbName].type }));
-    res.json({ err: false, result: dbs });
-});
-
-if(process.env.gui){
-    app.use("/gui", express.static(import.meta.dirname + "/gui"));
-}
-
-app.listen(port, () => console.log(`Server started on port ${port}`));

package/remote/server/initDataBases.js

@@ -1,20 +0,0 @@
-import DataBase from "../../database.js";
-import Graph from "../../graph.js";
-global.db = new DataBase("./serverDB");
-global.dataCenter = {};
-
-const databases = await global.db.find("dbs", {});
-
-for(const db of databases){
-    if(db.type === "database"){
-        global.dataCenter[db.name] = {
-            type: "database",
-            db: new DataBase(db.folder, db.opts || {})
-        }
-    }else if(db.type === "graph"){
-        global.dataCenter[db.name] = {
-            type: "graph",
-            db: new Graph(db.folder, db.opts || {})
-        }
-    }
-}

package/test/hasFieldsAdvanced.test.js

@@ -1,70 +0,0 @@
-import test from 'ava';
-import hasFieldsAdvanced from '../utils/hasFieldsAdvanced.js';
-
-test('throws error if fields is not an object', t => {
-    const error = t.throws(() => {
-        hasFieldsAdvanced({}, null);
-    }, { instanceOf: Error });
-    t.is(error.message, 'Fields must be an object');
-});
-
-test('returns true for empty fields', t => {
-    const result = hasFieldsAdvanced({ a: 1, b: 2 }, {});
-    t.true(result);
-});
-
-test('validates fields with $and operator', t => {
-    const obj = { a: 5, b: 10 };
-    const fields = { $and: [{ $gt: { a: 3 } }, { $lt: { b: 15 } }] };
-    const result = hasFieldsAdvanced(obj, fields);
-    t.true(result);
-});
-
-test('validates fields with $or operator', t => {
-    const obj = { a: 2, b: 10 };
-    const fields = { $or: [ { a: 5 }, { b: 15 }, { a: 2 }] };
-    const result = hasFieldsAdvanced(obj, fields);
-    t.true(result);
-});
-
-test('validates fields with $exists operator', t => {
-    const obj = { a: 5, b: undefined };
-    const fields = { $exists: { a: true, c: false } };
-    const result = hasFieldsAdvanced(obj, fields);
-    t.true(result);
-});
-
-test('validates comparison operators', t => {
-    const obj = { a: 10, b: 20 };
-    const fields = { $gt: { a: 5 }, $lt: { b: 30 } };
-    const result = hasFieldsAdvanced(obj, fields);
-    t.true(result);
-});
-
-test('returns false for invalid fields', t => {
-    const obj = { a: 1, b: 2 };
-    const fields = { $gt: { a: 2 } };
-    const result = hasFieldsAdvanced(obj, fields);
-    t.false(result);
-});
-
-test('validates fields with $type operator', t => {
-    const obj = { a: 5, b: 'test' };
-    const fields = { $type: { a: 'number', b: 'string' } };
-    const result = hasFieldsAdvanced(obj, fields);
-    t.true(result);
-});
-
-test('validates regex conditions', t => {
-    const obj = { name: 'Alice' };
-    const fields = { $regex: { name: /^A/ } };
-    const result = hasFieldsAdvanced(obj, fields);
-    t.true(result);
-});
-
-test('validates array conditions', t => {
-    const obj = { tags: ['js', 'ava', 'test'] };
-    const fields = { $arrinc: { tags: ['ava'] } };
-    const result = hasFieldsAdvanced(obj, fields);
-    t.true(result);
-});