prostgles-server 4.2.187 → 4.2.189

package/lib/Auth/setupAuthRoutes.ts

@@ -1,26 +1,13 @@
-import { RequestHandler } from "express";
+import { RequestHandler, Response } from "express";
+import { AuthResponse } from "prostgles-types";
 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, HTTP_FAIL_CODES } from "./AuthHandler";
+import { AuthClientRequest, ExpressReq, ExpressRes, LoginParams } from "./AuthTypes";
+import { setAuthProviders, upsertNamedExpressMiddleware } from "./setAuthProviders";
+import { getClientRequestIPsInfo } from "./utils/getClientRequestIPsInfo";
+import { getReturnUrl } from "./utils/getReturnUrl";
 export async function setupAuthRoutes(this: AuthHandler) {
-  if (!this.opts) return;
-
-  const { login, getUser, expressConfig } = this.opts;
+  const { login, expressConfig } = this.opts;
 
   if (!login) {
     throw "Invalid auth: Provide { sidKeyName: string } ";
@@ -30,18 +17,10 @@ export async function setupAuthRoutes(this: AuthHandler) {
     throw "sidKeyName cannot be 'sid' due to collision with socket.io";
   }
 
-  if (!getUser) throw "getUser missing from auth config";
-
   if (!expressConfig) {
     return;
   }
-  const {
-    app,
-    publicRoutes = [],
-    onGetRequestOK,
-    magicLinks,
-    use,
-  } = expressConfig;
+  const { app, publicRoutes = [], onGetRequestOK, onMagicLink, use } = expressConfig;
   if (publicRoutes.find((r) => typeof r !== "string" || !r)) {
     throw "Invalid or empty string provided within publicRoutes ";
   }
@@ -59,79 +38,66 @@ export async function setupAuthRoutes(this: AuthHandler) {
         db: this.db,
       });
     };
-    upsertNamedExpressMiddleware(
-      app,
-      prostglesUseMiddleware,
-      "prostglesUseMiddleware",
-    );
+    upsertNamedExpressMiddleware(app, prostglesUseMiddleware, "prostglesUseMiddleware");
   }
 
-  if (magicLinks) {
-    const { check } = magicLinks;
-    if (!check) {
-      throw "Check must be defined for magicLinks";
-    }
-
+  if (onMagicLink) {
     app.get(
       AUTH_ROUTES_AND_PARAMS.magicLinksExpressRoute,
-      async (req: ExpressReq, res: ExpressRes) => {
-        const { id } = req.params ?? {};
+      async (
+        req: ExpressReq,
+        res: Response<AuthResponse.MagicLinkAuthFailure | AuthResponse.MagicLinkAuthSuccess>
+      ) => {
+        const { id } = req.params;
 
         if (typeof id !== "string" || !id) {
           res
-            .status(HTTPCODES.BAD_REQUEST)
-            .json({ msg: "Invalid magic-link id. Expecting a string" });
+            .status(HTTP_FAIL_CODES.BAD_REQUEST)
+            .json({ success: false, code: "something-went-wrong", message: "Invalid magic link" });
         } else {
           try {
-            const session = await this.throttledFunc(async () => {
-              return check(
+            const response = await this.throttledFunc(async () => {
+              return onMagicLink(
                 id,
                 this.dbo as any,
                 this.db,
-                getLoginClientInfo({ httpReq: req }),
+                getClientRequestIPsInfo({ httpReq: req })
               );
             });
-            if (!session) {
-              res
-                .status(HTTPCODES.AUTH_ERROR)
-                .json({ error: "Invalid magic-link" });
+            if (!response.session) {
+              res.status(HTTP_FAIL_CODES.UNAUTHORIZED).json(response.response);
             } else {
-              this.setCookieAndGoToReturnURLIFSet(session, { req, res });
+              this.setCookieAndGoToReturnURLIFSet(response.session, { req, res });
             }
           } catch (e) {
-            res.status(HTTPCODES.AUTH_ERROR).json({ error: e });
+            res
+              .status(HTTP_FAIL_CODES.UNAUTHORIZED)
+              .json({ success: false, code: "something-went-wrong" });
           }
         }
-      },
+      }
     );
   }
 
-  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(HTTP_FAIL_CODES.BAD_REQUEST).json({ error });
+    }
+  });
 
   const onLogout = async (req: ExpressReq, res: ExpressRes) => {
-    const sid = this.validateSid(req?.cookies?.[this.sidKeyName]);
+    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);
@@ -141,83 +107,74 @@ export async function setupAuthRoutes(this: AuthHandler) {
   };
 
   /* 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;
-        }
+  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;
-        }
-
-        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;
-          }
+    }
+    try {
+      const returnURL = getReturnUrl(req);
 
-          /* If authorized and going to returnUrl then redirect. Otherwise serve file */
-        } else if (returnURL && (await getUser(clientReq))) {
-          res.redirect(returnURL);
-          return;
+      if (this.matchesRoute(AUTH_ROUTES_AND_PARAMS.logoutGetPath, req.path)) {
+        await onLogout(req, res);
+        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))
-        ) {
-          res.redirect("/");
+      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;
         }
 
-        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 : ""),
-          });
+        /* 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))
+      ) {
+        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(HTTP_FAIL_CODES.UNAUTHORIZED).json({
+        error:
+          "Something went wrong when processing your request" +
+          (errorMessage ? ": " + errorMessage : ""),
+      });
+    }
+  });
 }

package/lib/Auth/utils/checkDmarc.ts

@@ -0,0 +1,19 @@
+import { promises } from "node:dns";
+
+export const checkDmarc = async (websiteUrl: string) => {
+  const { host, hostname } = new URL(websiteUrl);
+  const ignoredHosts = ["localhost", "127.0.0.1"];
+  if (!hostname || ignoredHosts.includes(hostname)) {
+    return;
+  }
+  const dmarc = await promises.resolveTxt(`_dmarc.${host}`);
+  const dmarkTxt = dmarc[0]?.[0];
+  if (
+    !dmarkTxt?.includes("v=DMARC1") ||
+    (!dmarkTxt.includes("p=reject") && !dmarkTxt.includes("p=quarantine"))
+  ) {
+    throw new Error("DMARC not set to reject/quarantine");
+  } else {
+    console.log("DMARC set to reject");
+  }
+};

package/lib/Auth/utils/getClientRequestIPsInfo.ts

@@ -0,0 +1,25 @@
+import { AuthClientRequest, LoginClientInfo } from "../AuthTypes";
+export const getClientRequestIPsInfo = <T extends AuthClientRequest>(
+  req: T
+): T & LoginClientInfo => {
+  if (req.httpReq) {
+    const ip_address = req.httpReq.ip;
+    if (!ip_address) throw new Error("ip_address missing from req.httpReq");
+    const user_agent = req.httpReq.headers["user-agent"];
+    return {
+      ...req,
+      ip_address,
+      ip_address_remote: req.httpReq.connection.remoteAddress,
+      x_real_ip: req.httpReq.headers["x-real-ip"] as any,
+      user_agent,
+    };
+  } else {
+    return {
+      ...req,
+      ip_address: req.socket.handshake.address,
+      ip_address_remote: req.socket.request.connection.remoteAddress,
+      x_real_ip: req.socket.handshake.headers?.["x-real-ip"],
+      user_agent: req.socket.handshake.headers?.["user-agent"],
+    };
+  }
+};

package/lib/Auth/utils/getReturnUrl.ts

@@ -0,0 +1,13 @@
+import { AUTH_ROUTES_AND_PARAMS } from "../AuthHandler";
+import { ExpressReq } from "../AuthTypes";
+import { getSafeReturnURL } from "./getSafeReturnURL";
+
+export const getReturnUrl = (req: ExpressReq) => {
+  const { returnUrlParamName } = AUTH_ROUTES_AND_PARAMS;
+  if (req.query[returnUrlParamName]) {
+    const returnURL = decodeURIComponent(req.query[returnUrlParamName] as string);
+
+    return getSafeReturnURL(returnURL, returnUrlParamName);
+  }
+  return null;
+};

package/lib/DBEventsManager.ts

@@ -1,7 +1,4 @@
-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";
@@ -53,7 +50,7 @@ export class DBEventsManager {
   };
 
   onNotice = (notice: any) => {
-    if (this.notice && this.notice.sockets.length) {
+    if (this.notice.sockets.length) {
       this.notice.sockets.map((s) => {
         s.emit(this.notice.socketChannel, notice);
       });
@@ -68,7 +65,7 @@ export class DBEventsManager {
   async addNotify(
     query: string,
     socket?: PRGLIOSocket,
-    func?: any,
+    func?: any
   ): Promise<{
     socketChannel: string;
     socketUnsubChannel: string;
@@ -120,17 +117,10 @@ export class DBEventsManager {
         socketChannel,
         sockets: socket ? [socket] : [],
         localFuncs: func ? [func] : [],
-        notifMgr: await PostgresNotifListenManager.create(
-          this.db_pg,
-          this.onNotif,
-          channel,
-        ),
+        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) {
         this.notifies[notifChannel]!.localFuncs.push(func);
@@ -155,13 +145,9 @@ export class DBEventsManager {
     const notifChannel = channel && this.notifies[channel];
     if (notifChannel) {
       if (socket) {
-        notifChannel.sockets = notifChannel.sockets.filter(
-          (s) => s.id !== socket.id,
-        );
+        notifChannel.sockets = notifChannel.sockets.filter((s) => s.id !== socket.id);
       } else if (func) {
-        notifChannel.localFuncs = notifChannel.localFuncs.filter(
-          (f) => f !== func,
-        );
+        notifChannel.localFuncs = notifChannel.localFuncs.filter((f) => f !== func);
       }
 
       /* UNLISTEN if no listeners ?? */
@@ -169,15 +155,15 @@ export class DBEventsManager {
 
     if (socket) {
       getKeys(this.notifies).forEach((channel) => {
-        this.notifies[channel]!.sockets = this.notifies[
-          channel
-        ]!.sockets.filter((s) => s.id !== socket.id);
+        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";
+    if (!socket.id) throw "Expecting a socket obj with id";
 
     if (!this.notice.sockets.find((s) => s.id === socket.id)) {
       this.notice.sockets.push(socket);
@@ -194,7 +180,7 @@ export class DBEventsManager {
   }
 
   removeNotice(socket: PRGLIOSocket) {
-    if (!socket || !socket.id) throw "Expecting a socket obj with id";
+    if (!socket.id) throw "Expecting a socket obj with id";
     this.notice.sockets = this.notice.sockets.filter((s) => s.id !== socket.id);
   }
 }

package/lib/DBSchemaBuilder.ts

@@ -196,7 +196,7 @@ export type PublishFullyTyped<Schema = void> = Schema extends DBSchema
     transactions: true,
     onReady: ({ dbo }) => {
       dbo.tdwa?.find!();
-      dbo.tx?.((t) => {
+      dbo.tx((t) => {
         t.dwa?.find!();
       });
     },

package/lib/DboBuilder/DboBuilder.ts

@@ -40,7 +40,6 @@ import {
 import { getTablesForSchemaPostgresSQL } from "./getTablesForSchemaPostgresSQL";
 import { prepareShortestJoinPaths } from "./prepareShortestJoinPaths";
 import { cacheDBTypes, runSQL } from "./runSQL";
-import { runClientTransactionStatement } from "./runTransaction";
 
 export * from "./DboBuilderTypes";
 export * from "./dboBuilderUtils";
@@ -167,9 +166,7 @@ export class DboBuilder {
 
   _joins?: Join[];
   get joins(): Join[] {
-    return clone(this._joins ?? []).filter(
-      (j) => j.tables[0] !== j.tables[1],
-    ) as Join[];
+    return clone(this._joins ?? []).filter((j) => j.tables[0] !== j.tables[1]) as Join[];
   }
 
   set joins(j: Join[]) {
@@ -181,8 +178,7 @@ export class DboBuilder {
   }
 
   prepareShortestJoinPaths = async () => {
-    const { joins, shortestJoinPaths, joinGraph } =
-      await prepareShortestJoinPaths(this);
+    const { joins, shortestJoinPaths, joinGraph } = await prepareShortestJoinPaths(this);
     this.joinGraph = joinGraph;
     this.joins = joins;
     this.shortestJoinPaths = shortestJoinPaths;
@@ -192,7 +188,7 @@ export class DboBuilder {
     query: string,
     params: any,
     options: SQLOptions | undefined,
-    localParams?: LocalParams,
+    localParams?: LocalParams
   ) => {
     return runSQL
       .bind(this)(query, params, options, localParams)
@@ -201,8 +197,8 @@ export class DboBuilder {
           getSerializedClientErrorFromPGError(error, {
             type: "sql",
             localParams,
-          }),
-        ),
+          })
+        )
       );
   };
 
@@ -215,7 +211,7 @@ export class DboBuilder {
       if (subscribeError) {
         console.error(
           "Could not initiate PubSubManager. Realtime data/Subscriptions will not work. Error: ",
-          subscribeError,
+          subscribeError
         );
         this.canSubscribe = false;
       } else {
@@ -226,7 +222,7 @@ export class DboBuilder {
     const start = Date.now();
     const tablesOrViewsReq = await getTablesForSchemaPostgresSQL(
       this,
-      this.prostgles.opts.schemaFilter,
+      this.prostgles.opts.schemaFilter
     );
     await this.prostgles.opts.onLog?.({
       type: "debug",
@@ -236,36 +232,30 @@ export class DboBuilder {
     });
     this.tablesOrViews = tablesOrViewsReq.result;
 
-    this.constraints = await getConstraints(
-      this.db,
-      this.prostgles.opts.schemaFilter,
-    );
+    this.constraints = await getConstraints(this.db, this.prostgles.opts.schemaFilter);
     await this.prepareShortestJoinPaths();
 
     this.dbo = {};
     this.tablesOrViews.map((tov) => {
-      const columnsForTypes = tov.columns
-        .slice(0)
-        .sort((a, b) => a.name.localeCompare(b.name));
+      const columnsForTypes = tov.columns.slice(0).sort((a, b) => a.name.localeCompare(b.name));
 
       const filterKeywords = Object.values(this.prostgles.keywords);
-      const $filterCol = columnsForTypes.find((c) =>
-        filterKeywords.includes(c.name),
-      );
+      const $filterCol = columnsForTypes.find((c) => filterKeywords.includes(c.name));
       if ($filterCol) {
         throw `DboBuilder init error: \n\nTable ${JSON.stringify(tov.name)} column ${JSON.stringify($filterCol.name)} is colliding with Prostgles filtering functionality ($filter keyword)
                 Please provide a replacement keyword name using the $filter_keyName init option. 
                 Alternatively you can rename the table column\n`;
       }
 
-      this.dbo[tov.escaped_identifier] = new (
-        tov.is_view ? ViewHandler : TableHandler
-      )(this.db, tov, this, undefined, this.shortestJoinPaths);
+      this.dbo[tov.escaped_identifier] = new (tov.is_view ? ViewHandler : TableHandler)(
+        this.db,
+        tov,
+        this,
+        undefined,
+        this.shortestJoinPaths
+      );
 
-      if (
-        this.shortestJoinPaths &&
-        this.shortestJoinPaths.find((jp) => [jp.t1, jp.t2].includes(tov.name))
-      ) {
+      if (this.shortestJoinPaths.find((jp) => [jp.t1, jp.t2].includes(tov.name))) {
         const table = tov.name;
 
         this.dbo.innerJoin ??= {};
@@ -293,9 +283,7 @@ export class DboBuilder {
     if (!this.dbo.sql) {
       this.dbo.sql = this.runSQL;
     } else {
-      console.warn(
-        `Could not create dbo.sql handler because there is already a table named "sql"`,
-      );
+      console.warn(`Could not create dbo.sql handler because there is already a table named "sql"`);
     }
 
     this.tsTypesDefinition = [
@@ -309,18 +297,16 @@ export class DboBuilder {
 
   getShortestJoinPath = (
     viewHandler: ViewHandler,
-    target: string,
+    target: string
   ): JoinPaths[number] | undefined => {
     const source = viewHandler.name;
     if (source === target) {
-      const joinPath = parseJoinPath({
+      parseJoinPath({
         rawPath: target,
         rootTable: source,
         viewHandler,
       });
 
-      if (!joinPath) return undefined;
-
       return {
         t1: source,
         t2: target,
@@ -328,9 +314,7 @@ export class DboBuilder {
       };
     }
 
-    const jp = this.shortestJoinPaths.find(
-      (jp) => jp.t1 === source && jp.t2 === target,
-    );
+    const jp = this.shortestJoinPaths.find((jp) => jp.t1 === source && jp.t2 === target);
     return jp;
   };
 
@@ -339,13 +323,7 @@ export class DboBuilder {
       const dbTX: DbTxTableHandlers & Pick<DBHandlerServer, "sql"> = {};
       this.tablesOrViews?.map((tov) => {
         const handlerClass = tov.is_view ? ViewHandler : TableHandler;
-        dbTX[tov.name] = new handlerClass(
-          this.db,
-          tov,
-          this,
-          { t, dbTX },
-          this.shortestJoinPaths,
-        );
+        dbTX[tov.name] = new handlerClass(this.db, tov, this, { t, dbTX }, this.shortestJoinPaths);
       });
       dbTX.sql = (q, args, opts, localP) =>
         this.runSQL(q, args, opts, { tx: { dbTX, t }, ...(localP ?? {}) });
@@ -357,11 +335,4 @@ export class DboBuilder {
   };
 
   cacheDBTypes = cacheDBTypes.bind(this);
-
-  runClientTransactionStatement = (statement: string) => {
-    return runClientTransactionStatement(
-      statement,
-      this.prostgles.opts.dbConnection as any,
-    );
-  };
 }