@wxn0brp/db 0.0.6 → 0.0.8

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

@@ -1,71 +0,0 @@
-import CollectionManager from "../../CollectionManager.js";
-import { Remote, RequestData } from "./remote.js";
-import { Arg, ArgOrFunc } from "../../types/arg";
-import { DbFindOpts, FindOpts } from "../../types/options.js";
-import { Context } from "../../types/types";
-/**
- * Represents a database management class for performing CRUD operations.
- * Uses a remote database.
- * @class
- */
-declare class DataBaseRemote {
-    remote: Remote;
-    constructor(remote: Remote);
-    /**
-     * Make a request to the remote database.
-     */
-    _request(type: string, data: RequestData): Promise<any>;
-    /**
-     * Create a new instance of a CollectionManager class.
-     */
-    c(collection: string): CollectionManager;
-    /**
-     * Get the names of all available databases.
-     */
-    getCollections(): Promise<any>;
-    /**
-     * Check and create the specified collection if it doesn't exist.
-     */
-    checkCollection(collection: string): Promise<any>;
-    /**
-     * Check if a collection exists.
-     */
-    issetCollection(collection: any): Promise<any>;
-    /**
-     * Add data to a database.
-     */
-    add(collection: any, data: any, id_gen?: boolean): Promise<any>;
-    /**
-     * Find data in a database.
-     */
-    find(collection: string, search: ArgOrFunc, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<any>;
-    /**
-     * Find one data entry in a database.
-     */
-    findOne(collection: string, search: ArgOrFunc, context?: Context, findOpts?: FindOpts): Promise<any>;
-    /**
-     * Update data in a database.
-     */
-    update(collection: string, search: ArgOrFunc, arg: ArgOrFunc, context?: Context): Promise<any>;
-    /**
-     * Update one data entry in a database.
-     */
-    updateOne(collection: string, search: ArgOrFunc, arg: ArgOrFunc, context?: Context): Promise<any>;
-    /**
-     * Remove data from a database.
-     */
-    remove(collection: string, search: ArgOrFunc, context?: Context): Promise<any>;
-    /**
-     * Remove one data entry from a database.
-     */
-    removeOne(collection: string, search: ArgOrFunc, context?: Context): Promise<any>;
-    /**
-     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
-     */
-    updateOneOrAdd(collection: string, search: ArgOrFunc, arg: ArgOrFunc, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<any>;
-    /**
-     * Removes a database collection from the file system.
-     */
-    removeCollection(name: string): Promise<any>;
-}
-export default DataBaseRemote;

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

@@ -1,31 +0,0 @@
-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/dist/esm/remote/server/auth.js

@@ -1,87 +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 = 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) {
-    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/dist/esm/remote/server/db.d.ts

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

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

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

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

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

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

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

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

@@ -1,143 +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(global.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(global.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(global.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(global.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(global.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(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("/removeCollection", 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.removeCollection(collection);
-        res.json({ err: false, result });
-    }
-    catch (err) {
-        console.error(err);
-        res.status(500).json({ err: true, msg: err.message });
-    }
-});
-export default router;