Backend endpoints

backend/eslint.config.js

@@ -1,34 +1,14 @@
-import js from '@eslint/js'
-import jest from 'eslint-plugin-jest'
-import globals from 'globals'
+import globals from "globals";
+import pluginJs from "@eslint/js";
 
+/** @type {import('eslint').Linter.Config[]} */
 export default [
-  { ignores: ['dist'] },
-  {
-    files: ['**/*.{js,ts}'],
-    languageOptions: {
-      ecmaVersion: 'latest',
-      globals: globals.node,
-      parserOptions: {
-        ecmaVersion: 'latest',
-        ecmaFeatures: { jsx: true },
-        sourceType: 'module',
-      },
-    },
-    rules: {
-      ...js.configs.recommended.rules,
-    },
-  },
-  {
-    files: ['**/__tests__/**/*.test.{js,ts}'],
-    plugins: {
-      jest,
-    },
-    languageOptions: {
-      globals: jest.environments.globals.globals
-    },
-    rules: {
-      ...jest.configs.recommended.rules,
-    }
-  }
-]
+    { languageOptions: { globals: { ...globals.node, ...globals.jest } } },
+    pluginJs.configs.recommended,
+    {
+        rules: {
+            camelcase: ["warn", { properties: "never", ignoreDestructuring: false }],
+            "max-len": ["warn", { code: 140 }],
+        },
+    },
+];

backend/index.js

@@ -1,8 +1,8 @@
 import cors from "cors";
 import dotenv from "dotenv";
 import express from "express";
-import authRoutes from "./src/routes/authRoutes.js";
-import logRoutes from "./src/routes/logRoutes.js";
+import authRoutes from "./src/routes/auth-route.js";
+import logRoutes from "./src/routes/logbooks-route.js";
 
 dotenv.config();
 
@@ -15,9 +15,8 @@ const PORT = process.env.PORT || 8080;
 app.use(cors(corsOptions));
 app.use(express.json());
 
-//Routes
 app.use('/api/auth', authRoutes);
-app.use('/api/log', logRoutes);
+app.use('/api/logbooks', logRoutes);
 
 app.listen(PORT, () => {
     console.log(`Server listening on ${PORT}`);

backend/package.json

@@ -6,7 +6,7 @@
   "scripts": {
     "build": "babel index.js -d dist",
     "dev": "nodemon server",
-    "lint": "eslint .",
+    "lint": "eslint",
     "start": "node index.js",
     "test": "jest"
   },

backend/src/middlewares/auth.js

@@ -16,15 +16,12 @@ const auth = async (req, res, next) => {
 			})
 			req.supabase = supabase;
 		} else {
-			console.error("No token: Authentication Denied");
 			return res.status(401).json({ message: "No token: Authentication Denied" });
 		}
 		next();
 	} catch (err) {
-		console.error("Invalid token, authentication denied:", err.message);
 		return res.status(400).json({ message: `Invalid token, authentication denied: ${err.message}`});
 	}
 };
 
-export default auth;
-
+export default auth;

backend/src/routes/authRoutes.js → backend/src/routes/auth-route.js

@@ -3,7 +3,6 @@ import auth from "../middlewares/auth.js";
 
 const router = express.Router();
 
-//auth test
 router.post("/check", auth, async (req, res) => {
     res.json({ message: "Auth Check Ok"});
 })

backend/src/routes/logbooks-route.js

@@ -0,0 +1,61 @@
+import express from "express";
+import auth from "../middlewares/auth.js";
+import { createLogbook, getUserLogbooks, getLogbook, createLog, getLogbookLogs, getLog } from "../services/logbooks-service.js";
+
+const router = express.Router();
+
+router.post("", auth, async (req, res) => {
+    const logbook = await createLogbook(req);
+    if (logbook.error) {
+        res.status(500).json({ error: logbook.error });
+    } else {
+        res.status(201).json({ data: logbook });
+    }
+});
+
+router.get("", auth, async (req, res) => {
+    const userLogbooks = await getUserLogbooks(req);
+    if (userLogbooks.error) {
+        res.status(500).json({ error: userLogbooks.error });
+    } else {
+        res.status(200).json({ data: userLogbooks });
+    }
+});
+
+router.get("/:logbookID", auth, async (req, res) => {
+    const logbook = await getLogbook(req);
+    if (logbook.error) {
+        res.status(500).json({ error: logbook.error });
+    } else {
+        res.status(200).json({ data: logbook });
+    }
+});
+
+router.post("/:logbookID/logs", auth, async (req, res) => {
+    const log = await createLog(req);
+    if (log.error) {
+        res.status(500).json({ error: log.error });
+    } else {
+        res.status(201).json({ data: log });
+    }
+});
+
+router.get("/:logbookID/logs", auth, async (req, res) => {
+    const logbookLogs = await getLogbookLogs(req);
+    if (logbookLogs.error) {
+        res.status(500).json({ error: logbookLogs.error });
+    } else {
+        res.status(200).json({ data: logbookLogs });
+    }
+});
+
+router.get("/:logbookID/logs/:logID", auth, async (req, res) => {
+    const log = await getLog(req);
+    if (log.error) {
+        res.status(500).json({ error: log.error });
+    } else {
+        res.status(200).json({ data: log });
+    }
+});
+
+export default router;

backend/src/routes/test/auth-route.test.js

@@ -0,0 +1,3 @@
+test("empty test", () => {
+    expect(true).toBe(true);
+});

backend/src/routes/test/logbooks-route.test.js

@@ -0,0 +1,3 @@
+test("empty test", () => {
+    expect(true).toBe(true);
+});

backend/src/services/logbooks-service.js

@@ -0,0 +1,58 @@
+import getLogbookType from "../utils/get-logbook-type.js";
+import getTable from "../utils/get-table.js";
+import insertTable from "../utils/insert-table.js";
+import parseUserID from "../utils/parse-user-id.js";
+
+export async function createLogbook(req) {
+    const supabase = req.supabase;
+    const body = req.body
+    return insertTable(supabase, "logbooks", body);
+}
+
+export async function getUserLogbooks(req) {
+    const supabase = req.supabase;
+    const token = req.header("Authorization")?.split(" ")[1];
+    const userID = parseUserID(token);
+    return getTable(supabase, "logbooks", "user_id", userID, "collection");
+}
+
+export async function getLogbook(req) {
+    const supabase = req.supabase;
+    const { logbookID } = req.params;
+    return getTable(supabase, "logbooks", "id", logbookID, "resource");
+}
+
+export async function createLog(req) {
+    try {
+        const supabase = req.supabase;
+        const { logbookID } = req.params;
+        let body = req.body
+        body['logbook_id'] = logbookID
+        const logbookType = await getLogbookType(logbookID, supabase);
+        if (body['type'] !== logbookType) {
+            throw new Error(`log type '${body['type']}' does not match logbook type '${logbookType}'`);
+        }
+        switch (body['type']) {
+            case "adult_cardiac_logs":
+                return insertTable(supabase, "adult_cardiac_logs", body) 
+            default:
+                throw new Error(`log and logbook type '${body['type']}' are invalid`);
+        }
+    } catch (error) {
+        return { error: error.message };
+    }
+}
+
+export async function getLogbookLogs(req) {
+    const supabase = req.supabase;
+    const { logbookID } = req.params;
+    const logbookType = await getLogbookType(logbookID, supabase);
+    return getTable(supabase, logbookType, "logbook_id", logbookID, "collection");
+}
+
+export async function getLog(req) {
+    const supabase = req.supabase;
+    const { logbookID, logID } = req.params;
+    const logbookType = await getLogbookType(logbookID, supabase);
+    return getTable(supabase, logbookType, "id", logID, "resource");
+}

backend/src/utils/get-logbook-type.js

@@ -0,0 +1,11 @@
+export default async function getLogbookType(logbookID, supabase) {
+    try {
+        const { data, error } = await supabase.from("logbooks").select().eq("id", logbookID);
+        if (error) {
+            throw new Error(error.message);
+        }
+        return data[0]['type'];
+    } catch (error) {
+        return { error: error.message };
+    }
+}

backend/src/utils/get-table.js

@@ -0,0 +1,22 @@
+export default async function getTable(supabase, table, param, value, type) {
+    try {
+        let data, error;
+        if (param == null && value == null) {
+            ({ data, error } = await supabase.from(table).select());
+        } else if (param !== null && value !== null) {
+            ({ data, error } = await supabase.from(table).select().eq(param, value));
+        } else {
+            throw new Error(`${param == null ? "param" : "value"} is empty at getTable`);
+        }
+        if (error) {
+            throw new Error(error.message);
+        }
+        if (type === "collection") {
+            return data
+        } else if (type === "resource") {
+            return data[0]
+        }
+    } catch (error) {
+        return { error: error.message };
+    }
+}

backend/src/utils/insert-table.js

@@ -0,0 +1,12 @@
+export default async function insertTable(supabase, table, values) {
+    try {
+        const { data, error } = await supabase.from(table).insert(values).select();
+        if (error) {
+            throw new Error(error.message);
+        } else {
+            return data[0];
+        }
+    } catch (error) {
+        return { error: error.message }; 
+    }
+}

backend/src/utils/parse-user-id.js

@@ -0,0 +1,9 @@
+export default function parseUserID(token) {
+    try {
+        const parts = token.split(".");
+        const decodedPayload = JSON.parse(atob(parts[1]));
+        return decodedPayload["sub"];
+    } catch (error) {
+        return { error: error.message };
+    }
+}