notherbase-fs 4.4.6 → 4.5.0

package/notherbase-fs.js

@@ -1,30 +1,35 @@
 import dotenv from "dotenv";
 dotenv.config();
-import Models from "./models/index.js";
+import Spirit from "./server/spirit.js";
+import SendMail from "./server/send-mail.js";
 import { Server } from "socket.io";
 import express from "express";
 import http from 'http';
 import { fileURLToPath } from 'node:url';
 const __dirname = fileURLToPath(new URL('./', import.meta.url));
-import Creation from "./controllers/creation.js";
-import SpiritWorld from "./controllers/spirit-world.js";
+import Creation from "./server/creation.js";
+import SpiritWorld from "./server/spirit-world.js";
 import favicon from 'serve-favicon';
 import session from 'express-session';
 import MongoStore from 'connect-mongo';
 
 
 /**
- * The engine that runs a nother base.
+ * The engine that runs nother bases.
  */
 class NotherBaseFS {
     constructor(globals = {}, bases = {}) {
         this.bases = bases;
+    
+        this.initServer();
+    }
 
+    initServer() {
         this.app = express();
         this.server = http.createServer(this.app);
         this.io = new Server(this.server);
         this.spiritWorld = new SpiritWorld(this.io);
-        this.creation = new Creation(bases);
+        this.creation = new Creation(this.bases);
 
         //set view engine
         this.app.set("view engine", "ejs");
@@ -43,11 +48,12 @@ class NotherBaseFS {
         //be safe, needs to be before session
         if (process.env.PRODUCTION == "true") this.app.set('trust proxy', 2);
 
-        let baseKeys = Object.keys(this.bases);
+        //provide multiple base support
         let store = MongoStore.create({ mongoUrl: process.env.MONGODB_URI });
+        let baseKeys = Object.keys(this.bases);
         for (let i = 0; i < baseKeys.length; i++) {
             this.bases[baseKeys[i]].static = express.static(this.bases[baseKeys[i]].directory + "/public");
-            this.bases[baseKeys[i]].favicon = favicon(this.bases[baseKeys[i]].directory + this.bases[baseKeys[i]].icon);
+            if (this.bases[baseKeys[i]].icon) this.bases[baseKeys[i]].favicon = favicon(this.bases[baseKeys[i]].directory + this.bases[baseKeys[i]].icon);
             this.bases[baseKeys[i]].session = session({
                 store: store,
                 secret: process.env.SECRET,
@@ -61,39 +67,40 @@ class NotherBaseFS {
             });
         }
 
-        //provide database access and etc to use in routes
+        
         this.app.use((req, res, next) => {
             let split = req.hostname.split(".");
             if (split.length > 2) {
                 if (split[split.length - 2].length < 3) req.hosting = split[split.length - 3] + split[split.length - 2];
                 else req.hosting = split[split.length - 2];
             }
-            else req.hosting = split[0];        
+            else req.hosting = split[0]; 
             
             req.contentPath = this.bases[req.hosting].directory;
             next();
         });
 
+        // allows us to get static files like css
+        this.app.use((req, res, next) => {
+            this.bases[req.hosting].static(req, res, next);
+        });
+        this.app.use(express.static(`${__dirname}/public`));
+
         this.app.use((req, res, next) => {
-            this.bases[req.hosting].favicon(req, res, next);
+            if (this.bases[req.hosting].favicon) this.bases[req.hosting].favicon(req, res, next);
+            else next();
         });
 
         //enable cookies
         this.app.use((req, res, next) => {
             this.bases[req.hosting].session(req, res, next);
         });  
-        
-        // allows us to get static files like css
-        this.app.use((req, res, next) => {
-            this.bases[req.hosting].static(req, res, next);
-        });
-        this.app.use(express.static(`${__dirname}/public`));
 
         //provide database access and etc to use in routes
         this.app.use(async (req, res, next) => {
-            req.globals = globals;
-            req.db = Models;
-            req.user = req.session?.currentUser ? await req.db.Spirit.recallOne("user", null, { username: req.session.currentUser }) : null;
+            req.Spirit = Spirit;
+            req.SendMail = SendMail;
+            req.user = req.session?.currentUser ? await req.Spirit.findOne({ service: "user", username: req.session.currentUser }) : null;
             req.lock = false;
             // enables sessions only if the protocol is https and we are in production, or if we are in development
             req.sessionsEnabled = (process.env.PRODUCTION == "true" && req.secure) || process.env.PRODUCTION == "false";
@@ -101,20 +108,20 @@ class NotherBaseFS {
         });
 
         //destroy session if it is not authorized
-        this.app.use(async (req, res, next) => {
-            if (req.session.currentUser) {
-                if (req.user?.memory?.data?.sessions?.[req.session.id]) {
-                    if (req.user.memory.data.sessions[req.session.id] < Date.now()) {
-                        req.session.regenerate(() => {});
-                        delete req.user.memory.data.sessions[req.session.id];
-                        await req.user.commit();
-                    }
-                }
-                else req.session.regenerate(() => {});
-            }
+        // this.app.use(async (req, res, next) => {
+        //     if (req.session.currentUser) {
+        //         if (req.user?.memory?.data?.sessions?.[req.session.id]) {
+        //             if (req.user.memory.data.sessions[req.session.id] < Date.now()) {
+        //                 req.session.regenerate(() => {});
+        //                 delete req.user.memory.data.sessions[req.session.id];
+        //                 await req.user.commit();
+        //             }
+        //         }
+        //         else req.session.regenerate(() => {});
+        //     }
 
-            next();
-        });
+        //     next();
+        // });
 
         //spirit world routes
         this.app.use("/s", this.spiritWorld.router);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "notherbase-fs",
-  "version": "4.4.6",
+  "version": "4.5.0",
   "description": "Functions to help make developing for NotherBase easier.",
   "exports": "./notherbase-fs.js",
   "scripts": {

package/public/js/base.js

@@ -108,52 +108,12 @@ class Base {
      * @param {ObjectID} id The id of the spirit to load.
      * @returns Spirit world response.
      */
-    loadAll = async (service, scope = "local", data = {}, id = null) => {
-        let response = await $.post("/s/loadAll", JSON.stringify({ service, scope, data, id }));
-
-        return response;
-    }
-
-    /**
-     * Loads a single spirit of a certain service.
-     * @param {String} service The name of the spirit to load.
-     * @param {String} scope Defaults to local, else global.
-     * @param {Object} data Data to filter the spirits by.
-     * @param {ObjectID} id The id of the spirit to load.
-     * @returns Spirit world response.
-     */ 
-    load = async (service, scope = "local", data = {}, id = null) => {
+    load = async (service, scope = "local", data = null, id = null) => {
         let response = await $.post("/s/load", JSON.stringify({ service, scope, data, id }));
 
         return response;
     }
 
-    /**
-     * Saves a spirit of a certain service.
-     * @param {String} service The name of the spirit to save.
-     * @param {String} scope Defaults to local, else global.
-     * @param {Object} data Data to save the spirit with.
-     * @param {ObjectID} id The id of the spirit to save.
-     * @returns Spirit world response.
-     */
-    save = async (service, scope = "local", data = {}, id = null) => {
-        let response = await $.post("/s/save", JSON.stringify({ service, scope, data, id }));
-        return response;
-    }
-
-    /**
-     * Deletes a spirit of a certain service.
-     * @param {String} service The name of the spirit to delete.
-     * @param {String} scope Defaults to local, else global.
-     * @param {Object} data Data to filter the spirits by.
-     * @param {ObjectID} id The id of the spirit to delete.
-     * @returns Spirit world response.
-     */
-    delete = async (service, scope = "local", data = {}, id = null) => {
-        let response = await $.post("/s/delete", JSON.stringify({ service, scope, data, id }));
-        return response;
-    }
-
     /**
      * Appends html to the head.
      * @param {String} html The html to append.

package/server/creation.js

@@ -0,0 +1,117 @@
+import express from "express";
+import fs from 'fs';
+
+/**
+ * Creation is all the renedered pages in a base.
+ */
+export default class Creation {
+    constructor(bases = {}) {
+        this.bases = bases;
+        this.router = express.Router();
+
+        this.router.get("/", this.explore);
+        this.router.get("/the-front", this.explore);
+        this.router.get(`/:region`, this.lock, this.explore);
+        this.router.get(`/:region/:area`, this.lock, this.explore);
+        this.router.get(`/:region/:area/:poi`, this.lock, this.explore);
+        this.router.get(`/:region/:area/:poi/:detail`, this.lock, this.explore);
+
+        //void
+        this.router.use(function(req, res) {
+            res.redirect("/void");
+        });
+    }
+
+    /**
+     * This middleware requires a user to login to access affected routes.
+     * @param {Object} req An Express.js request.
+     * @param {Object} res An Express.js response.
+     * @param {Function} next next()
+     */
+    lock = (req, res, next) => {
+        req.lock = true;
+        next();
+    }
+
+    /**
+     * This route renders a page and sends it to the client.
+     * @param {Object} req An Express.js request.
+     * @param {Object} res An Express.js response.
+     * @param {Function} next next()
+     */
+    explore = async (req, res, next) => {
+        try {
+            req.main = `index`;
+            if (req.params.detail) req.main = req.params.detail + "\\" + req.main;
+            if (req.params.poi) req.main = req.params.poi + "\\" + req.main;
+            if (req.params.area) req.main = req.params.area + "\\" + req.main;
+            if (req.params.region) req.main = req.params.region + "\\" + req.main;
+            else req.main = "the-front\\" + req.main;
+            req.main = req.contentPath + "\\" + req.main;
+            req.preprocess = "_preprocess";
+            if (req.params.detail) req.preprocess = req.params.detail + "\\" + req.preprocess;
+            if (req.params.poi) req.preprocess = req.params.poi + "\\" + req.preprocess;
+            if (req.params.area) req.preprocess = req.params.area + "\\" + req.preprocess;
+            if (req.params.region) req.preprocess = req.params.region + "\\" + req.preprocess;
+            else req.preprocess = "the-front\\" + req.preprocess;
+            req.preprocess = req.contentPath + "\\" + req.preprocess;
+            req.siteTitle = `${this.bases[req.hosting].title} - ${req.params.detail || req.params.poi || req.params.area || req.params.region || "Home"}`;
+            req.toRender = "explorer";
+            
+            if (fs.existsSync(req.main + ".ejs")) {
+                let stats = await req.Spirit.findOne({ service: "stats", data: { route: req.path } });
+                if (stats == null) stats = new req.Spirit({ service: "stats", data: { route: req.path, visits: 0 } });
+                if (stats.data.visits) stats.data.visits++;
+                else stats.data.visits = 1;
+                await stats.commit();
+
+                let context = {
+                    user: null,
+                    siteTitle: req.siteTitle,
+                    main: req.main,
+                    query: req.query,
+                    route: req.path,
+                    requireUser: req.lock,
+                    preprocessed: {}
+                }
+
+                if (req.session.currentUser) {
+                    let user = req.user;
+                    context.user = {
+                        data: user.data,
+                        backups: user.backups,
+                        _id: user._id,
+                        parent: user.parent,
+                        service: user.service,
+                        _lastUpdate: user._lastUpdate
+                    }
+                }      
+
+                //preprocess
+                let preprocessScripts = fs.existsSync(req.preprocess) ? fs.readdirSync(req.preprocess) : [];
+                for (let preprocessScript of preprocessScripts) {
+                    try {
+                        let scriptPath = `${req.preprocess}/${preprocessScript}`;
+
+                        if (fs.existsSync(scriptPath)) {
+                            let script = await import(process.env.WINDOWS == "true" ? `file://${scriptPath}` : scriptPath);
+                            let result = await script.default(req, context.user, this.io);
+                            context.preprocessed[preprocessScript.split(".")[0]] = result;
+                        }
+                        else context.preprocessed[preprocessScript.split(".")[0]] = `Error: Script Not Found`;
+                    } catch (error) {
+                        console.log(error);
+                        context.preprocessed[preprocessScript.split(".")[0]] = `Error: Server Error`;
+                    }
+                }
+
+                res.render(req.toRender, context);
+            }
+            else next();
+        }
+        catch(err) {
+            console.log(err);
+            res.status(500).send("Server Error");
+        }
+    }
+}

package/server/spirit-world.js

@@ -0,0 +1,147 @@
+import express from "express";
+import { stripHtml } from "string-strip-html";
+import { success, fail } from "./util.js";
+import User from "./user.js";
+import fs from 'fs';
+
+/**
+* The spirit world is the API of a base.
+*/
+export default class SpiritWorld {
+    /**
+     * Sets up the spirit world.
+     * @param {Server} io 
+     */
+    constructor(io) {
+        this.io = io;
+        this.rooms = {};
+        this.io.on('connection', this.setupChat);
+
+        this.user = new User();
+        this.router = express.Router();
+        this.router.post("/load", this.load);
+        this.router.post("/serve", this.serve);
+        this.router.use("/user", this.user.router);
+    }
+
+    /**
+     * Sets up socket.io for instant messaging and etc.
+     * @param {*} socket 
+     */
+    setupChat = (socket) => {
+        try {
+            let roomName = socket.handshake.query.room;
+            socket.join(roomName);
+            let room = this.rooms[roomName];
+            if (room) room.users.push(socket.handshake.query.name);
+            else {
+                this.rooms[roomName] = {
+                    users: [ socket.handshake.query.name ]
+                }
+                room = this.rooms[roomName];
+            }
+        
+            this.io.to(roomName).emit("chat message", {
+                name: "Server",
+                time: Date.now(),
+                text: `${socket.handshake.query.name} has joined the room.`
+            });
+
+            this.io.to(roomName).emit("chat info", {
+                name: socket.handshake.query.room,
+                time: Date.now(),
+                data: {
+                    users: room.users
+                }
+            });
+        
+            socket.on("chat message", (msg) => {
+                this.io.to(roomName).emit("chat message", {
+                    name: msg.name,
+                    time: msg.time,
+                    text: stripHtml(msg.text).result
+                });
+            });
+        
+            socket.on('disconnect', () => {
+                room.users.splice(room.users.indexOf(socket.handshake.query.name));
+
+                this.io.to(roomName).emit("chat message", {
+                    name: "Server",
+                    time: Date.now(),
+                    text: `${socket.handshake.query.name} has left the room.`
+                });
+
+                this.io.to(roomName).emit("chat info", {
+                    name: socket.handshake.query.room,
+                    time: Date.now(),
+                    data: {
+                        users: room.users
+                    }
+                });
+
+                if (room.users.length < 1) delete this.rooms[roomName];
+            });
+        } catch (error) {
+            console.log(error);
+            fail(res, "Server error: Sockets");
+        }        
+    }
+
+    /**
+     * This API route requests all spirits of a kind from the database.
+     * @param {Object} req
+     * @param {Object} res
+     * @returns {Object} The requested spirits.
+     */
+    load = async (req, res) => {
+        try {
+            let query = {
+                service: req.body.service,
+                parent: null
+            };
+            if (req.body.data) query.data = req.body.data;
+            if (req.body.id) query._id = req.body.id;
+
+            // if the scope is local, the parent is the user's id
+            if (req.body.scope === "local") {
+                if (req.user?._id) query.parent = req.user._id;
+                else {
+                    fail(res, "User had no id on load()");
+                    return;
+                }
+            } 
+
+            // recall all spirits with the given service name and parent
+            let spirits = await req.Spirit.find(query);
+
+            res.send(spirits);
+        } catch (error) {
+            console.log(error);
+            fail(res, "Server error");
+        }
+    }
+
+    /**
+     * This API route runs a script on the server. Responds with the result.
+     * @param {Object} req 
+     * @param {Object} res 
+     */
+    serve = async (req, res) => {
+        try {
+            let scriptPath = `${req.contentPath}${req.body.route}/${req.body.script}.js`;
+        
+            let script, result = null;
+
+            if (fs.existsSync(scriptPath)) {
+                script = await import(process.env.WINDOWS == "true" ? `file://${scriptPath}` : scriptPath);
+                result = await script.default(req, req.user, this.io);
+                success(res, "Served.", result);
+            }
+            else fail(res, `Script not found: ${req.body.script} at ${scriptPath}`);
+        } catch (error) {
+            console.log(error);
+            fail(res, "Server error");
+        }        
+    }
+}

package/server/spirit.js

@@ -0,0 +1,83 @@
+import mongoose from "mongoose";
+import dotenv from "dotenv";
+dotenv.config();
+
+
+// DB setup
+mongoose.set('strictQuery', true);
+mongoose.connection.on('connected', (err) => {
+    console.log(`Mongoose connected to db`);
+});
+mongoose.connection.on('error', (err) => {
+    console.log(`Mongoose ${err}`);
+});
+mongoose.connection.on('disconnected', () => {
+    console.log('Mongoose disconnected');
+});
+try {
+    mongoose.connect(process.env.MONGODB_URI);
+}
+catch (err) {
+    console.log(`Mongoose on connect: ${err}`);
+}
+
+/**
+ * Curated Mongoose.js documents for use in bases.
+ */
+let spiritSchema = new mongoose.Schema({
+    _lastUpdate: Number,
+    service: String,
+    parent: { 
+        type: mongoose.Schema.Types.ObjectId, 
+        ref: "spirits",
+        required: false
+    },
+    data: {},
+    backups: []
+});
+
+/**
+ * Commits new data to a spirit.
+ * @param {Object} data Data to save.
+ * @returns Updated
+ */
+spiritSchema.method("commit", async function(data = this.data, maxBackups = 5) {
+    this._lastUpdate = Date.now();
+
+    this.backups.unshift({
+        _lastUpdate: Date.now(),
+        data: this.data
+    });
+    if (maxBackups > 1) {
+        while (this.backups.length > maxBackups) this.backups.pop();
+    }
+    this.data = data;
+    this.markModified("backups");
+    this.markModified("data");
+    await this.save();
+
+    return "Updated";
+});
+
+/**
+ * Restores a backup by its index.
+ * @param {Number} backupIndex The index of the backup to restore.
+ * @returns Status message.
+ */
+spiritSchema.method("restoreBackup", async function(backupIndex) {
+    if (backupIndex < 0 || backupIndex >= this.backups.length) return "Invalid backup index";
+    let backup = this.backups[backupIndex];
+    this.backups.unshift({
+        _lastUpdate: Date.now(),
+        data: this.data
+    });
+    this.data = backup.data;
+    this.markModified("backups");
+    this.markModified("data");
+    await this.save();
+    return "Restored";
+});
+
+let Spirit = mongoose.model('spirits', spiritSchema);
+
+export default Spirit;