prostgles-server 4.2.183 → 4.2.185

package/lib/Auth/setupAuthRoutes.ts

@@ -1,12 +1,25 @@
 import { RequestHandler } from "express";
 import { DBOFullyTyped } from "../DBSchemaBuilder";
-import { AUTH_ROUTES_AND_PARAMS, AuthHandler, getLoginClientInfo, HTTPCODES } from "./AuthHandler";
-import { AuthClientRequest, ExpressReq, ExpressRes, LoginParams } from "./AuthTypes";
-import { setAuthProviders, upsertNamedExpressMiddleware } from "./setAuthProviders";
+import {
+  AUTH_ROUTES_AND_PARAMS,
+  AuthHandler,
+  getLoginClientInfo,
+  HTTPCODES,
+} from "./AuthHandler";
+import {
+  AuthClientRequest,
+  ExpressReq,
+  ExpressRes,
+  LoginParams,
+} from "./AuthTypes";
+import {
+  setAuthProviders,
+  upsertNamedExpressMiddleware,
+} from "./setAuthProviders";
 
 export async function setupAuthRoutes(this: AuthHandler) {
   if (!this.opts) return;
- 
+
   const { login, getUser, expressConfig } = this.opts;
 
   if (!login) {
@@ -20,27 +33,37 @@ export async function setupAuthRoutes(this: AuthHandler) {
   if (!getUser) throw "getUser missing from auth config";
 
   if (!expressConfig) {
-    return 
+    return;
   }
-  const { app, publicRoutes = [], onGetRequestOK, magicLinks, use } = expressConfig;
-  if (publicRoutes.find(r => typeof r !== "string" || !r)) {
-    throw "Invalid or empty string provided within publicRoutes "
+  const {
+    app,
+    publicRoutes = [],
+    onGetRequestOK,
+    magicLinks,
+    use,
+  } = expressConfig;
+  if (publicRoutes.find((r) => typeof r !== "string" || !r)) {
+    throw "Invalid or empty string provided within publicRoutes ";
   }
 
   await setAuthProviders.bind(this)(expressConfig);
 
-  if(use){
+  if (use) {
     const prostglesUseMiddleware: RequestHandler = (req, res, next) => {
-      use({ 
-        req, 
-        res, 
-        next, 
+      use({
+        req,
+        res,
+        next,
         getUser: () => this.getUser({ httpReq: req }) as any,
-        dbo: this.dbo as DBOFullyTyped, 
+        dbo: this.dbo as DBOFullyTyped,
         db: this.db,
-      })
+      });
     };
-    upsertNamedExpressMiddleware(app, prostglesUseMiddleware, "prostglesUseMiddleware");
+    upsertNamedExpressMiddleware(
+      app,
+      prostglesUseMiddleware,
+      "prostglesUseMiddleware",
+    );
   }
 
   if (magicLinks) {
@@ -49,111 +72,152 @@ export async function setupAuthRoutes(this: AuthHandler) {
       throw "Check must be defined for magicLinks";
     }
 
-    app.get(AUTH_ROUTES_AND_PARAMS.magicLinksExpressRoute, async (req: ExpressReq, res: ExpressRes) => {
-      const { id } = req.params ?? {};
-
-      if (typeof id !== "string" || !id) {
-        res.status(HTTPCODES.BAD_REQUEST).json({ msg: "Invalid magic-link id. Expecting a string" });
-      } else {
-        try {
-          const session = await this.throttledFunc(async () => {
-            return check(id, this.dbo as any, this.db, getLoginClientInfo({ httpReq: req }));
-          });
-          if(!session) {
-            res.status(HTTPCODES.AUTH_ERROR).json({ error: "Invalid magic-link" });
-          } else {
-            this.setCookieAndGoToReturnURLIFSet(session, { req, res });
+    app.get(
+      AUTH_ROUTES_AND_PARAMS.magicLinksExpressRoute,
+      async (req: ExpressReq, res: ExpressRes) => {
+        const { id } = req.params ?? {};
+
+        if (typeof id !== "string" || !id) {
+          res
+            .status(HTTPCODES.BAD_REQUEST)
+            .json({ msg: "Invalid magic-link id. Expecting a string" });
+        } else {
+          try {
+            const session = await this.throttledFunc(async () => {
+              return check(
+                id,
+                this.dbo as any,
+                this.db,
+                getLoginClientInfo({ httpReq: req }),
+              );
+            });
+            if (!session) {
+              res
+                .status(HTTPCODES.AUTH_ERROR)
+                .json({ error: "Invalid magic-link" });
+            } else {
+              this.setCookieAndGoToReturnURLIFSet(session, { req, res });
+            }
+          } catch (e) {
+            res.status(HTTPCODES.AUTH_ERROR).json({ error: e });
           }
-
-        } catch (e) {
-          res.status(HTTPCODES.AUTH_ERROR).json({ error: e });
         }
-      }
-    });
+      },
+    );
   }
 
-  app.post(AUTH_ROUTES_AND_PARAMS.login, async (req: ExpressReq, res: ExpressRes) => {
-    try {
-      const loginParams: LoginParams = {
-        type: "username",
-        ...req.body,
-      };
-
-      await this.loginThrottledAndSetCookie(req, res, loginParams);
-    } catch (error) {
-      res.status(HTTPCODES.AUTH_ERROR).json({ error });
-    }
-  });
+  app.post(
+    AUTH_ROUTES_AND_PARAMS.login,
+    async (req: ExpressReq, res: ExpressRes) => {
+      try {
+        const loginParams: LoginParams = {
+          type: "username",
+          ...req.body,
+        };
+
+        await this.loginThrottledAndSetCookie(req, res, loginParams);
+      } catch (error) {
+        res.status(HTTPCODES.AUTH_ERROR).json({ error });
+      }
+    },
+  );
 
   const onLogout = async (req: ExpressReq, res: ExpressRes) => {
     const sid = this.validateSid(req?.cookies?.[this.sidKeyName]);
     if (sid) {
       try {
         await this.throttledFunc(() => {
-          return this.opts?.logout?.(req?.cookies?.[this.sidKeyName], this.dbo as any, this.db);
-        })
+          return this.opts?.logout?.(
+            req?.cookies?.[this.sidKeyName],
+            this.dbo as any,
+            this.db,
+          );
+        });
       } catch (err) {
         console.error(err);
       }
     }
-    res.redirect("/")
-  }
-  
+    res.redirect("/");
+  };
+
   /* Redirect if not logged in and requesting non public content */
-  app.get(AUTH_ROUTES_AND_PARAMS.catchAll, async (req: ExpressReq, res: ExpressRes, next) => {
-
-    const clientReq: AuthClientRequest = { httpReq: req };
-    const getUser = this.getUser;
-    if(this.prostgles.restApi){
-      if(Object.values(this.prostgles.restApi.routes).some(restRoute => this.matchesRoute(restRoute.split("/:")[0], req.path))){
-        next();
-        return;
-      }
-    }
-    try {
-      const returnURL = this.getReturnUrl(req);
-      
-      if(this.matchesRoute(AUTH_ROUTES_AND_PARAMS.logoutGetPath, req.path)){
-        await onLogout(req, res);
-        return;
+  app.get(
+    AUTH_ROUTES_AND_PARAMS.catchAll,
+    async (req: ExpressReq, res: ExpressRes, next) => {
+      const clientReq: AuthClientRequest = { httpReq: req };
+      const getUser = this.getUser;
+      if (this.prostgles.restApi) {
+        if (
+          Object.values(this.prostgles.restApi.routes).some((restRoute) =>
+            this.matchesRoute(restRoute.split("/:")[0], req.path),
+          )
+        ) {
+          next();
+          return;
+        }
       }
+      try {
+        const returnURL = this.getReturnUrl(req);
 
-      if(this.matchesRoute(AUTH_ROUTES_AND_PARAMS.loginWithProvider, req.path)){
-        next();
-        return;
-      }
-      /**
-       * Requesting a User route
-       */
-      if (this.isUserRoute(req.path)) {
-
-        /* Check auth. Redirect to login if unauthorized */
-        const u = await getUser(clientReq);
-        if (!u) {
-          res.redirect(`${AUTH_ROUTES_AND_PARAMS.login}?returnURL=${encodeURIComponent(req.originalUrl)}`);
+        if (this.matchesRoute(AUTH_ROUTES_AND_PARAMS.logoutGetPath, req.path)) {
+          await onLogout(req, res);
           return;
         }
 
-        /* If authorized and going to returnUrl then redirect. Otherwise serve file */
-      } else if (returnURL && (await getUser(clientReq))) {
+        if (
+          this.matchesRoute(AUTH_ROUTES_AND_PARAMS.loginWithProvider, req.path)
+        ) {
+          next();
+          return;
+        }
+        /**
+         * Requesting a User route
+         */
+        if (this.isUserRoute(req.path)) {
+          /* Check auth. Redirect to login if unauthorized */
+          const u = await getUser(clientReq);
+          if (!u) {
+            res.redirect(
+              `${AUTH_ROUTES_AND_PARAMS.login}?returnURL=${encodeURIComponent(req.originalUrl)}`,
+            );
+            return;
+          }
 
-        res.redirect(returnURL);
-        return;
+          /* If authorized and going to returnUrl then redirect. Otherwise serve file */
+        } else if (returnURL && (await getUser(clientReq))) {
+          res.redirect(returnURL);
+          return;
 
-        /** If Logged in and requesting login then redirect to main page */
-      } else if (this.matchesRoute(AUTH_ROUTES_AND_PARAMS.login, req.path) && (await getUser(clientReq))) {
+          /** If Logged in and requesting login then redirect to main page */
+        } else if (
+          this.matchesRoute(AUTH_ROUTES_AND_PARAMS.login, req.path) &&
+          (await getUser(clientReq))
+        ) {
+          res.redirect("/");
+          return;
+        }
 
-        res.redirect("/");
-        return;
+        onGetRequestOK?.(req, res, {
+          getUser: () => getUser(clientReq),
+          dbo: this.dbo as DBOFullyTyped,
+          db: this.db,
+        });
+      } catch (error) {
+        console.error(error);
+        const errorMessage =
+          typeof error === "string"
+            ? error
+            : error instanceof Error
+              ? error.message
+              : "";
+        res
+          .status(HTTPCODES.AUTH_ERROR)
+          .json({
+            error:
+              "Something went wrong when processing your request" +
+              (errorMessage ? ": " + errorMessage : ""),
+          });
       }
-
-      onGetRequestOK?.(req, res, { getUser: () => getUser(clientReq), dbo: this.dbo as DBOFullyTyped, db: this.db })
-
-    } catch (error) {
-      console.error(error);
-      const errorMessage = typeof error === "string" ? error : error instanceof Error ? error.message : "";
-      res.status(HTTPCODES.AUTH_ERROR).json({ error: "Something went wrong when processing your request" + (errorMessage? (": " + errorMessage) : "") });
-    }
-
-  });
-}
+    },
+  );
+}

package/lib/DBEventsManager.ts

@@ -1,17 +1,19 @@
-import { PostgresNotifListenManager, PrglNotifListener } from "./PostgresNotifListenManager";
+import {
+  PostgresNotifListenManager,
+  PrglNotifListener,
+} from "./PostgresNotifListenManager";
 import { DB, PGP } from "./Prostgles";
 import { getKeys, CHANNELS } from "prostgles-types";
 import { PRGLIOSocket } from "./DboBuilder/DboBuilder";
 
 export class DBEventsManager {
-
-  notifies: { 
+  notifies: {
     [key: string]: {
       socketChannel: string;
-      sockets: any[]; 
+      sockets: any[];
       localFuncs: ((payload: string) => void)[];
       notifMgr: PostgresNotifListenManager;
-    } 
+    };
   } = {};
 
   notice: {
@@ -21,73 +23,82 @@ export class DBEventsManager {
   } = {
     socketChannel: CHANNELS.NOTICE_EV,
     socketUnsubChannel: CHANNELS.NOTICE_EV + "unsubscribe",
-    sockets: []
+    sockets: [],
   };
 
   notifManager?: PostgresNotifListenManager;
 
   db_pg: DB;
-  pgp: PGP
-  constructor(db_pg: DB, pgp: PGP){
+  pgp: PGP;
+  constructor(db_pg: DB, pgp: PGP) {
     this.db_pg = db_pg;
     this.pgp = pgp;
   }
 
   private onNotif: PrglNotifListener = ({ channel, payload }) => {
-
     // console.log(36, { channel, payload },  Object.keys(this.notifies));
 
     getKeys(this.notifies)
-      .filter(ch => ch === channel)
-      .map(ch => {
+      .filter((ch) => ch === channel)
+      .map((ch) => {
         const sub = this.notifies[ch]!;
-        
-        sub.sockets.map(s => {
-          s.emit(sub.socketChannel, payload)
+
+        sub.sockets.map((s) => {
+          s.emit(sub.socketChannel, payload);
         });
-        sub.localFuncs.map(lf => {
+        sub.localFuncs.map((lf) => {
           lf(payload);
-        })
+        });
       });
-  }
+  };
 
   onNotice = (notice: any) => {
-    if(this.notice && this.notice.sockets.length){
-      this.notice.sockets.map(s => {
+    if (this.notice && this.notice.sockets.length) {
+      this.notice.sockets.map((s) => {
         s.emit(this.notice.socketChannel, notice);
-      })
+      });
     }
-  }
+  };
 
   getNotifChannelName = async (channel: string) => {
     const c = await this.db_pg.one("SELECT quote_ident($1) as c", channel);
     return c.c;
-  }
+  };
 
-  async addNotify(query: string, socket?: PRGLIOSocket, func?: any): Promise<{
+  async addNotify(
+    query: string,
+    socket?: PRGLIOSocket,
+    func?: any,
+  ): Promise<{
     socketChannel: string;
     socketUnsubChannel: string;
     notifChannel: string;
     unsubscribe?: () => void;
   }> {
-    if(typeof query !== "string" || (!socket && !func)){
-      throw "Expecting (query: string, socket?, localFunc?) But received: " + JSON.stringify({ query, socket, func });
+    if (typeof query !== "string" || (!socket && !func)) {
+      throw (
+        "Expecting (query: string, socket?, localFunc?) But received: " +
+        JSON.stringify({ query, socket, func })
+      );
     }
 
     /* Remove comments */
-    let q = query.trim()
-      .replace(/\/\*[\s\S]*?\*\/|\/\/.*/g,'\n')
-      .split("\n").map(v => v.trim()).filter(v => v && !v.startsWith("--"))
+    let q = query
+      .trim()
+      .replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "\n")
+      .split("\n")
+      .map((v) => v.trim())
+      .filter((v) => v && !v.startsWith("--"))
       .join("\n");
 
     /* Find the notify channel name */
-    if(!q.toLowerCase().startsWith("listen")){
+    if (!q.toLowerCase().startsWith("listen")) {
       throw "Expecting a LISTEN query but got: " + query;
     }
     q = q.slice(7).trim(); // Remove listen
-    if(q.endsWith(";")) q = q.slice(0, -1);
+    if (q.endsWith(";")) q = q.slice(0, -1);
 
-    if(q.startsWith('"') && q.endsWith('"')) {
+    if (q.startsWith('"') && q.endsWith('"')) {
       q = q.slice(1, -1);
     } else {
       /* Replicate PG by lowercasing identifier if not quoted */
@@ -95,35 +106,40 @@ export class DBEventsManager {
     }
     q = q.replace(/""/g, `"`);
 
-    const channel = q;    
-    let notifChannel = await this.getNotifChannelName(channel)
+    const channel = q;
+    let notifChannel = await this.getNotifChannelName(channel);
 
     notifChannel = notifChannel.replace(/""/g, `"`);
-    if(notifChannel.startsWith('"')) notifChannel = notifChannel.slice(1, -1);
+    if (notifChannel.startsWith('"')) notifChannel = notifChannel.slice(1, -1);
 
     const socketChannel = CHANNELS.LISTEN_EV + notifChannel,
       socketUnsubChannel = socketChannel + "unsubscribe";
 
-    if(!this.notifies[notifChannel]){
+    if (!this.notifies[notifChannel]) {
       this.notifies[notifChannel] = {
         socketChannel,
-        sockets: socket? [socket] : [],
-        localFuncs: func? [func] : [],
-        notifMgr: await PostgresNotifListenManager.create(this.db_pg, this.onNotif, channel)
-      }
-
+        sockets: socket ? [socket] : [],
+        localFuncs: func ? [func] : [],
+        notifMgr: await PostgresNotifListenManager.create(
+          this.db_pg,
+          this.onNotif,
+          channel,
+        ),
+      };
     } else {
-      if(socket && !this.notifies[notifChannel]!.sockets.find(s => s.id === socket.id)) {
+      if (
+        socket &&
+        !this.notifies[notifChannel]!.sockets.find((s) => s.id === socket.id)
+      ) {
         this.notifies[notifChannel]!.sockets.push(socket);
-
-      } else if(func) {
+      } else if (func) {
         this.notifies[notifChannel]!.localFuncs.push(func);
       }
     }
 
-    if(socket){
+    if (socket) {
       socket.removeAllListeners(socketUnsubChannel);
-      socket.on(socketUnsubChannel, ()=>{
+      socket.on(socketUnsubChannel, () => {
         this.removeNotify(notifChannel, socket);
       });
     }
@@ -132,32 +148,38 @@ export class DBEventsManager {
       socketChannel,
       socketUnsubChannel,
       notifChannel,
-    }
+    };
   }
 
-  removeNotify(channel?: string, socket?: PRGLIOSocket, func?: any){
-    const notifChannel = channel && this.notifies[channel]
-    if(notifChannel){
-      if(socket){
-        notifChannel.sockets = notifChannel.sockets.filter(s => s.id !== socket.id);
-      } else if(func){
-        notifChannel.localFuncs = notifChannel.localFuncs.filter(f => f !== func);
+  removeNotify(channel?: string, socket?: PRGLIOSocket, func?: any) {
+    const notifChannel = channel && this.notifies[channel];
+    if (notifChannel) {
+      if (socket) {
+        notifChannel.sockets = notifChannel.sockets.filter(
+          (s) => s.id !== socket.id,
+        );
+      } else if (func) {
+        notifChannel.localFuncs = notifChannel.localFuncs.filter(
+          (f) => f !== func,
+        );
       }
 
       /* UNLISTEN if no listeners ?? */
     }
 
-    if(socket){
-      getKeys(this.notifies).forEach(channel => {
-        this.notifies[channel]!.sockets = this.notifies[channel]!.sockets.filter(s => s.id !== socket.id);
-      })
+    if (socket) {
+      getKeys(this.notifies).forEach((channel) => {
+        this.notifies[channel]!.sockets = this.notifies[
+          channel
+        ]!.sockets.filter((s) => s.id !== socket.id);
+      });
     }
   }
 
-  addNotice(socket: PRGLIOSocket){
-    if(!socket || !socket.id) throw "Expecting a socket obj with id";
+  addNotice(socket: PRGLIOSocket) {
+    if (!socket || !socket.id) throw "Expecting a socket obj with id";
 
-    if(!this.notice.sockets.find(s => s.id === socket.id)){
+    if (!this.notice.sockets.find((s) => s.id === socket.id)) {
       this.notice.sockets.push(socket);
     }
 
@@ -168,11 +190,11 @@ export class DBEventsManager {
       this.removeNotice(socket);
     });
 
-    return { socketChannel, socketUnsubChannel, }
+    return { socketChannel, socketUnsubChannel };
   }
 
-  removeNotice(socket: PRGLIOSocket){
-    if(!socket || !socket.id) throw "Expecting a socket obj with id";
-    this.notice.sockets = this.notice.sockets.filter(s => s.id !== socket.id)
+  removeNotice(socket: PRGLIOSocket) {
+    if (!socket || !socket.id) throw "Expecting a socket obj with id";
+    this.notice.sockets = this.notice.sockets.filter((s) => s.id !== socket.id);
   }
-}
+}