Use promises instead callbacks. Now server not crashed if send invalid

token.

Author: OsirisAnubiz

JavaScript/session.js

@@ -36,20 +36,17 @@ class Session extends Map {
     return session;
   }
 
-  static restore(client) {
+  static async restore(client) {
     const { cookie } = client;
     if (!cookie) return;
     const sessionToken = cookie.token;
     if (sessionToken) {
-      return new Promise((resolve, reject) => {
-        storage.get(sessionToken, (err, session) => {
-          if (err) reject(new Error('No session'));
-          Object.setPrototypeOf(session, Session.prototype);
-          client.token = sessionToken;
-          client.session = session;
-          resolve(session);
-        });
-      });
+      const session = await storage.get(sessionToken);
+      if (!session) return;
+      Object.setPrototypeOf(session, Session.prototype);
+      client.token = sessionToken;
+      client.session = session;
+      return session;
     }
   }
 

JavaScript/storage.js

@@ -1,63 +1,51 @@
 'use strict';
 
-const fs = require('node:fs');
+const fs = require('node:fs').promises;
 const path = require('node:path');
 const v8 = require('node:v8');
 
 const PATH = `${__dirname}/sessions`;
 
-const safePath = (fn) => (token, ...args) => {
-  const callback = args[args.length - 1];
-  if (typeof token !== 'string') {
-    callback(new Error('Invalid session token'));
-    return;
-  }
+const safePath = (promise) => (token, ...args) => {
+  if (typeof token !== 'string') throw new Error('Invalid session token');
   const fileName = path.join(PATH, token);
-  if (!fileName.startsWith(PATH)) {
-    callback(new Error('Invalid session token'));
-    return;
-  }
-  fn(fileName, ...args);
+  if (!fileName.startsWith(PATH)) throw new Error('Invalid session token');
+  return promise(fileName, ...args)
 };
 
 const readSession = safePath(fs.readFile);
 const writeSession = safePath(fs.writeFile);
 const deleteSession = safePath(fs.unlink);
 
 class Storage extends Map {
-  get(key, callback) {
+  async get(key) {
     const value = super.get(key);
-    if (value) {
-      callback(null, value);
-      return;
+    if (value) return value;
+    let data;
+    try {
+      data = await readSession(key);
+    } catch (err) {
+      return undefined;
     }
-    readSession(key, (err, data) => {
-      if (err) {
-        callback(err);
-        return;
-      }
-      console.log(`Session loaded: ${key}`);
-      const session = v8.deserialize(data);
-      super.set(key, session);
-      callback(null, session);
-    });
+    console.log('Session loaded: ${key}');
+    const session = v8.deserialize(data);
+    super.set(key, session);
+    return session;
   }
 
-  save(key) {
+  async save(key) {
     const value = super.get(key);
     if (value) {
       const data = v8.serialize(value);
-      writeSession(key, data, () => {
-        console.log(`Session saved: ${key}`);
-      });
+      await writeSession(key, data);
+      console.log(`Session saved: ${key}`);
     }
   }
 
-  delete(key) {
+  async delete(key) {
     console.log('Delete: ', key);
-    deleteSession(key, () => {
-      console.log(`Session deleted: ${key}`);
-    });
+    await deleteSession(key);
+    console.log(`Session deleted: ${key}`);
   }
 }