prostgles-server 4.2.226 → 4.2.228

package/lib/Auth/AuthHandler.ts

@@ -41,11 +41,9 @@ export const AUTH_ROUTES_AND_PARAMS = {
   emailRegistration: "/register",
   returnUrlParamName: "returnURL",
   sidKeyName: "session_id",
-  logoutGetPath: "/logout",
-  magicLinksRoute: "/magic-link",
-  magicLinksExpressRoute: "/magic-link/:id",
-  confirmEmail: "/confirm-email",
-  confirmEmailExpressRoute: "/confirm-email",
+  logout: "/logout",
+  magicLinks: "/magic-link",
+  magicLinksIdParam: "/magic-link/:id",
   catchAll: "*",
 } as const;
 
@@ -75,11 +73,16 @@ export class AuthHandler {
   };
 
   isUserRoute = (pathname: string) => {
-    const { login, logoutGetPath, magicLinksRoute, loginWithProvider } = AUTH_ROUTES_AND_PARAMS;
+    const {
+      login,
+      logout: logoutRoute,
+      magicLinks: magicLinksRoute,
+      loginWithProvider,
+    } = AUTH_ROUTES_AND_PARAMS;
     const pubRoutes = [
       ...(this.opts.loginSignupConfig?.publicRoutes || []),
       login,
-      logoutGetPath,
+      logoutRoute,
       magicLinksRoute,
       loginWithProvider,
     ].filter((publicRoute) => publicRoute);
@@ -179,26 +182,22 @@ export class AuthHandler {
     const app = this.opts.loginSignupConfig?.app;
     const {
       login,
-      logoutGetPath,
-      magicLinksExpressRoute,
+      logout,
+      magicLinksIdParam,
       catchAll,
       loginWithProvider,
-      emailRegistration: emailSignup,
-      magicLinksRoute,
-      confirmEmail,
-      confirmEmailExpressRoute,
+      emailRegistration,
+      magicLinks,
     } = AUTH_ROUTES_AND_PARAMS;
 
     removeExpressRoute(app, [
       login,
-      logoutGetPath,
-      magicLinksExpressRoute,
+      logout,
+      magicLinksIdParam,
       catchAll,
       loginWithProvider,
-      emailSignup,
-      magicLinksRoute,
-      confirmEmail,
-      confirmEmailExpressRoute,
+      emailRegistration,
+      magicLinks,
     ]);
   };
 

package/lib/Auth/AuthTypes.ts

@@ -113,25 +113,37 @@ type PasswordRegisterResponse =
   | AuthResponse.PasswordRegisterSuccess;
 
 /**
- * Users have to provide an email and a password.
+ * Users have to provide an email and optionally a password.
  * Account should be activated after email confirmation
  */
-export type SignupWithEmailAndPassword = {
+export type SignupWithEmail = {
   /**
    * Defaults to 8
    */
   minPasswordLength?: number;
 
   /**
-   * Called when the user has registered
+   * If true, the user will have to provide a password
+   */
+  requirePassword?: boolean;
+
+  /**
+   * Called when the user has registered.
    */
   onRegister: (data: {
     email: string;
+
     /**
-     * Password after validation
+     * Password after validation.
+     * Will be empty if requirePassword is false
      */
     password: string;
     clientInfo: LoginClientInfo;
+
+    /**
+     * Returns a URL that the user can click or enter the verification code to confirm their email address.
+     * Will point to /magic-link/:email:code by default
+     */
     getConfirmationUrl: (data: { code: string; websiteUrl: string }) => string;
     req: ExpressReq;
   }) => Awaitable<PasswordRegisterResponse>;
@@ -289,11 +301,12 @@ export type AuthConfig<S = void, SUser extends SessionUser = SessionUser> = {
   sidKeyName?: string;
 
   /**
+   * Required to allow self-managed or managed (by setting up loginSignupConfig) authentication.
    * Used in:
-   * - WS AUTHGUARD - allows connected SPA client to check if on protected route and needs to reload to ne redirected to login
-   * - PublishParams - userData and/or sid (in testing) are passed to the publish function
+   * - publish - userData and/or sid (in testing) are passed to the publish function
    * - auth.expressConfig.use - express middleware to get user data and
    *    undefined sid is allowed to enable public users
+   * - websocket authguard - allows connected SPA client to check if on protected route and needs to reload to ne redirected to login
    */
   getUser: (
     sid: string | undefined,
@@ -341,6 +354,10 @@ export type LoginResponse =
   | AuthResponse.PasswordLoginFailure["code"]
   | AuthResponse.MagicLinkAuthFailure["code"];
 
+export type MagicLinkOrOTPData =
+  | { type: "magic-link"; magicId: string }
+  | { type: "otp"; code: string; email: string };
+
 export type LoginParams =
   | ({
       type: "username";
@@ -386,20 +403,30 @@ export type LoginSignupConfig<S, SUser extends SessionUser> = {
   ) => Awaitable<void>;
 
   /**
-   * If defined, will enable GET /magic-link/:id route.
-   * Requests with valid magic link ids will be logged in and redirected to the returnUrl if set
+   * If defined, will enable:
+   * - GET /magic-link/:id route.
+   * - POST /magic-link { email, code } route.
+   * Successfull requests that return a session will be logged in
+   * and redirected to the returnUrl if set.
+   * Otherwise just the response will be sent
    */
-  onMagicLink?: (
-    magicId: string,
+  onMagicLinkOrOTP?: (
+    data: MagicLinkOrOTPData,
     dbo: DBOFullyTyped<S>,
     db: DB,
     client: LoginClientInfo
   ) => Awaitable<
-    | { session: BasicSession; response?: AuthResponse.MagicLinkAuthSuccess }
-    | { session?: undefined; response: AuthResponse.MagicLinkAuthFailure }
+    | {
+        session: BasicSession | undefined;
+        response?: AuthResponse.AuthSuccess | AuthResponse.PasswordRegisterEmailConfirmationSuccess;
+      }
+    | {
+        session?: undefined;
+        response: AuthResponse.MagicLinkAuthFailure | AuthResponse.CodeVerificationFailure;
+      }
   >;
 
-  signupWithEmailAndPassword?: SignupWithEmailAndPassword;
+  signupWithEmail?: SignupWithEmail;
 
   loginWithOAuth?: LoginWithOAuthConfig<S>;
 
@@ -410,7 +437,8 @@ export type LoginSignupConfig<S, SUser extends SessionUser> = {
   localLoginMode?: AuthSocketSchema["loginType"];
 
   /**
-   * If provided then the user will be able to login with a username and password
+   * If provided then the user will be able to login with a username and/or password
+   * through the POST /login route.
    */
   login: (
     params: LoginParams,

package/lib/Auth/endpoints/setCatchAllRequestHandler.ts

@@ -24,7 +24,7 @@ export function setCatchAllRequestHandler(this: AuthHandler, app: e.Express) {
     res.redirect("/");
   };
 
-  const requestHandler: RequestHandler = async (req, res, next) => {
+  const requestHandlerCatchAll: RequestHandler = async (req, res, next) => {
     const { onGetRequestOK } = this.opts.loginSignupConfig ?? {};
     const clientReq: AuthClientRequest = { httpReq: req, res };
     const getUser = async () => {
@@ -47,7 +47,7 @@ export function setCatchAllRequestHandler(this: AuthHandler, app: e.Express) {
     try {
       const returnURL = getReturnUrl(req);
 
-      if (matchesRoute(AUTH_ROUTES_AND_PARAMS.logoutGetPath, req.path)) {
+      if (matchesRoute(AUTH_ROUTES_AND_PARAMS.logout, req.path) && req.method === "POST") {
         await onLogout(req, res);
         return;
       }
@@ -56,6 +56,7 @@ export function setCatchAllRequestHandler(this: AuthHandler, app: e.Express) {
         next();
         return;
       }
+
       /**
        * Requesting a User route
        */
@@ -87,7 +88,7 @@ export function setCatchAllRequestHandler(this: AuthHandler, app: e.Express) {
         }
       }
 
-      onGetRequestOK?.(req, res, {
+      await onGetRequestOK?.(req, res, {
         getUser,
         dbo: this.dbo as DBOFullyTyped,
         db: this.db,
@@ -106,5 +107,5 @@ export function setCatchAllRequestHandler(this: AuthHandler, app: e.Express) {
     }
   };
 
-  app.get(AUTH_ROUTES_AND_PARAMS.catchAll, requestHandler);
+  app.get(AUTH_ROUTES_AND_PARAMS.catchAll, requestHandlerCatchAll);
 }

package/lib/Auth/endpoints/setLoginRequestHandler.ts

@@ -3,14 +3,15 @@ import { AuthRequest, AuthResponse, isDefined, isObject } from "prostgles-types"
 import { AUTH_ROUTES_AND_PARAMS, AuthHandler, HTTP_FAIL_CODES } from "../AuthHandler";
 import { LoginParams } from "../AuthTypes";
 
-export type LoginResponseHandler = Response<
+export type LoginResponse =
   | AuthResponse.OAuthRegisterSuccess
   | AuthResponse.OAuthRegisterFailure
   | AuthResponse.PasswordLoginSuccess
   | AuthResponse.PasswordLoginFailure
   | AuthResponse.MagicLinkAuthFailure
   | AuthResponse.MagicLinkAuthSuccess
->;
+  | AuthResponse.CodeVerificationFailure;
+export type LoginResponseHandler = Response<LoginResponse>;
 
 export function setLoginRequestHandler(this: AuthHandler, app: e.Express) {
   app.post(AUTH_ROUTES_AND_PARAMS.login, async (req, res: LoginResponseHandler) => {

package/lib/Auth/endpoints/setMagicLinkOrOTPRequestHandler.ts

@@ -0,0 +1,78 @@
+import e, { type Response } from "express";
+import { DBOFullyTyped } from "../../DBSchemaBuilder";
+import {
+  AUTH_ROUTES_AND_PARAMS,
+  AuthHandler,
+  getClientRequestIPsInfo,
+  HTTP_FAIL_CODES,
+  HTTP_SUCCESS_CODES,
+} from "../AuthHandler";
+import { ExpressReq, LoginSignupConfig, MagicLinkOrOTPData, SessionUser } from "../AuthTypes";
+import { throttledAuthCall } from "../utils/throttledReject";
+import { LoginResponse } from "./setLoginRequestHandler";
+import { AuthResponse } from "prostgles-types";
+
+type MagicLinkResponseHandler = Response<
+  | LoginResponse
+  | AuthResponse.PasswordRegisterEmailConfirmationSuccess
+  | AuthResponse.PasswordRegisterEmailConfirmationFailure
+>;
+
+export function setMagicLinkOrOTPRequestHandler(
+  this: AuthHandler,
+  onMagicLink: Required<LoginSignupConfig<void, SessionUser>>["onMagicLinkOrOTP"],
+  app: e.Express
+) {
+  const handler = async (
+    req: ExpressReq,
+    res: MagicLinkResponseHandler,
+    data: MagicLinkOrOTPData
+  ) => {
+    try {
+      const response = await throttledAuthCall(async () => {
+        return onMagicLink(
+          data,
+          this.dbo as DBOFullyTyped,
+          this.db,
+          getClientRequestIPsInfo({ httpReq: req })
+        );
+      });
+      if (!response.session) {
+        res
+          .status(response.response?.success ? HTTP_SUCCESS_CODES.OK : HTTP_FAIL_CODES.UNAUTHORIZED)
+          .json(response.response);
+      } else {
+        this.setCookieAndGoToReturnURLIFSet(response.session, { req, res });
+      }
+    } catch (_e) {
+      res
+        .status(HTTP_FAIL_CODES.BAD_REQUEST)
+        .json({ success: false, code: "something-went-wrong" });
+    }
+  };
+  app.get(AUTH_ROUTES_AND_PARAMS.magicLinksIdParam, (req, res: MagicLinkResponseHandler) => {
+    const { id } = req.params;
+
+    if (typeof id !== "string" || !id) {
+      res
+        .status(HTTP_FAIL_CODES.BAD_REQUEST)
+        .json({ success: false, code: "invalid-magic-link", message: "Invalid magic link" });
+    }
+    return handler(req, res, { type: "magic-link", magicId: id });
+  });
+  app.post(AUTH_ROUTES_AND_PARAMS.magicLinks, (req, res: MagicLinkResponseHandler) => {
+    const { code, email } = req.body;
+
+    if (typeof code !== "string" || !code) {
+      res
+        .status(HTTP_FAIL_CODES.BAD_REQUEST)
+        .json({ success: false, code: "invalid-otp-code", message: "Invalid or empty code" });
+    }
+    if (typeof email !== "string" || !email) {
+      res
+        .status(HTTP_FAIL_CODES.BAD_REQUEST)
+        .json({ success: false, code: "invalid-email", message: "Invalid or empty email" });
+    }
+    return handler(req, res, { type: "otp", code, email });
+  });
+}

package/lib/Auth/endpoints/setRegisterRequestHandler.ts

@@ -1,7 +1,7 @@
 import e, { Request, Response } from "express";
 import { AuthResponse } from "prostgles-types";
 import { AUTH_ROUTES_AND_PARAMS, HTTP_FAIL_CODES } from "../AuthHandler";
-import type { SignupWithEmailAndPassword } from "../AuthTypes";
+import type { SignupWithEmail } from "../AuthTypes";
 import { getClientRequestIPsInfo } from "../utils/getClientRequestIPsInfo";
 import { parseLoginData } from "./setLoginRequestHandler";
 
@@ -13,8 +13,8 @@ type ReturnType =
 
 type RegisterResponseHandler = Response<ReturnType>;
 
-export const setRegisterRequestHandler = async (
-  { onRegister, minPasswordLength = 8 }: SignupWithEmailAndPassword,
+export const setRegisterRequestHandler = (
+  { onRegister, minPasswordLength = 8 }: SignupWithEmail,
   app: e.Express
 ) => {
   const registerRequestHandler = async (req: Request, res: RegisterResponseHandler) => {
@@ -50,7 +50,7 @@ export const setRegisterRequestHandler = async (
         email: username,
         password,
         getConfirmationUrl: ({ code, websiteUrl }) => {
-          const confirmationUrl = new URL(`${websiteUrl}${AUTH_ROUTES_AND_PARAMS.confirmEmail}`);
+          const confirmationUrl = new URL(`${websiteUrl}${AUTH_ROUTES_AND_PARAMS.magicLinks}`);
           confirmationUrl.searchParams.set("email", username);
           confirmationUrl.searchParams.set("code", code);
           return confirmationUrl.toString();

package/lib/Auth/getClientAuth.ts

@@ -64,8 +64,12 @@ export async function getClientAuth(
   }
 
   const userData = await this.getSidAndUserFromRequest(clientReq);
-  const { loginWithOAuth, signupWithEmailAndPassword, localLoginMode, login } =
-    this.opts.loginSignupConfig ?? {};
+  const {
+    loginWithOAuth,
+    signupWithEmail: signupWithEmailAndPassword,
+    localLoginMode,
+    login,
+  } = this.opts.loginSignupConfig ?? {};
 
   const auth: AuthSocketSchema = {
     providers: getOAuthProviders(loginWithOAuth),

package/lib/Auth/setupAuthRoutes.ts

@@ -1,14 +1,12 @@
-import e, { RequestHandler } from "express";
+import { RequestHandler } from "express";
 import { DBOFullyTyped } from "../DBSchemaBuilder";
 import { AuthHandler, HTTP_FAIL_CODES } from "./AuthHandler";
 import { setCatchAllRequestHandler } from "./endpoints/setCatchAllRequestHandler";
-import { setConfirmEmailRequestHandler } from "./endpoints/setConfirmEmailRequestHandler";
 import { setLoginRequestHandler } from "./endpoints/setLoginRequestHandler";
-import { setMagicLinkRequestHandler } from "./endpoints/setMagicLinkRequestHandler";
+import { setMagicLinkOrOTPRequestHandler } from "./endpoints/setMagicLinkOrOTPRequestHandler";
 import { setOAuthRequestHandlers } from "./endpoints/setOAuthRequestHandlers";
 import { setRegisterRequestHandler } from "./endpoints/setRegisterRequestHandler";
 import { upsertNamedExpressMiddleware } from "./utils/upsertNamedExpressMiddleware";
-import { removeExpressRoute } from "../FileManager/FileManager";
 
 export async function setupAuthRoutes(this: AuthHandler) {
   const { loginSignupConfig } = this.opts;
@@ -23,10 +21,10 @@ export async function setupAuthRoutes(this: AuthHandler) {
   const {
     app,
     publicRoutes = [],
-    onMagicLink,
+    onMagicLinkOrOTP,
     use,
     loginWithOAuth,
-    signupWithEmailAndPassword,
+    signupWithEmail: signupWithEmailAndPassword,
   } = loginSignupConfig;
   if (publicRoutes.find((r) => typeof r !== "string" || !r)) {
     throw "Invalid or empty string provided within publicRoutes ";
@@ -34,7 +32,6 @@ export async function setupAuthRoutes(this: AuthHandler) {
 
   if (signupWithEmailAndPassword) {
     setRegisterRequestHandler(signupWithEmailAndPassword, app);
-    setConfirmEmailRequestHandler.bind(this)(signupWithEmailAndPassword, app);
   }
 
   if (loginWithOAuth) {
@@ -43,7 +40,7 @@ export async function setupAuthRoutes(this: AuthHandler) {
 
   if (use) {
     const prostglesUseMiddleware: RequestHandler = (req, res, next) => {
-      use({
+      void use({
         req,
         res,
         next,
@@ -62,8 +59,8 @@ export async function setupAuthRoutes(this: AuthHandler) {
     upsertNamedExpressMiddleware(app, prostglesUseMiddleware, "prostglesUseMiddleware");
   }
 
-  if (onMagicLink) {
-    setMagicLinkRequestHandler.bind(this)(onMagicLink, app);
+  if (onMagicLinkOrOTP) {
+    setMagicLinkOrOTPRequestHandler.bind(this)(onMagicLinkOrOTP, app);
   }
 
   setLoginRequestHandler.bind(this)(app);

package/lib/DBSchemaBuilder.ts

@@ -148,7 +148,7 @@ export type PublishFullyTyped<Schema = void> =
   ddb.dwad?.delete;
 
   //@ts-ignore
-  prostgles({
+  void prostgles({
     dbConnection: 1 as any,
     publish: async (params) => {
       const _rows = await params.dbo.dwadwa?.find?.({});
@@ -157,9 +157,9 @@ export type PublishFullyTyped<Schema = void> =
     },
     transactions: true,
     onReady: ({ dbo }) => {
-      dbo.tdwa?.find!();
-      dbo.tx((t) => {
-        t.dwa?.find!();
+      void dbo.tdwa?.find!();
+      void dbo.tx((t) => {
+        void t.dwa?.find!();
       });
     },
   });
@@ -192,13 +192,13 @@ export type PublishFullyTyped<Schema = void> =
   const _test: DBSchema = c;
   const dbt: DBOFullyTyped<S> = 1 as any;
 
-  dbt.tx!((t) => {
-    t.tbl1.delete();
+  void dbt.tx!((t) => {
+    void t.tbl1.delete();
   });
 
   const db: DBHandlerServer = 1 as any;
-  db.tx!((t) => {
-    t.wadwa?.find!();
+  void db.tx!((t) => {
+    void t.wadwa?.find!();
   });
 
   const _publish = (): PublishFullyTyped<S> => {
@@ -244,7 +244,7 @@ export type PublishFullyTyped<Schema = void> =
 
     const p: PublishParams<undefined> = 1 as any;
 
-    p.dbo.dwadaw?.find?.();
+    void p.dbo.dwadaw?.find?.();
 
     return res;
   };

package/lib/DboBuilder/DboBuilder.ts

@@ -161,7 +161,7 @@ export class DboBuilder {
   };
 
   destroy() {
-    this._pubSubManager?.destroy();
+    return this._pubSubManager?.destroy();
   }
 
   _joins?: Join[];

package/lib/DboBuilder/QueryStreamer.ts

@@ -55,18 +55,18 @@ export class QueryStreamer {
     this.db = dboBuilder.db;
     const setAdminClient = () => {
       this.adminClient = this.getConnection(undefined, { keepAlive: true });
-      this.adminClient.connect();
+      return this.adminClient.connect();
     };
     this.adminClient = this.getConnection(
       (error) => {
         if (error.message?.includes("database") && error.message?.includes("does not exist"))
           return;
         console.log("Admin client error. Reconnecting...", error);
-        setAdminClient();
+        void setAdminClient();
       },
       { keepAlive: true }
     );
-    this.adminClient.connect();
+    void this.adminClient.connect();
   }
 
   getConnection = (onError: ((err: any) => void) | undefined, extraOptions?: pg.ClientConfig) => {
@@ -84,7 +84,7 @@ export class QueryStreamer {
     Object.values(socketQueries).forEach(({ client, stop }) => {
       stop?.();
       /** end does not stop active query?! */
-      client?.end();
+      void client?.end();
     });
     delete this.socketQueries[socketId];
   };
@@ -165,7 +165,7 @@ export class QueryStreamer {
         client ??
         this.getConnection((err) => {
           socketQuery.onError(err);
-          currentClient.end();
+          void currentClient.end();
         });
       this.socketQueries[socketId]![id]!.client = currentClient;
       try {
@@ -188,7 +188,7 @@ export class QueryStreamer {
         this.socketQueries[socketId]![id]!.cursor = cursor;
         let streamLimitReached = false;
         let reachedEnd = false;
-        (async () => {
+        void (async () => {
           try {
             let rowChunk: any[] = [];
             let rowsSent = 0;
@@ -216,9 +216,9 @@ export class QueryStreamer {
 
             if (!query.options?.persistStreamConnection) {
               delete this.socketQueries[socketId]?.[id];
-              currentClient.end();
+              void currentClient.end();
             }
-            cursor.close();
+            void cursor.close();
           } catch (error: any) {
             streamState = "errored";
             if (error.message === "cannot insert multiple commands into a prepared statement") {
@@ -258,7 +258,7 @@ export class QueryStreamer {
       if (!queryClient) return;
       if (opts?.terminate) {
         setTimeout(() => {
-          queryClient.end();
+          void queryClient.end();
         }, 4e3);
       }
       try {

package/lib/DboBuilder/ViewHandler/find.ts

@@ -152,7 +152,7 @@ export const find = async function (
     });
     return result;
   } catch (e) {
-    this._log({
+    await this._log({
       command,
       localParams,
       data: { filter, selectParams },

package/lib/FileManager/upload.ts

@@ -1,9 +1,4 @@
-import {
-  FileManager,
-  LocalConfig,
-  OnProgress,
-  UploadedItem,
-} from "./FileManager";
+import { FileManager, LocalConfig, OnProgress, UploadedItem } from "./FileManager";
 import * as stream from "stream";
 import * as fs from "fs";
 
@@ -12,7 +7,7 @@ export async function upload(
   file: Buffer | string | stream.PassThrough,
   name: string,
   mime: string,
-  onProgress?: OnProgress,
+  onProgress?: OnProgress
 ): Promise<UploadedItem> {
   return new Promise(async (resolve, reject) => {
     if (!file) {
@@ -43,7 +38,7 @@ export async function upload(
       }
     } else {
       let content_length = 0;
-      this.cloudClient.upload({
+      void this.cloudClient.upload({
         fileName: name,
         contentType: mime,
         file,

package/lib/FileManager/uploadStream.ts

@@ -10,18 +10,16 @@ export function uploadStream(
   onProgress?: OnProgress,
   onError?: (error: any) => void,
   onEnd?: (item: UploadedItem) => void,
-  expectedSizeBytes?: number,
+  expectedSizeBytes?: number
 ) {
   const passThrough = new stream.PassThrough();
 
   if (!this.cloudClient && "localFolderPath" in this.config) {
     try {
-      this.checkFreeSpace(this.config.localFolderPath, expectedSizeBytes).catch(
-        (err) => {
-          onError?.(err);
-          passThrough.end();
-        },
-      );
+      this.checkFreeSpace(this.config.localFolderPath, expectedSizeBytes).catch((err) => {
+        onError?.(err);
+        passThrough.end();
+      });
       const url = this.getLocalFileUrl(name);
       fs.mkdirSync(this.config.localFolderPath, { recursive: true });
       const filePath = path.resolve(`${this.config.localFolderPath}/${name}`);
@@ -71,7 +69,7 @@ export function uploadStream(
       onError?.(err);
     }
   } else {
-    this.upload(passThrough, name, mime, onProgress).then(onEnd).catch(onError);
+    void this.upload(passThrough, name, mime, onProgress).then(onEnd).catch(onError);
   }
 
   return passThrough;

package/lib/PostgresNotifListenManager.ts

@@ -44,7 +44,7 @@ export class PostgresNotifListenManager {
     this.notifListener = notifListener;
     this.db_channel_name = db_channel_name;
 
-    if (!noInit) this.init();
+    if (!noInit) void this.init();
   }
 
   async init(): Promise<PostgresNotifListenManager> {
@@ -68,7 +68,7 @@ export class PostgresNotifListenManager {
   destroy = async () => {
     this.destroyed = true;
     await this.stopListening();
-    this.connection?.done();
+    await this.connection?.done();
     this.connection = undefined;
   };
 
@@ -77,7 +77,7 @@ export class PostgresNotifListenManager {
       try {
         await this.connection?.none("UNLISTEN $1~", [this.db_channel_name]);
         await this.client?.query("UNLISTEN $1~", [this.db_channel_name]);
-      } catch (error) {}
+      } catch {}
     }
   };
 

package/lib/Prostgles.ts

@@ -392,7 +392,7 @@ export class Prostgles {
     if (this.connectedSockets.length) {
       this.connectedSockets.forEach((s) => {
         s.emit(CHANNELS.SCHEMA_CHANGED);
-        this.pushSocketSchema(s);
+        void this.pushSocketSchema(s);
       });
       return;
     }