prostgles-server 4.2.279 → 4.2.280

package/lib/Auth/utils/setCookieAndGoToReturnURLIFSet.ts

@@ -0,0 +1,62 @@
+import { HTTP_FAIL_CODES, type AuthHandler } from "../AuthHandler";
+import type { ExpressReq } from "../AuthTypes";
+import type { LoginResponseHandler } from "../endpoints/setLoginRequestHandler";
+import { getBasicSessionErrorCode } from "../login";
+import { getReturnUrl } from "./getReturnUrl";
+
+export function validateSessionAndSetCookie(
+  this: AuthHandler,
+  cookie: { sid: string; expires: number },
+  requestHandler: { req: ExpressReq; res: LoginResponseHandler }
+) {
+  const sessionErrorCode = getBasicSessionErrorCode(cookie);
+  if (sessionErrorCode) {
+    const { res } = requestHandler;
+    res.status(HTTP_FAIL_CODES.UNAUTHORIZED).json({
+      success: false,
+      code: sessionErrorCode,
+    });
+    return;
+  }
+  return this.setCookieAndGoToReturnURLIFSet(cookie, requestHandler);
+}
+
+export function setCookieAndGoToReturnURLIFSet(
+  this: AuthHandler,
+  cookie: { sid: string; expires: number },
+  requestHandler: { req: ExpressReq; res: LoginResponseHandler }
+) {
+  const { sid, expires } = cookie;
+  const { res, req } = requestHandler;
+  if (!sid) {
+    throw "no sid";
+  }
+
+  const maxAgeOneDay = 60 * 60 * 24; // 24 hours;
+  type CookieExpirationOptions = { maxAge: number } | { expires: Date };
+  let cookieDuration: CookieExpirationOptions = {
+    maxAge: maxAgeOneDay,
+  };
+
+  if (expires && Number.isFinite(expires) && !isNaN(+new Date(expires))) {
+    cookieDuration = { expires: new Date(expires) };
+    const days = (+cookieDuration.expires - Date.now()) / (24 * 60 * 60e3);
+    if (days >= 400) {
+      console.warn(`Cookie expiration is higher than the Chrome 400 day limit: ${days}days`);
+    }
+  }
+
+  const cookieOpts = {
+    ...cookieDuration,
+    // The cookie only accessible by the web server
+    httpOnly: true,
+    //signed: true
+    secure: true,
+    sameSite: "strict" as const,
+    ...(this.opts.loginSignupConfig?.cookieOptions ?? {}),
+  };
+  const cookieData = sid;
+  res.cookie(this.sidKeyName, cookieData, cookieOpts);
+  const successURL = getReturnUrl(req) || "/";
+  res.redirect(successURL);
+}

package/lib/DboBuilder/DboBuilderTypes.ts

@@ -139,6 +139,15 @@ export type TableOrViewInfo = TableInfo &
     is_view: boolean;
   };
 
+export type CachedSessionData = {
+  userData: Omit<SessionUser, "session">;
+  session: BasicSession;
+};
+
+export type CachedSession = {
+  __prglCache?: CachedSessionData;
+};
+
 export type PRGLIOSocket = {
   readonly id: string;
 
@@ -167,17 +176,11 @@ export type PRGLIOSocket = {
     connection: { remoteAddress?: string };
   };
 
-  /** Used for session caching */
-  __prglCache?: {
-    userData: Omit<SessionUser, "session">;
-    session: BasicSession;
-  };
-
   _user?: AnyObject;
 
   /** Used for publish error caching */
   prostgles?: ClientSchema;
-};
+} & CachedSession;
 
 export type LocalParams = {
   // httpReq?: ExpressReq;

package/lib/DboBuilder/ViewHandler/parseFieldFilter.ts

@@ -7,11 +7,11 @@ import { isPlainObject } from "../DboBuilder";
  * @param {boolean} allow_empty - allow empty select. defaults to true
  */
 export const parseFieldFilter = <AllowedKeys extends string[]>(
-  fieldParams: FieldFilter<Record<AllowedKeys[number], any>> = "*",
+  fieldParams: FieldFilter<Record<AllowedKeys[number] | string, 1>> = "*",
   allow_empty = true,
   all_cols: AllowedKeys
 ): AllowedKeys | [""] => {
-  let colNames: AllowedKeys = [] as any;
+  let colNames: string[] = [];
   const initialParams = JSON.stringify(fieldParams);
 
   if (fieldParams) {
@@ -82,7 +82,7 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
       if (disallowed.length) {
         return all_cols.filter((col) => !disallowed.includes(col)) as typeof all_cols;
       } else {
-        return [...allowed] as any;
+        return [...allowed] as AllowedKeys | [""];
       }
     } else {
       throw (
@@ -93,9 +93,9 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
 
     validate(colNames);
   }
-  return colNames as any;
+  return colNames as AllowedKeys | [""];
 
-  function validate(cols: AllowedKeys) {
+  function validate(cols: string[]) {
     const bad_keys = cols.filter((col) => !all_cols.includes(col));
     if (bad_keys.length) {
       throw "\nUnrecognised or illegal fields: " + bad_keys.join(", ");

package/lib/Prostgles.ts

@@ -6,39 +6,26 @@
 import * as pgPromise from "pg-promise";
 import { AuthHandler } from "./Auth/AuthHandler";
 import { FileManager } from "./FileManager/FileManager";
-import { SchemaWatch } from "./SchemaWatch/SchemaWatch";
 import { OnInitReason, initProstgles } from "./initProstgles";
-import { makeSocketError, onSocketConnected } from "./onSocketConnected";
-import { clientCanRunSqlRequest, runClientSqlRequest } from "./runClientRequest";
+import { SchemaWatch } from "./SchemaWatch/SchemaWatch";
+import { getClientSchema } from "./WebsocketAPI/getClientSchema";
+import { onSocketConnected } from "./WebsocketAPI/onSocketConnected";
 import pg = require("pg-promise/typescript/pg-subset");
-const version = (require("../package.json") as { version: string }).version;
 
 import type { ProstglesInitOptions } from "./ProstglesTypes";
 import { RestApi } from "./RestApi";
 import TableConfigurator from "./TableConfig/TableConfig";
 
-import {
-  DBHandlerServer,
-  DboBuilder,
-  PRGLIOSocket,
-  getErrorAsObject,
-} from "./DboBuilder/DboBuilder";
+import { DBHandlerServer, DboBuilder, PRGLIOSocket } from "./DboBuilder/DboBuilder";
 export { DBHandlerServer };
 export type PGP = pgPromise.IMain<{}, pg.IClient>;
 export { getEmailSender, getOrSetTransporter, verifySMTPConfig } from "./Auth/sendEmail";
 export { applyTableConfig } from "./TableConfig/applyTableConfig";
 
-import {
-  CHANNELS,
-  ClientSchema,
-  SQLRequest,
-  includes,
-  isObject,
-  omitKeys,
-  tryCatchV2,
-} from "prostgles-types";
+import { CHANNELS, tryCatchV2 } from "prostgles-types";
 import { DBEventsManager } from "./DBEventsManager";
 import { PublishParser } from "./PublishParser/PublishParser";
+import { pushSocketSchema } from "./WebsocketAPI/pushSocketSchema";
 
 export type DB = pgPromise.IDatabase<{}, pg.IClient>;
 export type DBorTx = DB | pgPromise.ITask<{}>;
@@ -66,8 +53,8 @@ const DEFAULT_KEYWORDS = {
 };
 
 import { randomUUID } from "crypto";
+import type { RequestHandler } from "express";
 import * as fs from "fs";
-import { AuthClientRequest } from "./Auth/AuthTypes";
 
 export class Prostgles {
   /**
@@ -332,12 +319,16 @@ export class Prostgles {
   setSocketEvents() {
     this.checkDb();
 
-    if (!this.dbo) throw "dbo missing";
+    const {
+      dbo,
+      opts: { io },
+    } = this;
+    if (!dbo) throw "dbo missing";
 
     const publishParser = new PublishParser(this);
     this.publishParser = publishParser;
 
-    if (!this.opts.io) return;
+    if (!io) return;
 
     /* Already initialised. Only reconnect sockets */
     if (this.connectedSockets.length) {
@@ -348,158 +339,43 @@ export class Prostgles {
       return;
     }
 
+    const { authHandler } = this;
+    if (authHandler) {
+      let redirected = false;
+      io.engine.use(((req, res, next) => {
+        console.log(req.cookies);
+        if (!redirected) {
+          redirected = true;
+          // this.authHandler?.setCookieAndGoToReturnURLIFSet(
+          //   { expires: Date.now() + 221000, sid: "heehe" },
+          //   { req, res }
+          // );
+          // Set cookie manually on raw HTTP response
+          const cookieStr = `${this.authHandler?.sidKeyName}=hehehe; Path=/; Expires=${new Date(Date.now() + 221000).toUTCString()}; HttpOnly`;
+          res.setHeader("Set-Cookie", cookieStr);
+
+          // Handle redirection
+          res.statusCode = 302;
+          res.setHeader("Location", "/");
+          res.end();
+          return;
+        }
+        next();
+      }) satisfies RequestHandler);
+    }
+
     /* Initialise */
-    this.opts.io.removeAllListeners("connection");
-    this.opts.io.on("connection", this.onSocketConnected);
+    io.removeAllListeners("connection");
+    io.on("connection", this.onSocketConnected);
     /** In some cases io will re-init with already connected sockets */
-    this.opts.io.sockets.sockets.forEach((socket) => {
+    io.sockets.sockets.forEach((socket) => {
       void this.onSocketConnected(socket);
     });
   }
 
   onSocketConnected = onSocketConnected.bind(this);
-
-  getClientSchema = async (clientReq: AuthClientRequest) => {
-    const result = await tryCatchV2(async () => {
-      const clientInfo =
-        clientReq.socket ?
-          { type: "socket" as const, ...clientReq }
-        : { type: "http" as const, ...clientReq };
-
-      const userData = await this.authHandler?.getSidAndUserFromRequest(clientInfo);
-      if (userData === "new-session-redirect") {
-        throw "new-session-redirect";
-      }
-      const { publishParser } = this;
-      let fullSchema: Awaited<ReturnType<PublishParser["getSchemaFromPublish"]>> | undefined;
-      let publishValidationError;
-
-      try {
-        if (!publishParser) throw "publishParser undefined";
-        fullSchema = await publishParser.getSchemaFromPublish({
-          ...clientInfo,
-          userData,
-        });
-      } catch (e) {
-        publishValidationError = e;
-        console.error(`\nProstgles Publish validation failed (after socket connected):\n    ->`, e);
-      }
-      let rawSQL = false;
-      if (this.opts.publishRawSQL && typeof this.opts.publishRawSQL === "function") {
-        const { allowed } = await clientCanRunSqlRequest.bind(this)(clientInfo);
-        rawSQL = allowed;
-      }
-
-      const { schema, tables, tableSchemaErrors } = fullSchema ?? {
-        schema: {},
-        tables: [],
-        tableSchemaErrors: {},
-      };
-      const joinTables2: string[][] = [];
-      if (this.opts.joins) {
-        const _joinTables2 = this.dboBuilder
-          .getAllJoinPaths()
-          .filter((jp) => ![jp.t1, jp.t2].find((t) => !schema[t] || !schema[t]?.findOne))
-          .map((jp) => [jp.t1, jp.t2].sort());
-        _joinTables2.map((jt) => {
-          if (!joinTables2.find((_jt) => _jt.join() === jt.join())) {
-            joinTables2.push(jt);
-          }
-        });
-      }
-
-      const methods = await publishParser?.getAllowedMethods(clientInfo, userData);
-
-      const methodSchema: ClientSchema["methods"] =
-        !methods ?
-          []
-        : Object.entries(methods)
-            .map(([methodName, method]) => {
-              if (isObject(method) && "run" in method) {
-                return {
-                  name: methodName,
-                  ...omitKeys(method, ["run"]),
-                };
-              }
-              return methodName;
-            })
-            .sort((a, b) => {
-              const aName = isObject(a) ? a.name : a;
-              const bName = isObject(b) ? b.name : b;
-              return aName.localeCompare(bName);
-            });
-
-      const authInfo = await this.authHandler?.getClientAuth(clientReq);
-      if (authInfo === "new-session-redirect") {
-        throw "new-session-redirect";
-      }
-
-      const clientSchema: ClientSchema = {
-        schema,
-        methods: methodSchema,
-        tableSchema: tables,
-        rawSQL,
-        joinTables: joinTables2,
-        tableSchemaErrors,
-        auth: authInfo?.auth,
-        version,
-        err: publishValidationError ? "Server Error: User publish validation failed." : undefined,
-      };
-
-      return {
-        publishValidationError,
-        clientSchema,
-        userData,
-      };
-    });
-    const sid = this.authHandler?.getSIDNoError(clientReq);
-    await this.opts.onLog?.({
-      type: "connect.getClientSchema",
-      duration: result.duration,
-      sid,
-      socketId: clientReq.socket?.id,
-      error: result.error || result.data?.publishValidationError,
-    });
-    if (result.hasError) throw result.error;
-    return result.data.clientSchema;
-  };
-
-  pushSocketSchema = async (socket: PRGLIOSocket) => {
-    try {
-      const clientSchema = await this.getClientSchema({ socket });
-      socket.prostgles = clientSchema;
-      if (clientSchema.rawSQL) {
-        socket.removeAllListeners(CHANNELS.SQL);
-        socket.on(
-          CHANNELS.SQL,
-          (
-            sqlRequestData: SQLRequest,
-            cb = (..._callback: any) => {
-              /* Empty */
-            }
-          ) => {
-            runClientSqlRequest
-              .bind(this)(sqlRequestData, { socket })
-              .then((res) => {
-                cb(null, res);
-              })
-              .catch((err) => {
-                makeSocketError(cb, err);
-              });
-          }
-        );
-      }
-      await this.dboBuilder.prostgles.opts.onLog?.({
-        type: "debug",
-        command: "pushSocketSchema",
-        duration: -1,
-        data: { socketId: socket.id, clientSchema },
-      });
-      socket.emit(CHANNELS.SCHEMA, clientSchema);
-    } catch (err: any) {
-      socket.emit(CHANNELS.SCHEMA, { err: getErrorAsObject(err) });
-    }
-  };
+  getClientSchema = getClientSchema.bind(this);
+  pushSocketSchema = pushSocketSchema.bind(this);
 }
 
 export async function getIsSuperUser(db: DBorTx): Promise<boolean> {

package/lib/ProstglesTypes.ts

@@ -15,7 +15,6 @@ import pgPromise from "pg-promise";
 import pg from "pg-promise/typescript/pg-subset";
 import { AnyObject } from "prostgles-types";
 import type { Server } from "socket.io";
-import { DB } from "./Prostgles";
 import { Awaitable, Publish, PublishMethods, PublishParams } from "./PublishParser/PublishParser";
 
 /**

package/lib/PubSubManager/notifListener.ts

@@ -1,4 +1,4 @@
-import { pickKeys } from "prostgles-types";
+import { includes, pickKeys } from "prostgles-types";
 import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
 import { PubSubManager } from "./PubSubManager";
 import { DELIMITER, log, NOTIF_TYPE, type NotifTypeName } from "./PubSubManagerUtils";
@@ -139,8 +139,9 @@ export async function notifListener(this: PubSubManager, data: { payload: string
 
         const actionIsIgnored =
           actions &&
-          !parseFieldFilter(actions, false, ["insert", "update", "delete"]).includes(
-            commandLowerCase as any
+          !includes(
+            parseFieldFilter(actions, false, ["insert", "update", "delete"]),
+            commandLowerCase
           );
         if (actionIsIgnored) {
           return;

package/lib/PublishParser/getFileTableRules.ts

@@ -1,4 +1,4 @@
-import { AnyObject, FullFilter, isDefined } from "prostgles-types";
+import { AnyObject, FullFilter, includes, isDefined } from "prostgles-types";
 import { AuthClientRequest, AuthResultWithSID } from "../Auth/AuthTypes";
 import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
 import { PublishParser } from "./PublishParser";
@@ -54,7 +54,7 @@ export async function getFileTableRules(
           if (tableRules.select) {
             const parsedFields = parseFieldFilter(tableRules.select.fields, false, allColumns);
             /** Must be allowed to view this column */
-            if (parsedFields.includes(column as any)) {
+            if (includes(parsedFields, column)) {
               forcedSelectFilters.push({
                 $existsJoined: {
                   path,
@@ -66,14 +66,14 @@ export async function getFileTableRules(
           if (tableRules.insert) {
             const parsedFields = parseFieldFilter(tableRules.insert.fields, false, allColumns);
             /** Must be allowed to view this column */
-            if (parsedFields.includes(column as any)) {
+            if (includes(parsedFields, column)) {
               allowedNestedInserts.push({ table: tableName, column });
             }
           }
           if (tableRules.update) {
             const parsedFields = parseFieldFilter(tableRules.update.fields, false, allColumns);
             /** Must be allowed to view this column */
-            if (parsedFields.includes(column as any)) {
+            if (includes(parsedFields, column)) {
               forcedUpdateFilters.push({
                 $existsJoined: {
                   path,

package/lib/WebsocketAPI/getClientSchema.ts

@@ -0,0 +1,111 @@
+import { isObject, omitKeys, tryCatchV2, type ClientSchema } from "prostgles-types";
+import type { AuthClientRequest } from "../Auth/AuthTypes";
+import { Prostgles } from "../Prostgles";
+import type { PublishParser } from "../PublishParser/PublishParser";
+import { clientCanRunSqlRequest } from "../runClientRequest";
+const version = (require("../../package.json") as { version: string }).version;
+
+export async function getClientSchema(this: Prostgles, clientReq: AuthClientRequest) {
+  const result = await tryCatchV2(async () => {
+    const clientInfo =
+      clientReq.socket ?
+        { type: "socket" as const, ...clientReq }
+      : { type: "http" as const, ...clientReq };
+
+    const userData = await this.authHandler?.getSidAndUserFromRequest(clientInfo);
+    if (userData === "new-session-redirect") {
+      throw "new-session-redirect";
+    }
+    const { publishParser } = this;
+    let fullSchema: Awaited<ReturnType<PublishParser["getSchemaFromPublish"]>> | undefined;
+    let publishValidationError;
+
+    try {
+      if (!publishParser) throw "publishParser undefined";
+      fullSchema = await publishParser.getSchemaFromPublish({
+        ...clientInfo,
+        userData,
+      });
+    } catch (e) {
+      publishValidationError = e;
+      console.error(`\nProstgles Publish validation failed (after socket connected):\n    ->`, e);
+    }
+    let rawSQL = false;
+    if (this.opts.publishRawSQL && typeof this.opts.publishRawSQL === "function") {
+      const { allowed } = await clientCanRunSqlRequest.bind(this)(clientInfo);
+      rawSQL = allowed;
+    }
+
+    const { schema, tables, tableSchemaErrors } = fullSchema ?? {
+      schema: {},
+      tables: [],
+      tableSchemaErrors: {},
+    };
+    const joinTables2: string[][] = [];
+    if (this.opts.joins) {
+      const _joinTables2 = this.dboBuilder
+        .getAllJoinPaths()
+        .filter((jp) => ![jp.t1, jp.t2].find((t) => !schema[t] || !schema[t]?.findOne))
+        .map((jp) => [jp.t1, jp.t2].sort());
+      _joinTables2.map((jt) => {
+        if (!joinTables2.find((_jt) => _jt.join() === jt.join())) {
+          joinTables2.push(jt);
+        }
+      });
+    }
+
+    const methods = await publishParser?.getAllowedMethods(clientInfo, userData);
+
+    const methodSchema: ClientSchema["methods"] =
+      !methods ?
+        []
+      : Object.entries(methods)
+          .map(([methodName, method]) => {
+            if (isObject(method) && "run" in method) {
+              return {
+                name: methodName,
+                ...omitKeys(method, ["run"]),
+              };
+            }
+            return methodName;
+          })
+          .sort((a, b) => {
+            const aName = isObject(a) ? a.name : a;
+            const bName = isObject(b) ? b.name : b;
+            return aName.localeCompare(bName);
+          });
+
+    const authInfo = await this.authHandler?.getClientAuth(clientReq);
+    if (authInfo === "new-session-redirect") {
+      throw "new-session-redirect";
+    }
+
+    const clientSchema: ClientSchema = {
+      schema,
+      methods: methodSchema,
+      tableSchema: tables,
+      rawSQL,
+      joinTables: joinTables2,
+      tableSchemaErrors,
+      auth: authInfo?.auth,
+      version,
+      err: publishValidationError ? "Server Error: User publish validation failed." : undefined,
+    };
+
+    return {
+      publishValidationError,
+      clientSchema,
+      userData,
+    };
+  });
+  const sid = this.authHandler?.getSIDNoError(clientReq);
+  await this.opts.onLog?.({
+    type: "connect.getClientSchema",
+    duration: result.duration,
+    sid,
+    socketId: clientReq.socket?.id,
+    error: result.error || result.data?.publishValidationError,
+  });
+  if (result.hasError) throw result.error;
+  return result.data.clientSchema;
+}

package/lib/{onSocketConnected.ts → WebsocketAPI/onSocketConnected.ts}

@@ -1,10 +1,11 @@
 import { AnyObject, CHANNELS } from "prostgles-types";
-import type { Prostgles, TABLE_METHODS } from "./Prostgles";
-import { PRGLIOSocket } from "./DboBuilder/DboBuilderTypes";
-import { runClientMethod, runClientRequest } from "./runClientRequest";
-import { getErrorAsObject } from "./DboBuilder/dboBuilderUtils";
-import { DBOFullyTyped } from "./DBSchemaBuilder";
-import { getClientRequestIPsInfo } from "./Auth/AuthHandler";
+import type { Prostgles, TABLE_METHODS } from "../Prostgles";
+import { PRGLIOSocket } from "../DboBuilder/DboBuilderTypes";
+import { runClientMethod, runClientRequest } from "../runClientRequest";
+import { getErrorAsObject } from "../DboBuilder/dboBuilderUtils";
+import { DBOFullyTyped } from "../DBSchemaBuilder";
+import { getClientRequestIPsInfo } from "../Auth/AuthHandler";
+import type { AuthResultWithSID, SessionUser } from "../Auth/AuthTypes";
 
 export async function onSocketConnected(this: Prostgles, socket: PRGLIOSocket) {
   if (!this.db || !this.dbo) throw new Error("db/dbo missing");
@@ -18,8 +19,8 @@ export async function onSocketConnected(this: Prostgles, socket: PRGLIOSocket) {
   this.connectedSockets.push(socket);
 
   try {
-    const getUser = async () => {
-      if (!this.authHandler) throw "authHandler missing";
+    const getUser = async (): Promise<AuthResultWithSID<SessionUser>> => {
+      if (!this.authHandler) return { sid: undefined, user: undefined };
       const res = await this.authHandler.getSidAndUserFromRequest({ socket });
       if (res === "new-session-redirect") {
         socket.emit(CHANNELS.AUTHGUARD, {

package/lib/WebsocketAPI/pushSocketSchema.ts

@@ -0,0 +1,42 @@
+import { CHANNELS, type SQLRequest } from "prostgles-types";
+import type { PRGLIOSocket } from "../DboBuilder/DboBuilderTypes";
+import { Prostgles } from "../Prostgles";
+import { runClientSqlRequest } from "../runClientRequest";
+import { makeSocketError } from "./onSocketConnected";
+import { getErrorAsObject } from "../DboBuilder/dboBuilderUtils";
+export async function pushSocketSchema(this: Prostgles, socket: PRGLIOSocket) {
+  try {
+    const clientSchema = await this.getClientSchema({ socket });
+    socket.prostgles = clientSchema;
+    if (clientSchema.rawSQL) {
+      socket.removeAllListeners(CHANNELS.SQL);
+      socket.on(
+        CHANNELS.SQL,
+        (
+          sqlRequestData: SQLRequest,
+          cb = (..._callback: any) => {
+            /* Empty */
+          }
+        ) => {
+          runClientSqlRequest
+            .bind(this)(sqlRequestData, { socket })
+            .then((res) => {
+              cb(null, res);
+            })
+            .catch((err) => {
+              makeSocketError(cb, err);
+            });
+        }
+      );
+    }
+    await this.dboBuilder.prostgles.opts.onLog?.({
+      type: "debug",
+      command: "pushSocketSchema",
+      duration: -1,
+      data: { socketId: socket.id, clientSchema },
+    });
+    socket.emit(CHANNELS.SCHEMA, clientSchema);
+  } catch (err: any) {
+    socket.emit(CHANNELS.SCHEMA, { err: getErrorAsObject(err) });
+  }
+}

package/lib/initProstgles.ts

@@ -86,7 +86,9 @@ export const initProstgles = async function (
     this.opts.auth?.loginSignupConfig?.app;
 
   /** Crucial in ensuring the runtime version of express works as expected */
-  if (expressApp) await removeExpressRoutesTest(expressApp);
+  if (expressApp) {
+    await removeExpressRoutesTest(expressApp);
+  }
 
   if (!this.db) {
     let existingAppName = "";
@@ -104,7 +106,7 @@ export const initProstgles = async function (
         const url = new URL(connString);
         existingAppName =
           url.searchParams.get("application_name") ?? url.searchParams.get("ApplicationName") ?? "";
-      } catch (e) {}
+      } catch {}
     }
 
     const conObj =
@@ -115,7 +117,8 @@ export const initProstgles = async function (
 
     /* 1. Connect to db */
     const { db, pgp } = getDbConnection({
-      ...this.opts,
+      onQuery: this.opts.onQuery,
+      DEBUG_MODE: this.opts.DEBUG_MODE,
       dbConnection: { ...conObj, application_name },
       onNotice: (notice) => {
         if (this.opts.onNotice) this.opts.onNotice(notice);