notherbase-fs 2.0.2 → 3.0.0

package/models/index.js

@@ -2,6 +2,8 @@ import mongoose from "mongoose";
 import dotenv from "dotenv";
 dotenv.config();
 import Spirit from "./spirit.js";
+import Item from "./item.js";
+import User from "./user.js";
 import SendMail from "./send-mail.js";
 
 mongoose.connection.on('connected', (err) => {
@@ -26,128 +28,63 @@ 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 migrate = function () {
+//     // 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: {}
+//     }));
     
-//             let found = await spirit.recall();
+//     user.find({}, async (err, users) => {
+//         for (let i = 0; i < users.length; i++) {
+//             let userSpirit = await User.create(
+//                 users[i].username,
+//                 users[i].password,
+//                 users[i].email
+//             );
+            
+//             let foundPages = await page.find({ user: users[i]._id });
     
-//             if (found) {
-//                 spirit.memory.data.tickets.concat(foundPages[i].data.tickets);
-//                 await spirit.commit();
+//             for (let i = 0; i < foundPages.length; i++) {
+//                 let spirit = await Spirit.create({
+//                     route: `/${foundPages[i].name}`,
+//                     service: foundPages[i].name,
+//                     scope: foundPages[i].type,
+//                     parent: userSpirit.memory._id,
+//                     _lastUpdate: 0
+//                 }, foundPages[i].data.tickets);
 //             }
-//             else await spirit.create({
-//                 tickets: foundPages[i].data.tickets 
-//             });
 //         }
-//     }
-// });
-
-
-
-
-
-
+//     });
+// }
 
+// migrate();
 
 export default {
     SendMail: SendMail,

package/models/item.js

@@ -0,0 +1,80 @@
+import Spirit from "./spirit.js";
+
+export default class Item extends Spirit {
+    static create = async (name, short, long) => {
+        let spirit = new Item(name);
+
+        spirit.memory = await Spirit.db.create({
+            route: "/",
+            service: "items",
+            parent: null,
+            scope: "global",
+            _lastUpdate: Date.now(),
+            data: {
+                name,
+                short,
+                long
+            }
+        });
+
+        return spirit;
+    }
+
+    static recallAll = async () => {
+        let spirit = new Item();
+
+        let found = await Spirit.db.find({
+            route: "/",
+            service: "items",
+            parent: null,
+            scope: "global"
+        });
+
+        if (found) {
+            spirit.memory = found;
+            
+            return spirit;
+        }
+        else return null;
+    }
+
+    static recallOne = async (name) => {
+        let spirit = new Item(name);
+
+        let query = Spirit.buildQuery({
+            route: "/",
+            service: "items",
+            parent: null,
+            scope: "global"
+        }, {
+            name: name
+        });
+
+        let found = await Spirit.db.findOne(query);
+
+        if (found) {
+            spirit.memory = found;
+            
+            return spirit;
+        }
+        else return null;
+    }
+
+    static delete = async (name) => {
+        let found = await Spirit.db.findAndDelete(Spirit.buildQuery({
+            route: "/",
+            service: "items",
+            parent: null,
+            scope: "global"
+        }, {
+            name: name
+        }));
+
+        return found.deletedCount;
+    }
+
+    constructor(name = "") {
+        super();
+        this.name = name;
+    }
+}

package/models/send-mail.js

@@ -22,6 +22,8 @@ const passwordReset = async (toEmail, resetToken) => {
 };
 
 const send = async (toEmail, subject, html) => {
+    console.log("dfhd");
+
     var transporter = nodemailer.createTransport({
         service: 'gmail',
         auth: {

package/models/spirit.js

@@ -1,19 +1,6 @@
 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,
@@ -27,133 +14,108 @@ export default class Spirit {
         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;
+    static buildQuery = (options = {}, data = {}, id = null) => {
+        let query = {};
+        
+        if (id) query = {
+            _id: id
+        };
+        if (options) query = {
+            ...query,
+            ...options
+        };
+        if (data){
+            let keys = Object.keys(data);
+            for (let i = 0; i < keys.length; i++) {
+                query[`data.${keys[i]}`] = data[keys[i]];
+            }
+        }
+    
+        return query;
     }
 
-    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,
+    static create = async (options, data) => {
+        let spirit = new Spirit();
+
+        spirit.memory = await Spirit.db.create({
+            ...options,
+            _lastUpdate: Date.now(),
             data: data
-        }, {
-            upsert: true
         });
 
-        return true;
+        return spirit;
     }
 
-    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);
+    static recall = async (options = {}, data = {}, id = null) => {
+        let spirit = new Spirit();
 
-        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
-        });
+        let query = Spirit.buildQuery(options, data, id);
+
+        let found = await Spirit.db.find(query);
 
-        if (found && new Date(found._lastUpdate) > new Date(this.body._lastUpdate)) {
-            this.memory = found;
-            this.time = found._lastUpdate;
+        if (found) {
+            spirit.memory = found;
+            if (!spirit.memory.data) spirit.memory.data = {};
             
-            return found.data;
+            return spirit;
         }
-        else return false;
+        else return null;
     }
 
-    getAll = async () => {
-        let found = await Spirit.db.find({ 
-            route: this.body.route,
-            service: this.body.service,
-            scope: this.body.scope
-        });
+    static recallOne = async (options = {}, data = {}, id = null) => {
+        let spirit = new Spirit();
 
-        if (found) {
-            this.memory = found;
-            this.time = found._lastUpdate;
+        let query = Spirit.buildQuery(options, data, id);
 
-            let takeout = [];
-            for (let i = 0; i < found.length; i++) {
-                takeout.push(found[i].data)
-            }
+        let found = await Spirit.db.findOne(query);
+
+        if (found) {
+            spirit.memory = found;
+            if (!spirit.memory.data) spirit.memory.data = {};
             
-            return takeout;
+            return spirit;
         }
-        else return false;
+        else return null;
     }
 
-    recallFromData = async (which, query) => {
-        let found = await Spirit.db.findOne({ 
-            route: this.body.route,
-            service: this.body.service
-        }).where(`data.${which}`).equals(query);
+    static recallOrCreate = async (options = {}, queryData = {}, initdata = {}) => {
+        let spirit = new Spirit();
+
+        let query = Spirit.buildQuery(options, queryData);
+
+        let found = await Spirit.db.findOne(query);
 
-        if (found && new Date(found._lastUpdate) > new Date(this.body._lastUpdate)) {
-            this.memory = found;
-            this.time = found._lastUpdate;
+        if (found) {
+            spirit.memory = found;
+            if (!spirit.memory.data) spirit.memory.data = {};
             
-            return found.data;
+            return spirit;
+        }
+        else {
+            let newSpirit = await Spirit.create(options, initdata);
+            return newSpirit;
         }
-        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
-        });
+    static delete = async (options = {}, data = {}, id = null) => {
+        let found = await Spirit.db.findAndDelete(Spirit.buildQuery(options, data, id));
+
+        return found.deletedCount;
+    }
+
+    constructor() {
+        this.memory = {
+            data: {}
+        };
     }
 
-    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);
+    commit = async (data = this.memory.data) => {
+        this.memory._lastUpdate = Date.now();
+
+        this.memory.data = data;
+        this.memory.markModified("data");
+        await this.memory.save();
+
+        return "Updated";
     }
 };