prostgles-server 4.2.227 → 4.2.229

package/lib/Auth/AuthHandler.ts

@@ -41,10 +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",
+  logout: "/logout",
+  magicLinks: "/magic-link",
+  magicLinksIdParam: "/magic-link/:id",
   catchAll: "*",
 } as const;
 
@@ -74,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);
@@ -178,24 +182,22 @@ export class AuthHandler {
     const app = this.opts.loginSignupConfig?.app;
     const {
       login,
-      logoutGetPath,
-      magicLinksExpressRoute,
+      logout,
+      magicLinksIdParam,
       catchAll,
       loginWithProvider,
       emailRegistration,
-      magicLinksRoute,
-      confirmEmail,
+      magicLinks,
     } = AUTH_ROUTES_AND_PARAMS;
 
     removeExpressRoute(app, [
       login,
-      logoutGetPath,
-      magicLinksExpressRoute,
+      logout,
+      magicLinksIdParam,
       catchAll,
       loginWithProvider,
       emailRegistration,
-      magicLinksRoute,
-      confirmEmail,
+      magicLinks,
     ]);
   };
 

package/lib/Auth/AuthTypes.ts

@@ -113,41 +113,40 @@ 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>;
-
-  /**
-   * Called after the user has clicked the URL to confirm their email address
-   */
-  onEmailConfirmation: (data: {
-    email: string;
-    code: string;
-    clientInfo: LoginClientInfo;
-    req: ExpressReq;
-  }) => Awaitable<
-    | AuthResponse.PasswordRegisterEmailConfirmationFailure
-    | (AuthResponse.PasswordRegisterEmailConfirmationSuccess & { redirect_to?: string })
-  >;
 };
 
 export type AuthProviderUserData =
@@ -289,11 +288,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,
@@ -390,8 +390,12 @@ 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
    */
   onMagicLinkOrOTP?: (
     data: MagicLinkOrOTPData,
@@ -399,14 +403,17 @@ export type LoginSignupConfig<S, SUser extends SessionUser> = {
     db: DB,
     client: LoginClientInfo
   ) => Awaitable<
-    | { session: BasicSession; response?: AuthResponse.AuthSuccess }
+    | {
+        session: BasicSession | undefined;
+        response?: AuthResponse.AuthSuccess | AuthResponse.PasswordRegisterEmailConfirmationSuccess;
+      }
     | {
         session?: undefined;
         response: AuthResponse.MagicLinkAuthFailure | AuthResponse.CodeVerificationFailure;
       }
   >;
 
-  signupWithEmailAndPassword?: SignupWithEmailAndPassword;
+  signupWithEmail?: SignupWithEmail;
 
   loginWithOAuth?: LoginWithOAuthConfig<S>;
 
@@ -417,7 +424,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,15 +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
->;
+  | 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

@@ -1,21 +1,33 @@
-import e from "express";
+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 { LoginResponseHandler } from "./setLoginRequestHandler";
+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: LoginResponseHandler, data: MagicLinkOrOTPData) => {
+  const handler = async (
+    req: ExpressReq,
+    res: MagicLinkResponseHandler,
+    data: MagicLinkOrOTPData
+  ) => {
     try {
       const response = await throttledAuthCall(async () => {
         return onMagicLink(
@@ -26,17 +38,19 @@ export function setMagicLinkOrOTPRequestHandler(
         );
       });
       if (!response.session) {
-        res.status(HTTP_FAIL_CODES.UNAUTHORIZED).json(response.response);
+        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.UNAUTHORIZED)
+        .status(HTTP_FAIL_CODES.BAD_REQUEST)
         .json({ success: false, code: "something-went-wrong" });
     }
   };
-  app.get(AUTH_ROUTES_AND_PARAMS.magicLinksExpressRoute, (req, res: LoginResponseHandler) => {
+  app.get(AUTH_ROUTES_AND_PARAMS.magicLinksIdParam, (req, res: MagicLinkResponseHandler) => {
     const { id } = req.params;
 
     if (typeof id !== "string" || !id) {
@@ -46,18 +60,18 @@ export function setMagicLinkOrOTPRequestHandler(
     }
     return handler(req, res, { type: "magic-link", magicId: id });
   });
-  app.post(AUTH_ROUTES_AND_PARAMS.magicLinksRoute, (req, res: LoginResponseHandler) => {
+  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 code" });
+        .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: "something-went-wrong", message: "Invalid email" });
+        .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, requirePassword }: SignupWithEmail,
   app: e.Express
 ) => {
   const registerRequestHandler = async (req: Request, res: RegisterResponseHandler) => {
@@ -24,7 +24,7 @@ export const setRegisterRequestHandler = async (
         .status(HTTP_FAIL_CODES.BAD_REQUEST)
         .json({ success: false, code: "something-went-wrong", message: error });
     }
-    const { username, password } = data;
+    const { username, password = "" } = data;
     const sendResponse = (response: ReturnType) => {
       if (response.success) {
         res.json(response);
@@ -35,7 +35,7 @@ export const setRegisterRequestHandler = async (
     if (!username) {
       return sendResponse({ success: false, code: "username-missing" });
     }
-    if (!password) {
+    if (!password && requirePassword) {
       return sendResponse({ success: false, code: "password-missing" });
     } else if (password.length < minPasswordLength) {
       return sendResponse({
@@ -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,8 +1,7 @@
-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 { setMagicLinkOrOTPRequestHandler } from "./endpoints/setMagicLinkOrOTPRequestHandler";
 import { setOAuthRequestHandlers } from "./endpoints/setOAuthRequestHandlers";
@@ -25,7 +24,7 @@ export async function setupAuthRoutes(this: AuthHandler) {
     onMagicLinkOrOTP,
     use,
     loginWithOAuth,
-    signupWithEmailAndPassword,
+    signupWithEmail: signupWithEmailAndPassword,
   } = loginSignupConfig;
   if (publicRoutes.find((r) => typeof r !== "string" || !r)) {
     throw "Invalid or empty string provided within publicRoutes ";
@@ -33,7 +32,6 @@ export async function setupAuthRoutes(this: AuthHandler) {
 
   if (signupWithEmailAndPassword) {
     setRegisterRequestHandler(signupWithEmailAndPassword, app);
-    setConfirmEmailRequestHandler.bind(this)(signupWithEmailAndPassword, app);
   }
 
   if (loginWithOAuth) {
@@ -42,7 +40,7 @@ export async function setupAuthRoutes(this: AuthHandler) {
 
   if (use) {
     const prostglesUseMiddleware: RequestHandler = (req, res, next) => {
-      use({
+      void use({
         req,
         res,
         next,

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;
     }