@wxn0brp/db 0.0.4 → 0.0.6

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

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const pathUtils_js_1 = require("./pathUtils.js");
+const router = (0, express_1.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 (!(0, pathUtils_js_1.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 (!(0, pathUtils_js_1.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 (!(0, pathUtils_js_1.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 (!(0, pathUtils_js_1.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 (!(0, pathUtils_js_1.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 (!(0, pathUtils_js_1.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 (!(0, pathUtils_js_1.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 (!(0, pathUtils_js_1.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 });
+    }
+});
+exports.default = router;

package/dist/cjs/remote/server/index.d.ts

@@ -0,0 +1 @@
+import "./initDataBases.js";

package/dist/cjs/remote/server/index.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const body_parser_1 = __importDefault(require("body-parser"));
+const auth_js_1 = require("./auth.js");
+const db_js_1 = __importDefault(require("./db.js"));
+const graph_js_1 = __importDefault(require("./graph.js"));
+require("./initDataBases.js");
+const cors_1 = __importDefault(require("cors"));
+const dotenv_1 = require("dotenv");
+(0, dotenv_1.configDotenv)({ path: ".db.env" });
+const port = process.env.PORT || 14785;
+global.baseDir = process.env.baseDir || process.cwd();
+console.log("baseDir", global.baseDir);
+global.app = (0, express_1.default)();
+global.app.get("/", (req, res) => res.send("Server is running."));
+global.app.use(body_parser_1.default.urlencoded({ extended: true }));
+global.app.use(body_parser_1.default.json());
+global.app.use((0, cors_1.default)({
+    origin: "*",
+}));
+const apiDbRouter = express_1.default.Router();
+apiDbRouter.use(auth_js_1.authMiddleware);
+apiDbRouter.use(checkRequest);
+function checkRequest(req, res, next) {
+    const dbName = req.body.db;
+    if (!global.dataCenter[dbName]) {
+        return res.status(400).json({ err: true, msg: "Invalid data center." });
+    }
+    req.dataCenter = global.dataCenter[dbName].db;
+    req.dbType = global.dataCenter[dbName].type;
+    next();
+}
+apiDbRouter.use("/database", db_js_1.default);
+apiDbRouter.use("/graph", graph_js_1.default);
+global.app.use("/db/", apiDbRouter);
+global.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 (0, auth_js_1.loginFunction)(login, password);
+    if (err)
+        return res.json({ err: true, msg: "Invalid login or password." });
+    res.json({ err: false, token });
+});
+global.app.post("/getDbList", auth_js_1.authMiddleware, async (req, res) => {
+    const dbsKeys = Object.keys(global.dataCenter);
+    const dbs = dbsKeys.map(dbName => ({ name: dbName, type: global.dataCenter[dbName].type }));
+    res.json({ err: false, result: dbs });
+});
+if (process.env.gui) {
+    let path;
+    if (global.__dirname) {
+        // @ts-ignore
+        path = global.__dirname;
+    }
+    else {
+        // @ts-ignore
+        path = import.meta.dirname;
+    }
+    global.app.use("/gui", express_1.default.static(path + "/gui"));
+}
+global.app.listen(port, () => console.log(`Server started on port ${port}`));

package/dist/cjs/remote/server/initDataBases.d.ts

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

package/dist/cjs/remote/server/initDataBases.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const database_js_1 = __importDefault(require("../../database.js"));
+const graph_js_1 = __importDefault(require("../../graph.js"));
+global.db = new database_js_1.default("./serverDB");
+global.dataCenter = {};
+global.db.find("dbs", {}).then(databases => {
+    for (const db of databases) {
+        if (db.type === "database") {
+            global.dataCenter[db.name] = {
+                type: "database",
+                db: new database_js_1.default(db.folder, db.opts || {})
+            };
+        }
+        else if (db.type === "graph") {
+            global.dataCenter[db.name] = {
+                type: "graph",
+                db: new graph_js_1.default(db.folder)
+            };
+        }
+    }
+});

package/dist/cjs/remote/server/pathUtils.d.ts

@@ -0,0 +1 @@
+export declare function isPathSafe(baseDir: any, userPath: any): boolean;

package/dist/cjs/remote/server/pathUtils.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathSafe = isPathSafe;
+const path_1 = __importDefault(require("path"));
+function isPathSafe(baseDir, userPath) {
+    const resolvedBase = path_1.default.resolve(baseDir);
+    const resolvedUserPath = path_1.default.resolve(baseDir, userPath);
+    return resolvedUserPath.startsWith(resolvedBase + path_1.default.sep);
+}

package/dist/cjs/remote/server/secret.d.ts

@@ -0,0 +1 @@
+export default function getSecret(): string;

package/dist/cjs/remote/server/secret.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getSecret;
+const crypto_1 = __importDefault(require("crypto"));
+const os_1 = __importDefault(require("os"));
+function generateJwtSecret() {
+    const hostname = os_1.default.hostname();
+    const cpuModels = os_1.default.cpus().map(cpu => cpu.model).join("-");
+    const platform = os_1.default.platform();
+    const arch = os_1.default.arch();
+    const macAddresses = os_1.default.networkInterfaces();
+    const macAddress = Object.values(macAddresses)
+        .flat()
+        .filter(iface => iface.mac !== "00:00:00:00:00:00" && !iface.internal)
+        .map(iface => iface.mac)
+        .join("-");
+    const secretData = `${hostname}-${cpuModels}-${platform}-${arch}-${macAddress}`;
+    return crypto_1.default.createHash("sha256").update(secretData).digest("hex");
+}
+function getSecret() {
+    return process.env.JWT || generateJwtSecret();
+}

package/dist/cjs/remote/serverMgmt/index.d.ts

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

package/dist/cjs/remote/serverMgmt/index.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+let args = process.argv.slice(2);
+if (args.length == 0) {
+    console.log("No arguments");
+    process.exit(1);
+}
+const database_js_1 = __importDefault(require("../../database.js"));
+const auth_js_1 = require("../server/auth.js");
+global.db = new database_js_1.default("./serverDB");
+switch (args.shift()) {
+    case "help":
+        console.log("commands:");
+        console.log("  add-db <type> <name> <folder> <opts>");
+        console.log("  rm-db <name>");
+        console.log("  list-dbs");
+        console.log("  add-user <login> <password>");
+        console.log("  rm-user <login>");
+        console.log("  list-users");
+        break;
+    case "add-db":
+        if (args.length < 3) {
+            console.log("usage: add-db <type> <name> <folder> <opts>");
+            console.log("*type: 'database' or 'graph'");
+            console.log("*opts: JSON object");
+            process.exit(1);
+        }
+        const type = args[0];
+        const name = args[1];
+        const folder = args[2];
+        const opts = args[3] ? JSON.parse(args[3]) : {};
+        global.db.findOne("dbs", { name }).then(dbExists => {
+            if (dbExists) {
+                console.log("Database already exists");
+                process.exit(1);
+            }
+            global.db.add("dbs", {
+                type,
+                name,
+                folder,
+                opts
+            }, false).then(() => console.log("Done"));
+        });
+        break;
+    case "rm-db":
+        if (args.length < 1) {
+            console.log("No database name");
+            process.exit(1);
+        }
+        global.db.removeOne("dbs", { name: args[0] }).then((res) => console.log(res ? "Done" : "Database not found"));
+        break;
+    case "list-dbs":
+        global.db.find("dbs", {}).then(dbs => console.log(dbs));
+        break;
+    case "add-user":
+        if (args.length < 2) {
+            console.log("usage: add-user <login> <password>");
+            process.exit(1);
+        }
+        const login = args[0];
+        const password = args[1];
+        (0, auth_js_1.addUserAccess)(login, password).then((res) => console.log(res.err ? res.msg : res.user._id));
+        break;
+    case "rm-user":
+        if (args.length < 1) {
+            console.log("No user login or id");
+            process.exit(1);
+        }
+        (0, auth_js_1.removeUser)(args[0]).then((res) => console.log(res ? "Done" : "User not found"));
+        break;
+    case "list-users":
+        global.db.find("user", {}).then(users => {
+            users = users.map(u => {
+                return {
+                    login: u.login,
+                    _id: u._id
+                };
+            });
+            console.log(users);
+        });
+        break;
+    default:
+        console.log("Invalid argument. Use help for more info");
+}

package/dist/cjs/types/Id.d.ts

@@ -0,0 +1,3 @@
+type Id = string;
+export default Id;
+export { Id };

package/dist/cjs/types/Id.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/arg.d.ts

@@ -0,0 +1,6 @@
+import Id from "./Id";
+export interface Arg {
+    _id?: Id;
+    [key: string]: any;
+}
+export type ArgOrFunc = Arg | Function;

package/dist/cjs/types/arg.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/data.d.ts

@@ -0,0 +1,4 @@
+export interface Data {
+    [key: string]: any;
+}
+export default Data;

package/dist/cjs/types/data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/options.d.ts

@@ -0,0 +1,12 @@
+export interface DbOpts {
+    maxFileSize?: number;
+}
+export interface DbFindOpts {
+    reverse?: boolean;
+    max?: number;
+}
+export interface FindOpts {
+    select?: string[];
+    exclude?: string[];
+    transform?: Function;
+}

package/dist/cjs/types/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/searchOpts.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Predefined Search Options Quick Reference
+ *
+ * This module defines the types and structures for search operators used
+ * to validate and query data objects.
+ */
+/** Logical Operators */
+export type LogicalOperators = {
+    /**
+     * Recursively applies multiple conditions, all of which must evaluate to true.
+     * Can include other operators such as $gt, $exists, or nested $and/$or conditions.
+     */
+    $and?: Array<PredefinedSearchOperators>;
+    /**
+     * Recursively applies multiple conditions, at least one of which must evaluate to true.
+     * Can include other operators such as $lt, $type, or nested $and/$or conditions.
+     */
+    $or?: Array<PredefinedSearchOperators>;
+    /**
+     * Negates a single condition.
+     * Can include any other operator as its value.
+     */
+    $not?: PredefinedSearchOperators;
+};
+/** Comparison Operators */
+export type ComparisonOperators = {
+    $gt?: Record<string, number>;
+    $lt?: Record<string, number>;
+    $gte?: Record<string, number>;
+    $lte?: Record<string, number>;
+    $in?: Record<string, any[]>;
+    $nin?: Record<string, any[]>;
+    $between?: Record<string, [number, number]>;
+};
+/** Type and Existence Operators */
+export type TypeAndExistenceOperators = {
+    $exists?: Record<string, boolean>;
+    $type?: Record<string, string>;
+};
+/** Array Operators */
+export type ArrayOperators = {
+    $arrinc?: Record<string, any[]>;
+    $arrincall?: Record<string, any[]>;
+    $size?: Record<string, number>;
+};
+/** String Operators */
+export type StringOperators = {
+    $regex?: Record<string, RegExp>;
+    $startsWith?: Record<string, string>;
+    $endsWith?: Record<string, string>;
+};
+/** Other Operators */
+export type OtherOperators = {
+    $subset?: Record<string, any>;
+};
+/** Predefined Search Operators */
+export type PredefinedSearchOperators = LogicalOperators & ComparisonOperators & TypeAndExistenceOperators & ArrayOperators & StringOperators & OtherOperators;
+/**
+ * SearchOptions can be either a function or an object with predefined operators.
+ */
+export type SearchOptions = PredefinedSearchOperators | ((doc: Record<string, any>) => boolean);

package/dist/cjs/types/searchOpts.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Predefined Search Options Quick Reference
+ *
+ * This module defines the types and structures for search operators used
+ * to validate and query data objects.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/types.d.ts

@@ -0,0 +1,6 @@
+export interface Context {
+}
+export interface SortedFiles {
+    i: number;
+    f: string;
+}

package/dist/cjs/types/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/hasFields.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if an object matches the standard field comparison.
+ * @function
+ * @param {Object} obj - The object to check.
+ * @param {Object} fields - Criteria to compare.
+ * @returns {boolean} - Whether the object matches the criteria.
+ */
+export default function hasFields(obj: any, fields: any): any;

package/dist/cjs/utils/hasFields.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = hasFields;
+/**
+ * Checks if an object matches the standard field comparison.
+ * @function
+ * @param {Object} obj - The object to check.
+ * @param {Object} fields - Criteria to compare.
+ * @returns {boolean} - Whether the object matches the criteria.
+ */
+function hasFields(obj, fields) {
+    const keys = Object.keys(fields);
+    return keys.every(key => {
+        if (obj[key] !== undefined) {
+            if (typeof fields[key] === "object" && fields[key] !== null) {
+                return hasFields(obj[key], fields[key]);
+            }
+            return obj[key] === fields[key];
+        }
+        return false;
+    });
+}

package/dist/cjs/utils/hasFieldsAdvanced.d.ts

@@ -0,0 +1,5 @@
+import { Arg } from "../types/arg";
+/**
+ * Checks if an object meets the criteria specified in the fields with operators.
+ */
+export default function hasFieldsAdvanced(obj: Object, fields: Arg): any;