added dashboard with security

Author: Alex Prosser

deno.json

@@ -1,14 +1,17 @@
 {
     "tasks": {
-        "dev": "deno run --allow-read --allow-net server.ts"
+        "run": "deno run -A --env-file --unstable-ffi server.ts"
     },
     "imports": {
         "@b-fuze/deno-dom": "jsr:@b-fuze/deno-dom@^0.1.48",
         "@codingap/steve": "jsr:@codingap/steve@^2.0.10",
+        "@db/sqlite": "jsr:@db/sqlite@^0.12.0",
         "@libs/markdown": "jsr:@libs/markdown@^2.0.2",
+        "@std/crypto": "jsr:@std/crypto@^1.0.3",
+        "@std/encoding": "jsr:@std/encoding@^1.0.6",
         "@std/fs": "jsr:@std/fs@^1.0.6",
         "@std/html": "jsr:@std/html@^1.0.3",
-        "@std/media-types": "jsr:@std/media-types@^1.1.0",
+        "@std/http": "jsr:@std/http@^1.0.12",
         "@std/path": "jsr:@std/path@^1.0.8"
     },
     "lint": {

deno.lock

@@ -1,93 +1,28 @@
-
-import { walkSync } from '@std/fs';
-import { contentType } from '@std/media-types';
-import { extname } from "@std/path";
+import { route, type Route } from "@std/http/unstable-route";
+import { serveDir } from '@std/http/file-server';
 import { STEVE } from '@codingap/steve';
-import { Handler } from "./src/types.ts";
 import { getNotFoundResponse } from "./src/middleware.ts";
 
 const PORT = 1337;
 
 STEVE.includeDirectory = './views/includes';
 
-// read in static files
-const staticDirectory = 'static';
-const STATIC_CONTENT: { [key: string]: Uint8Array } = {};
-Array.from(walkSync(staticDirectory)).filter(file => file.isFile).forEach(file => STATIC_CONTENT[file.path] = Deno.readFileSync(file.path));
-
 // routing time
-
-// ~~~ this should be the only part you need to modify
 import MAIN_ROUTES from './src/routes.ts';
 import API_ROUTES from './src/api.ts';
 
-const routers = [{ router: MAIN_ROUTES, startingPath: '' }, { router: API_ROUTES, startingPath: '/api' }];
-// ~~~ end modification ~~~
-
-// combine all routers together
-
-const ROUTES: { [key: string]: { match: (path: string) => { match: boolean, url: { [key: string]: string }}, handler: Handler }[] } = {};
-routers.forEach(({ router, startingPath }) => {
-    Object.keys(router).forEach(method => {
-        if (ROUTES[method] === undefined) ROUTES[method] = [];
-        Object.keys(router[method]).forEach(route => {
-            const routeParts = (startingPath + route).split('/').filter(part => part.length > 0);
-
-            ROUTES[method].push({
-                match: (path) => {
-                    const pathParts = path.split('/').filter(part => part.length > 0);
-                    if (pathParts.length !== routeParts.length) return { match: false, url: {} };
-
-                    let match = true;
-                    const url: { [key: string]: string } = {};
-
-                    for (let i = 0; i < pathParts.length; i++) {
-                        // parse url parameter if needed
-                        if (routeParts[i][0] === ':') url[routeParts[i].slice(1)] = pathParts[i];
-                        else if (routeParts[i] !== pathParts[i]) {
-                            match = false;
-                            break;
-                        }
-                    }
-
-                    return { match, url };
-                },
-                handler: router[method][route]
-            });
-        });
-    });
-});
+const routers: Route[] = [
+    ...MAIN_ROUTES,
+    ...API_ROUTES,
+    {
+        pattern: new URLPattern({ pathname: '/static/*' }),
+        handler: (request) => serveDir(request, { quiet: true })
+    }
+];
 
 Deno.serve({
     port: PORT,
-    handler: async (request) => {
-        // handle static files
-        const url = new URL(request.url);
-        const path = url.pathname.slice(1);
-        if (path.startsWith(staticDirectory)) {
-            const mimeType = contentType(extname(path)) || 'text/plaintext';
-            if (STATIC_CONTENT[path] !== undefined) {
-                return new Response(STATIC_CONTENT[path], {
-                    status: 200,
-                    headers: {
-                        'Content-Type': mimeType
-                    }
-                });
-            } else return getNotFoundResponse();
-        }
-
-        // try getting routes
-        const method = request.method.toUpperCase(); 
-        if (ROUTES[method] !== undefined) {
-            for (const route of ROUTES[method]) {
-                const { match, url } = route.match(path);
-                if (match) return await route.handler(request, url);
-            }
-        }
-
-        // else, return not found
-        return getNotFoundResponse();
-    },
+    handler: route(routers, getNotFoundResponse),
     onListen: () => {
         console.log(`https://codingap.dev is listening on port ${PORT} (http://localhost:${PORT})`);
     }

server.ts

@@ -1,5 +1,44 @@
-import { Router } from './types.ts';
+import { type Route } from '@std/http/unstable-route';
+import { setCookie } from '@std/http/cookie';
+import { crypto } from '@std/crypto';
+import { encodeHex } from '@std/encoding/hex';
+import { authenticated, encrypt } from './middleware.ts';
+import { LoginRequestBody } from './types.ts';
 
-const ROUTES: Router = {};
+const defaultHeaders = new Headers();
+defaultHeaders.append('Content-Type', 'application/json');
+
+const ROUTES: Route[] = [
+    {
+        method: ['POST'],
+        pattern: new URLPattern({ pathname: '/api/cms/login' }),
+        handler: async (request) => {
+            if (request.headers.get('Content-Type') === 'application/json') {
+                const body = (await request.json()) as LoginRequestBody;
+    
+                // check to see if logged in
+                if (body.check && await authenticated(request)) {
+                    return new Response(JSON.stringify({ message: 'Already Logged In!', error: false }), { status: 200, headers: defaultHeaders });
+                }
+    
+                // encrypted session token and send to client
+                const passwordBuffer = new TextEncoder().encode(body.password + Deno.env.get('SALT'));
+                const hashBuffer = await crypto.subtle.digest('SHA-256', passwordBuffer);
+                if (Deno.env.get('HASH') === encodeHex(hashBuffer)) {
+                    const cookie = await encrypt(JSON.stringify({ loggedIn: new Date().toISOString(), id: 'codingap' }));
+                    const headers = new Headers();
+                    headers.append('Content-Type', 'application/json');
+                    setCookie(headers, { name: 'session', value: cookie, path: '/', sameSite: 'Lax' });
+    
+                    return new Response(JSON.stringify({ message: 'Success!', error: false }), { status: 200, headers });
+                } else {
+                    return new Response(JSON.stringify({ message: 'Incorrect password!', error: true }), { status: 400, headers: defaultHeaders });
+                }
+            }
+    
+            return new Response(JSON.stringify({ message: 'Failed to login!', error: true }), { status: 400, headers: defaultHeaders });
+        }
+    },
+];
 
 export default ROUTES;