@wxn0brp/db 0.0.5 → 0.0.6

package/dist/esm/remote/client/graph.js

@@ -0,0 +1,88 @@
+import got from "got";
+/**
+ * A class representing a graph database.
+ * Uses a remote database.
+ * @class
+ */
+class GraphRemote {
+    remote;
+    /**
+     * Create a new database instance.
+     */
+    constructor(remote) {
+        this.remote = remote;
+    }
+    /**
+     * Make a request to the remote database.
+     */
+    async _request(type, data) {
+        data.db = this.remote.name;
+        const res = await got.post(this.remote.url + "/db/graph/" + type, {
+            // @ts-ignore
+            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;
+    }
+    /**
+     * Adds an edge between two nodes.
+     */
+    async add(collection, nodeA, nodeB) {
+        return await this._request("add", { collection, nodeA, nodeB });
+    }
+    /**
+     * Removes an edge between two nodes.
+     */
+    async remove(collection, nodeA, nodeB) {
+        return await this._request("remove", { collection, nodeA, nodeB });
+    }
+    /**
+     * Finds all edges with either node equal to `node`.
+     */
+    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 findOne(collection, nodeA, nodeB) {
+        return await this._request("findOne", { collection, nodeA, nodeB });
+    }
+    /**
+     * Get all edges in the collection.
+     */
+    async getAll(collection) {
+        return await this._request("getAll", { 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 });
+    }
+    /**
+     * Remove the specified collection.
+     */
+    removeCollection(collection) {
+        return this._request("removeCollection", { collection });
+    }
+}
+export default GraphRemote;

package/dist/esm/remote/client/remote.d.ts

@@ -0,0 +1,16 @@
+export interface Remote {
+    name: string;
+    url: string;
+    auth: string;
+}
+export interface RequestData {
+    collection?: string;
+    db?: string;
+    keys?: string[];
+    [key: string]: any;
+}
+export interface findOptsRemote {
+    select?: string[];
+    exclude?: string[];
+    transform?: string;
+}

package/dist/esm/remote/client/remote.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/remote/server/auth.d.ts

@@ -0,0 +1,31 @@
+export declare function authMiddleware(req: any, res: any, next: any): Promise<any>;
+export declare function loginFunction(login: any, password: any): Promise<{
+    err: boolean;
+    msg: string;
+    token?: undefined;
+} | {
+    err: boolean;
+    token: string;
+    msg?: undefined;
+}>;
+export declare function generateToken(payload: any): Promise<string>;
+export declare function removeToken(token: any): Promise<any>;
+export declare function addUserAccess(login: any, password: any): Promise<{
+    err: boolean;
+    msg: string;
+    user?: undefined;
+} | {
+    err: boolean;
+    user: any;
+    msg?: undefined;
+}>;
+export declare function checkUserAccess(login: any, password: any): Promise<{
+    err: boolean;
+    msg: string;
+    user?: undefined;
+} | {
+    err: boolean;
+    user: any;
+    msg?: undefined;
+}>;
+export declare function removeUser(idOrLogin: any): Promise<any>;

package/{remote → dist/esm/remote}/server/auth.js

@@ -2,99 +2,86 @@ 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 TOKEN_CACHE_TTL = parseInt(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){
+export async function authMiddleware(req, res, next) {
     const token = req.headers["authorization"];
-    if(!token){
+    if (!token) {
         return res.status(401).json({ err: true, msg: "Access denied. No token provided." });
     }
-
-    if(cache.has(token)){
+    if (cache.has(token)) {
         req.user = cache.get(token);
         return next();
     }
-
-    try{
+    try {
         const user = jwt.decode(token, secret);
-        if(!user || !user._id){
+        if (!user || !user._id) {
             return res.status(401).json({ err: true, msg: "Invalid token." });
         }
-
         const tokenD = await global.db.findOne("token", { token });
-        if(!tokenD){
+        if (!tokenD) {
             return res.status(401).json({ err: true, msg: "Invalid token." });
         }
-
         const userD = await global.db.findOne("user", { _id: user._id });
-        if(!userD){
+        if (!userD) {
             return res.status(401).json({ err: true, msg: "Invalid token." });
         }
-        
         req.user = user;
         cache.set(token, user);
         next();
-    }catch(err){
+    }
+    catch (err) {
         res.status(400).json({ err: true, msg: "An error occurred during authentication." });
     }
 }
-
-export async function loginFunction(login, password){
+export async function loginFunction(login, password) {
     const { err, user } = await checkUserAccess(login, password);
-    if(err){
+    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){
+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){
+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." };
-
+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." };
-
+    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){
+export async function checkUserAccess(login, password) {
     const user = await global.db.findOne("user", { login });
-    if(!user) return { err: true, msg: "Invalid login or password." };
-
+    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." };
-
+    if (hash !== user.password)
+        return { err: true, msg: "Invalid login or password." };
     delete user.password;
     return { err: false, user };
 }
-
-export async function removeUser(idOrLogin){
+export async function removeUser(idOrLogin) {
     return await global.db.removeOne("user", { $or: [{ _id: idOrLogin }, { login: idOrLogin }] });
 }
-
-function generateHash(password){
+function generateHash(password) {
     return crypto.createHash("sha256").update(password).digest("hex");
-}
+}

package/dist/esm/remote/server/db.d.ts

@@ -0,0 +1,2 @@
+declare const router: any;
+export default router;

package/dist/esm/remote/server/db.js

@@ -0,0 +1,218 @@
+import { Router } from "express";
+import deserializeFunctions 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(global.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(global.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(global.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, keys } = req.body;
+    if (!collection || !search)
+        return res.status(400).json({ err: true, msg: "collection & search is required" });
+    if (!isPathSafe(global.baseDir, collection))
+        return res.status(400).json({ err: true, msg: "invalid collection" });
+    if (keys && !Array.isArray(keys))
+        return res.status(400).json({ err: true, msg: "keys must be an array" });
+    try {
+        const data = deserializeFunctions({ search, context, options, findOpts }, keys || []);
+        const db = req.dataCenter;
+        const result = await db.find(collection, data.search, data.context || {}, data.options || {}, data.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, keys } = req.body;
+    if (!collection || !search)
+        return res.status(400).json({ err: true, msg: "collection & search is required" });
+    if (!isPathSafe(global.baseDir, collection))
+        return res.status(400).json({ err: true, msg: "invalid collection" });
+    if (keys && !Array.isArray(keys))
+        return res.status(400).json({ err: true, msg: "keys must be an array" });
+    try {
+        const data = deserializeFunctions({ search, context, findOpts }, keys || []);
+        const db = req.dataCenter;
+        const result = await db.findOne(collection, data.search, data.context || {}, data.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, keys } = req.body;
+    if (!collection || !search || !arg)
+        return res.status(400).json({ err: true, msg: "collection & search & arg is required" });
+    if (!isPathSafe(global.baseDir, collection))
+        return res.status(400).json({ err: true, msg: "invalid collection" });
+    if (keys && !Array.isArray(keys))
+        return res.status(400).json({ err: true, msg: "keys must be an array" });
+    try {
+        const data = deserializeFunctions({ search, arg, context }, keys || []);
+        const db = req.dataCenter;
+        const result = await db.update(collection, data.search, data.arg, data.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, keys } = req.body;
+    if (!collection || !search || !arg)
+        return res.status(400).json({ err: true, msg: "collection & search & arg is required" });
+    if (!isPathSafe(global.baseDir, collection))
+        return res.status(400).json({ err: true, msg: "invalid collection" });
+    if (keys && !Array.isArray(keys))
+        return res.status(400).json({ err: true, msg: "keys must be an array" });
+    try {
+        const data = deserializeFunctions({ search, arg, context }, keys || []);
+        const db = req.dataCenter;
+        const result = await db.updateOne(collection, data.search, data.arg, data.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, keys } = req.body;
+    if (!collection || !search)
+        return res.status(400).json({ err: true, msg: "collection & search is required" });
+    if (!isPathSafe(global.baseDir, collection))
+        return res.status(400).json({ err: true, msg: "invalid collection" });
+    if (keys && !Array.isArray(keys))
+        return res.status(400).json({ err: true, msg: "keys must be an array" });
+    try {
+        const data = deserializeFunctions({ search, context }, keys || []);
+        const db = req.dataCenter;
+        const result = await db.remove(collection, data.search, data.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, keys } = req.body;
+    if (!collection || !search)
+        return res.status(400).json({ err: true, msg: "collection & search is required" });
+    if (!isPathSafe(global.baseDir, collection))
+        return res.status(400).json({ err: true, msg: "invalid collection" });
+    if (keys && !Array.isArray(keys))
+        return res.status(400).json({ err: true, msg: "keys must be an array" });
+    try {
+        const data = deserializeFunctions({ search, context }, keys || []);
+        const db = req.dataCenter;
+        const result = await db.removeOne(collection, data.search, data.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, keys } = req.body;
+    if (!collection || !search || !arg)
+        return res.status(400).json({ err: true, msg: "collection & search & arg is required" });
+    if (!isPathSafe(global.baseDir, collection))
+        return res.status(400).json({ err: true, msg: "invalid collection" });
+    if (keys && !Array.isArray(keys))
+        return res.status(400).json({ err: true, msg: "keys must be an array" });
+    try {
+        const data = deserializeFunctions({ search, arg, add_arg, context }, keys || []);
+        const db = req.dataCenter;
+        const result = await db.updateOneOrAdd(collection, data.search, data.arg, data.add_arg || {}, data.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(global.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/dist/esm/remote/server/function.d.ts

@@ -0,0 +1,2 @@
+declare function deserializeFunctions(data: any, keys: any): any;
+export default deserializeFunctions;

package/dist/esm/remote/server/function.js

@@ -0,0 +1,87 @@
+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 deserializeFunctions(data, keys) {
+    const setAtPath = (obj, path, value) => {
+        const segments = path.split(".").map(segment => segment.replace(/\[dot\]/g, "."));
+        let currentLevel = obj;
+        for (let i = 0; i < segments.length - 1; i++) {
+            const segment = segments[i];
+            if (Array.isArray(currentLevel)) {
+                const index = parseInt(segment, 10);
+                if (!currentLevel[index])
+                    currentLevel[index] = {};
+                currentLevel = currentLevel[index];
+            }
+            else if (!currentLevel[segment]) {
+                currentLevel[segment] = {};
+                currentLevel = currentLevel[segment];
+            }
+            else {
+                currentLevel = currentLevel[segment];
+            }
+        }
+        currentLevel[segments[segments.length - 1]] = value;
+    };
+    const getAtPath = (obj, path) => {
+        const segments = path.split(".").map(key => key.replace(/\[dot\]/g, "."));
+        return segments.reduce((acc, key) => {
+            if (Array.isArray(acc)) {
+                const index = parseInt(key, 10);
+                return acc[index];
+            }
+            return acc && acc[key];
+        }, obj);
+    };
+    keys.forEach((keyPath) => {
+        const value = getAtPath(data, keyPath);
+        if (typeof value === "string") {
+            const fn = changeStringToFunction(value);
+            setAtPath(data, keyPath, fn);
+        }
+        else if (typeof value === "object" && value !== null) {
+            if (Array.isArray(value)) {
+                value.forEach((item, index) => {
+                    if (typeof item === "string") {
+                        value[index] = changeStringToFunction(item);
+                    }
+                });
+            }
+            else {
+                Object.keys(value).forEach((key) => {
+                    if (typeof value[key] === "string") {
+                        value[key] = changeStringToFunction(value[key]);
+                    }
+                });
+            }
+        }
+    });
+    return data;
+}
+export default deserializeFunctions;

package/dist/esm/remote/server/graph.d.ts

@@ -0,0 +1,2 @@
+declare const router: any;
+export default router;