@social-mail/social-mail-web-server 1.8.414 → 1.8.416

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@social-mail/social-mail-web-server",
-  "version": "1.8.414",
+  "version": "1.8.416",
   "description": "## Phase 1",
   "main": "index.js",
   "type": "module",

package/src/server/services/UserAuthorizationService.ts

@@ -3,20 +3,15 @@ import AuthorizationService, { ICookie } from "@entity-access/server-pages/dist/
 import SocialMailContext from "../model/SocialMailContext.js";
 import Sql from "@entity-access/entity-access/dist/sql/Sql.js";
 import { SessionUser } from "@entity-access/server-pages/dist/core/SessionUser.js";
-import BaseDiskCache from "../../common/BaseDiskCache.js";
-import { join } from "path";
-import { globalEnv } from "../../common/globalEnv.js";
 import { IAuthorizationCookie } from "@entity-access/server-pages/dist/services/IAuthorizationCookie.js";
 import MessagingService from "./message-events/MessagingService.js";
+import TimedCache from "@entity-access/entity-access/dist/common/cache/TimedCache.js";
 
 @RegisterSingleton
 export default class UserAuthorizationService extends AuthorizationService {
 
-    diskCache = new BaseDiskCache({
-        root: join(globalEnv.cacheDir, globalEnv.serverID, "user-sessions"),
-        keepTTLSeconds: 60*60*1000,
-        maxAge: 24*60*60*1000
-    });
+    cache = new TimedCache(60000,90000);
+    userIDCache = new TimedCache(90000, 180000);
 
     @Inject
     ms: MessagingService;
@@ -29,32 +24,35 @@ export default class UserAuthorizationService extends AuthorizationService {
     }
 
     async loadUserSessionFromCookie(cookie: string, user: SessionUser) {
-        const keyPath = cookie.replaceAll(":", "-");
-        const info = await this.diskCache.getOrCreateJsonAsync(keyPath, async () => {
+        const info = await this.cache.getOrCreateAsync(cookie, async () => {
             const sessionID = await this.decode(cookie);
             return await this.loadSessionFromDb(sessionID);
         });
         user.sessionID = info.sessionID;
         if (!info.userID) {
             // delete cache. cache is invalid...
-            await this.diskCache.deleteAt(keyPath);
+            this.cache.delete(cookie);
             return;
         }
         user.userID = info.userID;
         user.roles = info.roles;
         user.expiry = info.expiry;
-        user.keyPath = keyPath;
+        user.keyPath = cookie;
         user.fileAccessList = info.fileAccessList;
         (user as any).isAuthorized = true;
-        await this.diskCache.getOrCreateJsonAsync<string>(user.userID.toString(36), () => Promise.resolve(keyPath));
+        this.userIDCache.getOrCreate(user.userID.toString(36), cookie, (c) => c);
     }
 
     async setAuthCookie(user: SessionUser, authCookie: IAuthorizationCookie): Promise<ICookie> {
         if (authCookie === null) {
+            const { userID } = user;
+            if (userID) {
+                this.ms.removeUserLoginSessions.notify({ userID });
+            }
             // delete key path...
             if (user.keyPath) {
-                await this.diskCache.deleteAt(user.keyPath);
-                await this.diskCache.deleteAt(user.userID.toString(36));
+                this.cache.delete(user.keyPath);
+                this.userIDCache.delete(user.userID.toString(36));
             }
         }
         return super.setAuthCookie(user, authCookie);
@@ -98,17 +96,17 @@ export default class UserAuthorizationService extends AuthorizationService {
     private async clearLogin(userID) {
         try {
             const userKey = userID.toString(36);
-            const keyPath = await this.diskCache.getOrCreateJsonAsync<string>(userKey, () => Promise.reject(new Error("not found")));
+            const keyPath = await this.userIDCache.getOrCreate(userKey, null, (c) => c);
             if (keyPath) {
-                await this.diskCache.deleteAt(keyPath);
+                this.cache.delete(keyPath);
             }
-            await this.diskCache.deleteAt(userKey);
+            this.userIDCache.delete(userKey);
         } catch (error) {
             // ignore this error...
             if (error?.message === "not found") {
                 return;
             }
-            console.error(error);
+            console.warn(error);
         }
     }