working with db, docker working, small error with personal data

server/db/model/member.js

@@ -2,80 +2,84 @@ import path from 'path';
 import fs from 'fs';
 import argon2 from 'argon2';
 import { z } from 'zod';
+import sql from '../sql.js';
 
 export default class Member {
-    prefix = "MEMBER"
-    indices = null
+  schema = z.object({
+    email: z.string().email(),
+    firstName: z.string(),
+    lastName: z.string(),
+    password: z.string(),
+    apps: z.array(z.string())
+  });
 
-    constructor(indices) {
-        this.indices = indices
+  isHashed = (s) => s.startsWith("$argon2");
+
+  async add(newMember, networkId = null) {
+    if (!this.isHashed(newMember.password)) {
+      newMember.password = await argon2.hash(newMember.password);
     }
 
-    schema = z.object({
-        id: z.number(),
-        email: z.string().email(),
-        firstName: z.string(),
-        lastName: z.string(),
-        password: z.string(),
-        apps: z.array(z.string()),
-        created: z.string()
-    })
-
-    isHashed = (s) => {return s.startsWith("$argon2")}
-
-    async add(newMember, network = null) {
-        const hash = await argon2.hash(newMember.password);
-        newMember.password = hash
-        newMember.apps = ["Dashboard"]
-
-        try {
-            global.db.addNode(this.prefix, newMember)
-            if(network) {
-                global.db.edge.add({
-                    type: "IN",
-                    from: `${this.prefix}-${global.db.getCurrentIndex(this)}`,
-                    to: "NETWORK-1"
-                })
-            }
-        } catch(e) {
-            console.error(e)
-            throw new global.ServerError(400, "Failed to add member!");
-        }
+    const result = this.schema.safeParse(newMember);
+    if (!result.success) {
+      console.error(result.error);
+      throw new global.ServerError(400, "Invalid Member Data!");
     }
 
-    async getPersonalData(id) {
-        const filePath = path.join(global.db.PERSONAL_DATA_PATH,  id, "db.json");
+    try {
+      const [member] = await sql`
+        INSERT INTO members ${sql({
+          email:      newMember.email,
+          first_name: newMember.firstName,
+          last_name:  newMember.lastName,
+          password:   newMember.password,
+          apps:       newMember.apps ?? ['Dashboard']
+        })}
+        RETURNING *
+      `;
 
-        const [raw] = await Promise.all([
-            fs.promises.readFile(filePath, "utf8"),
-        ]);
+      if (networkId) {
+        await sql`
+          INSERT INTO member_network ${sql({
+            member_id:  member.id,
+            network_id: networkId,
+            type:       'IN'
+          })}
+        `;
+      }
 
-        const result = raw.trim() ? JSON.parse(raw) : [];
-        return result
+      return member;
+    } catch (e) {
+      console.error(e);
+      throw new global.ServerError(400, "Failed to add member!");
     }
+  }
 
-    getByNetwork(id) {
-        let connections = db.MEMBER_IN_NETWORK.getByNetwork(id)
-        let members = []
-        connections.forEach((conn) => {
-            members.push(this.getByID(conn.from))
-        })
-        return members
-    }
+  async getByID(id) {
+    const [member] = await sql`
+      SELECT * FROM members WHERE id = ${id}
+    `;
+    return member ?? null;
+  }
 
-    getByID(id) {
-        if(typeof id === 'string') {
-            id = id.split("-")[1]
-        }
-        return global.db.nodes[this.indices[0] + id - 1]
-    }
+  async getByEmail(email) {
+    const [member] = await sql`
+      SELECT * FROM members WHERE email = ${email}
+    `;
+    return member ?? null;
+  }
 
-    getByEmail(email) {
-        for(let i=this.indices[0]; i<this.indices[1]; i++) {
-            if(global.db.nodes[i].email === email) {
-                return global.db.nodes[i]
-            }
-        }
-        return null
-    }
+  async getByNetwork(networkId) {
+    return await sql`
+      SELECT m.* FROM members m
+      JOIN member_network mn ON mn.member_id = m.id
+      WHERE mn.network_id = ${networkId}
+    `;
+  }
+
+  async getPersonalData(id) {
+    const filePath = path.join(global.db.PERSONAL_DATA_PATH, id, "db.json");
+    const raw = await fs.promises.readFile(filePath, "utf8");
+    return raw.trim() ? JSON.parse(raw) : [];
+  }
 }