database basically working

server/db/db.js

@@ -1,41 +1,73 @@
 import fs from 'fs/promises';
 import chalk from 'chalk';
 import path from 'path';
-
-import Titles from "./model/Titles.js"
-import Networks from "./model/Networks.js"
-import Members from './model/Members.js'
-import Tokens from './model/Tokens.js'
-import Payments from "./model/Payments.js"
-import Posts from "./model/Forum/Posts.js"
-import Conversations from "./model/Messages/Conversations.js"
-import Messages from "./model/Messages/Messages.js"
+import {nodeModels, edgeModels} from './model/import.js'
 
 export default class Database {
-    titles = new Titles()
-    networks = new Networks()
-    members = new Members()
-    tokens = new Tokens()
-    payments = new Payments()
-    posts = new Posts()
-    conversations = new Conversations()
-    messages = new Messages()
 
-    fromID = {
-        "MEMBER": this.members,
-        "NETWORK": this.networks,
-        "TITLE": this.titles,
-        "TOKEN": this.tokens,
-        "PAYMENT": this.payments,
-        "POST": this.posts,
-        "CONVERSATION": this.conversations,
-        "DM": this.messages
-    }
+    nodes = new Array(10000).fill(0);
+    edges = new Array(10000).fill(0);
 
     constructor() {
+        let values = Object.values(nodeModels)
+        for(let i = 0; i < values.length; i++) {
+            let key = values[i].constructor.name
+            key = key.toLowerCase() + "s"
+            this[key] = values[i]
+        }
+        let eValues = Object.values(edgeModels)
+        for(let i = 0; i < eValues.length; i++) {
+            let key = eValues[i].constructor.name
+            key = key.toLowerCase() + "s"
+            this[key] = eValues[i]
+        }
         this.loadData()
     }
 
+    addNode(id, node) {
+        try {
+            let type = id.split("-")[0]
+            let model = nodeModels[type[0] + type.slice(1).toLowerCase()]
+            if(model) {
+                let schema = model.schema
+                let result = schema.safeParse(node)
+                if(result.success) {
+                    this.nodes[model.indices[1]] = node
+                    model.indices[1]++;
+                } else {
+                    console.error(result.error)
+                    throw new global.ServerError(400, "Invalid Data!");
+                }
+            } else {
+                throw new Error("Type does not exist for node: " + id)
+            }
+        } catch(e) {
+            throw e
+        }
+    }
+
+    addEdge(id, edge) {
+        try {
+            let type = id.split("-")[0]
+            let model = edgeModels[type]
+            if(model) {
+                let schema = model.schema
+                let result = schema.safeParse(edge)
+                if(result.success) {
+                    this.edges[model.indices[1]] = edge
+                    model.indices[1]++;
+                } else {
+                    console.error(result.error)
+                    throw new global.ServerError(400, "Invalid Data!");
+                }
+            } else {
+                throw new Error("Type does not exist for edge: " + id)
+            }
+        } catch(e) {
+            throw e
+        }
+    }
+
     async loadData() {
         const dbData = await fs.readFile(path.join(process.cwd(), 'db/db.json'), 'utf8');
         let dbJson;
@@ -44,24 +76,21 @@ export default class Database {
         } catch {
             dbJson = []
         }
+
         let nodes = dbJson["nodes"];
         let entries = Object.entries(nodes)
-        
         for(let i=0; i<entries.length; i++) {
             let entry = entries[i]
             let id = entry[0]; let node = entry[1];
-            let type = id.split("-")[0]
-            try {
-                let collection = this.fromID[type]
-                if(collection) {
-                    collection.save(node, id)
-                } else {
-                    throw new Error("Type does not exist for node: ", id)
-                }
-            } catch(e) {
-                throw e
-            }
+            this.addNode(id, node)
+        }
 
+        let edges = dbJson["edges"];
+        let edgeEntries = Object.entries(edges)
+        for(let i=0; i<edgeEntries.length; i++) {
+            let entry = edgeEntries[i]
+            let id = entry[0]; let node = entry[1];
+            this.addEdge(id, node)
         }
 
         setInterval(() => {
@@ -72,37 +101,37 @@ export default class Database {
 
     async saveData() {
         let data = {
-            "nodes": {
-
-            },
-            "edges": {
-
-            }
+            "nodes": {},
+            "edges": {}
         }
-        let arrs = [
-            this.titles.entries,
-            this.members.entries,
-            this.tokens.entries,
-            this.posts.entries,
-            this.conversations.entries,
-            this.messages.entries,
-            this.payments.entries,
-        ]
-        let ids = [
-            Object.entries(this.titles.ids),
-            Object.entries(this.members.ids),
-            Object.entries(this.tokens.ids),
-            Object.entries(this.posts.ids),
-            Object.entries(this.conversations.ids),
-            Object.entries(this.messages.ids),
-            Object.entries(this.payments.ids),
-        ]
-        for(let i=0; i<arrs.length; i++) {
-            let arr = arrs[i]
-            for(let j=0; j<arr.length; j++) {
-                data.nodes[ids[i][j][0]] = arr[j]
+
+        let nModels = Object.values(nodeModels)
+        this.nodes.forEach((entry, i) => {
+            if(entry) {
+                for(let j = 0; j < nModels.length; j++) {
+                    let model = nModels[j]
+                    let indices = model.indices
+                    if(i >= indices[0] && i < indices[1]) {
+                        let prefix = model.prefix
+                        data.nodes[prefix + "-" + entry.id] = entry
+                    }
+                }
             }
-        }
+        })
+
+        let eModels = Object.values(edgeModels)
+        this.edges.forEach((entry, i) => {
+            if(entry) {
+                for(let j = 0; j < eModels.length; j++) {
+                    let model = eModels[j]
+                    let indices = model.indices
+                    if(i >= indices[0] && i < indices[1]) {
+                        let prefix = model.prefix
+                        data.nodes[prefix + "-" + entry.id] = entry
+                    }
+                }
+            }
+        })
 
         let string = JSON.stringify(data, null, 4)
         await fs.writeFile(path.join(process.cwd(), 'db/db.json'), string, "utf8");