notherbase-fs 1.5.3 → 2.0.1

package/models/index.js

@@ -1,6 +1,8 @@
 import mongoose from "mongoose";
 import dotenv from "dotenv";
 dotenv.config();
+import Spirit from "./spirit.js";
+import SendMail from "./send-mail.js";
 
 mongoose.connection.on('connected', (err) => {
     console.log(`Mongoose connected to db`);
@@ -14,28 +16,142 @@ mongoose.connection.on('disconnected', () => {
     console.log('Mongoose disconnected');
 });
 
-let connectionSuccess = false;
-
 try {
     mongoose.connect(process.env.MONGODB_URI, { 
         useNewUrlParser: true,
         useUnifiedTopology: true
     });
-
-    connectionSuccess = true;
 }
 catch (err) {
     console.log(`Mongoose on connect: ${err}`);
 }
 
+class User extends Spirit {
+    constructor(service, email = null) {
+        super();
+        this.body.route = "/";
+        this.body.service = service;
+        this.email = email;
+    }
+
+    recall = async () => {
+        let result = await this.recallFromData("email", this.email);
+        return result;
+    }
+}
+
+class Item extends Spirit {
+    constructor(name = "") {
+        super();
+        this.body.route = "/";
+        this.body.service = "item";
+
+        this.memory = {
+            data: {
+                name: name
+            }
+        }
+    }
+
+    recall = async () => {
+        let result = await this.recallFromData("name", this.memory.data.name);
+        return result;
+    }
+    
+    commit = async (data = this.memory.data) => {
+        let result = await this.commitByData("name", this.memory.data.name, data);
+        return result;
+    }
+
+    delete = async () => {
+        let result = await this.deleteByData("name", this.memory.data.name);
+        return result;
+    }
+}
+
+
+// migrate
+// const user = mongoose.model('users', new mongoose.Schema({
+//     username: String,
+//     password: String,
+//     email: String,
+//     coin: Number,
+//     home: String,
+//     authLevels: [ String ],
+//     location: String,
+//     attributes: {
+//         translation: Number,
+//         strength: Number,
+//         agility: Number,
+//         defense: Number
+//     },
+//     reset: {
+//         token: Number,
+//         exp: Number
+//     }
+// }));
+// const page = mongoose.model('pages', new mongoose.Schema({
+// 	name: String,
+// 	type: String,
+//     user: { 
+//         type: mongoose.Schema.Types.ObjectId, 
+//         ref: "users",
+//         required: false
+//     },
+//     data: {}
+// }));
+
+// user.find({}, async (err, users) => {
+//     for (let i = 0; i < users.length; i++) {
+//         let userSpirit = new User("user", users[i].email);
+        
+//         await userSpirit.create({
+//             username: users[i].username,
+//             password: users[i].password,
+//             email: users[i].email,
+//             coin: users[i].coin,
+//             home: users[i].home,
+//             authLevels: users[i].authLevels,
+//             location: users[i].location,
+//             attributes: users[i].attributes,
+//             inventory: []
+//         });
+        
+//         let foundPages = await page.find({ user: users[i]._id });
+
+//         for (let i = 0; i < foundPages.length; i++) {
+//             let spirit = new Spirit({
+//                 route: `/${foundPages[i].name}`,
+//                 service: foundPages[i].name,
+//                 scope: foundPages[i].type,
+//                 parent: userSpirit.memory._id,
+//                 _lastUpdate: 0,
+//                 data: foundPages[i].data.tickets
+//             });
+    
+//             let found = await spirit.recall();
+    
+//             if (found) {
+//                 spirit.memory.data.tickets.concat(foundPages[i].data.tickets);
+//                 await spirit.commit();
+//             }
+//             else await spirit.create({
+//                 tickets: foundPages[i].data.tickets 
+//             });
+//         }
+//     }
+// });
+
+
+
+
+
+
+
 
-export {default as chat} from "./chat.js";
-export {default as item} from "./item.js";
-export {default as user} from "./user.js";
-export {default as contact} from "./contact.js";
-export {default as inventory} from "./inventory.js";
-export {default as game} from "./game.js";
-export {default as sendMail} from "./send-mail.js";
-export {default as detail} from "./detail.js";
-export {default as page} from "./page.js";
-export { connectionSuccess };
+export default {
+    SendMail: SendMail,
+    Spirit: Spirit,
+    User: User,
+    Item: Item
+}

package/models/spirit.js

@@ -0,0 +1,159 @@
+import mongoose from "mongoose";
+
+export default class Spirit {
+    constructor(body = {}) {
+        this.body = body;
+        if (!this.body.route) this.body.route = "/";
+        if (!this.body.service) this.body.service = "default"; 
+        if (!this.body.scope) this.body.scope = "global";
+        if (!this.body.parent) this.body.parent = null;
+        if (!this.body._lastUpdate) this.body._lastUpdate = 0;
+        if (!this.body.data) this.body.data = {};
+        this.memory = {
+            data: {}
+        };
+    }
+
+    static db = mongoose.model('spirits', new mongoose.Schema({
+        _lastUpdate: Number,
+        route: String,
+        service: String,
+        scope: String,
+        parent: { 
+            type: mongoose.Schema.Types.ObjectId, 
+            ref: "spirits",
+            required: false
+        },
+        data: {}
+    }));
+
+    create = async (data = this.memory.data) => {
+        this.time = Date.now();
+
+        this.memory = await Spirit.db.create({ 
+            route: this.body.route,
+            service: this.body.service,
+            scope: this.body.scope,
+            parent: this.body.parent,
+            _lastUpdate: this.time,
+            data: data
+        });
+
+        return true;
+    }
+
+    commit = async (data = this.memory.data) => {
+        this.time = Date.now();
+
+        this.memory = await Spirit.db.updateOne({ 
+            route: this.body.route,
+            service: this.body.service,
+            scope: this.body.scope,
+            parent: this.body.parent
+        }, { 
+            route: this.body.route,
+            service: this.body.service,
+            scope: this.body.scope,
+            parent: this.body.parent,
+            _lastUpdate: this.time,
+            data: data
+        }, {
+            upsert: true
+        });
+
+        return true;
+    }
+
+    commitByData = async (which, query, data = this.memory.data) => {
+        this.time = Date.now();
+
+        this.memory = await Spirit.db.updateOne({ 
+            route: this.body.route,
+            service: this.body.service,
+            scope: this.body.scope,
+            parent: this.body.parent
+        }, { 
+            route: this.body.route,
+            service: this.body.service,
+            scope: this.body.scope,
+            parent: this.body.parent,
+            _lastUpdate: this.time,
+            data: data
+        }, {
+            upsert: true
+        }).where(`data.${which}`).equals(query);
+
+        return true;
+    }
+    
+    recall = async () => {
+        let found = await Spirit.db.findOne({ 
+            route: this.body.route,
+            service: this.body.service,
+            scope: this.body.scope,
+            parent: this.body.parent
+        });
+
+        if (found && new Date(found._lastUpdate) > new Date(this.body._lastUpdate)) {
+            this.memory = found;
+            this.time = found._lastUpdate;
+            
+            return found.data;
+        }
+        else return false;
+    }
+
+    getAll = async () => {
+        let found = await Spirit.db.find({ 
+            route: this.body.route,
+            service: this.body.service,
+            scope: this.body.scope
+        });
+
+        if (found) {
+            this.memory = found;
+            this.time = found._lastUpdate;
+
+            let takeout = [];
+            for (let i = 0; i < found.length; i++) {
+                takeout.push(found[i].data)
+            }
+            
+            return takeout;
+        }
+        else return false;
+    }
+
+    recallFromData = async (which, query) => {
+        let found = await Spirit.db.findOne({ 
+            route: this.body.route,
+            service: this.body.service
+        }).where(`data.${which}`).equals(query);
+
+        if (found && new Date(found._lastUpdate) > new Date(this.body._lastUpdate)) {
+            this.memory = found;
+            this.time = found._lastUpdate;
+            
+            return found.data;
+        }
+        else return false;
+    }
+
+    delete = async () => {
+        await Spirit.db.findOneAndDelete({ 
+            route: this.body.route,
+            service: this.body.service,
+            scope: this.body.scope,
+            parent: this.body.parent
+        });
+    }
+
+    deleteByData = async (which, query) => {
+        await Spirit.db.findOneAndDelete({ 
+            route: this.body.route,
+            service: this.body.service,
+            scope: this.body.scope,
+            parent: this.body.parent
+        }).where(`data.${which}`).equals(query);
+    }
+};

package/notherbase-fs.js

@@ -1,6 +1,6 @@
 import dotenv from "dotenv";
 dotenv.config();
-import * as db from "./models/index.js";
+import Models from "./models/index.js";
 import { Server } from "socket.io";
 import express from "express";
 import session from 'express-session';
@@ -10,17 +10,16 @@ import favicon from 'serve-favicon';
 import http from 'http';
 import { fileURLToPath } from 'node:url';
 const __dirname = fileURLToPath(new URL('./', import.meta.url));
-
-import { stripHtml } from "string-strip-html";
-
-import * as controllers from "./controllers/index.js";
+import Creation from "./controllers/creation.js";
+import SpiritWorld from "./controllers/spirit-world.js";
 
 class NotherBaseFS {
-    constructor(worldPath, voidPath, frontPath, pagesPath) {
+    constructor(contentPath) {
         this.app = express();
         this.server = http.createServer(this.app);
         this.io = new Server(this.server);
-        this.db = db;
+        this.creation = new Creation();
+        this.spiritWorld = new SpiritWorld(this.io);
         
         //set views path
         this.app.set("view engine", "ejs");
@@ -30,7 +29,12 @@ class NotherBaseFS {
         this.app.use(methodOverride('_method'));
     
         // allows us to use post body data
-        this.app.use(express.urlencoded({ extended: true }));
+        this.app.use(express.json({
+            extended: true,
+            inflate: true,
+            type: 'application/x-www-form-urlencoded'
+          }));
+        //this.app.use(express.urlencoded({ extended: true }));
     
         // allows us to get static files like css
         this.app.use(express.static('public'));
@@ -40,76 +44,22 @@ class NotherBaseFS {
         this.app.use(favicon(__dirname + '/public/img/logo.png'));
     
         //enable cookies
-        if (this.db.connectionSuccess) {
-            this.app.use(session({
-                store: MongoStore.create({ mongoUrl: process.env.MONGODB_URI }),
-                secret: process.env.SECRET,
-                resave: false,
-                saveUninitialized: false
-            }));
-    
-            console.log("sessions enabled");
-        }
-        else console.log("sessions disabled");
-    
-        this.io.on('connection', (socket) => {
-            socket.join(socket.handshake.query.room);
-        
-            this.io.to(socket.handshake.query.room).emit("chat message", {
-                name: "Server",
-                time: Date.now(),
-                text: `${socket.handshake.query.name} has joined the room.`
-            });
-        
-            socket.on("chat message", (msg) => {
-                this.io.to(socket.handshake.query.room).emit("chat message", {
-                    name: msg.name,
-                    time: msg.time,
-                    text: stripHtml(msg.text).result
-                });
-            });
-        
-            socket.on('disconnect', () => {
-                this.io.to(socket.handshake.query.room).emit("chat message", {
-                    name: "Server",
-                    time: Date.now(),
-                    text: `${socket.handshake.query.name} has left the room.`
-                });
-            });
-        });
+        this.app.use(session({
+            store: MongoStore.create({ mongoUrl: process.env.MONGODB_URI }),
+            secret: process.env.SECRET,
+            resave: false,
+            saveUninitialized: false
+        }));
 
         this.app.use((req, res, next) => {
-            req.db = this.db;
-            req.worldDir = worldPath;
-            req.frontDir = frontPath;
-            req.pagesDir = pagesPath;
-            req.voidDir = voidPath;
-
+            req.db = Models;
+            req.contentPath = contentPath;
             next();
         });
-        
-        this.app.use("/user", controllers.user);
-    
-        this.app.use("/contact", controllers.contact);
-    
-        this.app.use("/game", controllers.game);
-    
-        this.app.use("/inventory", controllers.authCheck, controllers.inventory);
-    
-        this.app.use("/item", controllers.item);
-    
-        this.app.use("/the-front", controllers.front);
-    
-        this.app.use("/", controllers.pages);
-        
-        this.app.use("/", controllers.authCheck, controllers.explorer);
-
-        // start location
-        this.app.get("/", function(req, res) {
-            res.redirect("/the-front");
-        });
 
-        this.app.use(controllers.void);
+        this.app.use("/s", this.spiritWorld.router);
+        
+        this.app.use("/", this.creation.router);
     
         this.server.listen(process.env.PORT, function () {
             console.log(`Server started at ${process.env.PORT}`);

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "notherbase-fs",
-  "version": "1.5.3",
+  "version": "2.0.1",
   "description": "Functions to help make developing for NotherBase easier.",
   "exports": "./notherbase-fs.js",
   "scripts": {
-    "test": "nodemon test/test-index.js",
+    "test": "nodemon test-index.js",
     "gmail-auth": "node gmail-auth.js",
     "gmail-token": "node gmail-token.js"
   },

package/public/js/commune.js

@@ -0,0 +1,22 @@
+const commune = async (action, data = null, options) => {
+    try {
+        let body = {
+            action,
+            data,
+            ...options
+        };
+    
+        let response = null;
+    
+        let onResponse = (res) => {
+            response = res;
+            if (res.status != "success") console.log(`${res.status}: ${res.message}`, res.data);
+        };
+    
+        await $.post("/s", JSON.stringify(body), onResponse);
+    
+        return response;
+    } catch (error) {
+        return error;
+    }
+}

package/public/js/establishment.js

@@ -0,0 +1,44 @@
+class Establishment {
+    constructor() {
+        this._lastUpdate = 0;
+        this.data = {};
+    }
+    
+    load = async (service, route = currentRoute) => {
+        if (!this.data[service]) this.data[service] = { _lastUpdate: 0 };
+
+        let response = await commune("recall", {}, {
+            service: service,
+            _lastUpdate: this.data[service]._lastUpdate,
+            route: route,
+            scope: "global",
+            parent: null
+        });
+
+        if (!response.isUpToDate) {
+            this.data[service] = response.data;
+            this._lastUpdate = this.data[service]._lastUpdate;
+        }
+
+        return this.data[service];
+    }
+    
+    save = async (service, dataToSave, route = currentRoute) => {
+        this._lastUpdate = Date.now();
+        dataToSave._lastUpdate = this._lastUpdate;
+
+        let response = await commune("commit", dataToSave, {
+            service: service,
+            _lastUpdate: this._lastUpdate,
+            route: route,
+            scope: "global",
+            parent: null
+        });
+
+        this.data[service] = dataToSave;
+
+        return response;
+    }
+}
+
+const establishment = new Establishment();

package/public/js/memories.js

@@ -4,41 +4,40 @@ class Memories {
         this.data = {};
     }
     
-    load = async (service, route = currentRoute) => {
-        try {
-            await $.get(`/recall`, {
-                route: route,
-                service: service,
-                _lastUpdate: this._lastUpdate
-            }, (res) => {
-                if (!res.isUpToDate && res.data) {
-                    this.data[service] = JSON.parse(res.data);
-                    this._lastUpdate = this.data[service]._lastUpdate;
-                }
-            });
+    load = async (service, route = currentRoute, parent = null) => {
+        if (!this.data[service]) this.data[service] = { _lastUpdate: 0 };
 
-            return this.data[service];
-        } catch (error) {
-            return error;
+        let response = await commune("recall", {}, {
+            service: service,
+            _lastUpdate: this.data[service]._lastUpdate,
+            route: route,
+            scope: "local",
+            parent: parent
+        });
+
+        if (!response.isUpToDate) {
+            this.data[service] = response.data;
+            this._lastUpdate = this.data[service]._lastUpdate;
         }
+
+        return this.data[service];
     }
     
-    save = async (service, dataToSave, route = currentRoute) => {
-        try {
-            this._lastUpdate = Date.now();
+    save = async (service, dataToSave, route = currentRoute, parent = null) => {
+        this._lastUpdate = Date.now();
+        dataToSave._lastUpdate = this._lastUpdate;
 
-            await $.post('/commit', {
-                route: route,
-                service: service,
-                _lastUpdate: this._lastUpdate,
-                data: JSON.stringify(dataToSave)
-            }, (data) => {
-                this.data[service] = dataToSave;
-                return "saved";
-            });
-        } catch (error) {
-            return error;
-        }
+        let response = await commune("commit", dataToSave, {
+            service: service,
+            _lastUpdate: this._lastUpdate,
+            route: route,
+            scope: "local",
+            parent: parent
+        });
+
+        this.data[service] = dataToSave;
+
+        return response;
     }
 }