prostgles-server 4.2.187 → 4.2.188

package/lib/JSONBValidation/validation.ts

@@ -1,10 +1,4 @@
-import {
-  getKeys,
-  isEmpty,
-  isObject,
-  JSONB,
-  TableSchema,
-} from "prostgles-types";
+import { getKeys, isEmpty, isObject, JSONB, TableSchema } from "prostgles-types";
 import { postgresToTsType } from "../DboBuilder/DboBuilder";
 import { asValue } from "../PubSubManager/PubSubManager";
 
@@ -14,33 +8,21 @@ const getFieldTypeObj = (rawFieldType: JSONB.FieldType): JSONB.FieldTypeObj => {
   return rawFieldType;
 };
 
-export function validate<T>(
-  obj: T,
-  key: keyof T,
-  rawFieldType: JSONB.FieldType,
-): boolean {
+export function validate<T>(obj: T, key: keyof T, rawFieldType: JSONB.FieldType): boolean {
   let err = `The provided value for ${JSON.stringify(key)} is of invalid type. Expecting `;
   const val = obj[key];
   const fieldType = getFieldTypeObj(rawFieldType);
   if ("type" in fieldType && fieldType.type) {
     if (typeof fieldType.type !== "string") {
       getKeys(fieldType.type).forEach((subKey) => {
-        validate(
-          val,
-          subKey as any,
-          (fieldType.type as JSONB.ObjectType["type"])[subKey]!,
-        );
+        validate(val, subKey as any, (fieldType.type as JSONB.ObjectType["type"])[subKey]!);
       });
     }
     err += fieldType.type;
-    if (fieldType.type === "boolean" && typeof val !== fieldType.type)
-      throw new Error(err);
-    if (fieldType.type === "string" && typeof val !== fieldType.type)
-      throw new Error(err);
-    if (fieldType.type === "number" && !Number.isFinite(val))
-      throw new Error(err);
-    if (fieldType.type === "integer" && !Number.isInteger(val))
-      throw new Error(err);
+    if (fieldType.type === "boolean" && typeof val !== fieldType.type) throw new Error(err);
+    if (fieldType.type === "string" && typeof val !== fieldType.type) throw new Error(err);
+    if (fieldType.type === "number" && !Number.isFinite(val)) throw new Error(err);
+    if (fieldType.type === "integer" && !Number.isInteger(val)) throw new Error(err);
   } else if (fieldType.enum) {
     err += `on of: ${fieldType.enum}`;
     if (!fieldType.enum.includes(val)) throw new Error(err);
@@ -52,10 +34,9 @@ export function validateSchema<S extends JSONB.ObjectType["type"]>(
   schema: S,
   obj: JSONB.GetObjectType<S>,
   objName?: string,
-  optional = false,
+  optional = false
 ) {
-  if ((!schema || isEmpty(schema)) && !optional)
-    throw new Error(`Expecting ${objName} to be defined`);
+  if (isEmpty(schema) && !optional) throw new Error(`Expecting ${objName} to be defined`);
   getKeys(schema).forEach((k) => validate(obj as any, k, schema[k]!));
 }
 
@@ -65,19 +46,19 @@ export function getJSONBSchemaTSTypes(
   schema: JSONB.JSONBSchema,
   colOpts: ColOpts,
   outerLeading = "",
-  tables: TableSchema[],
+  tables: TableSchema[]
 ): string {
   const getFieldType = (
     rawFieldType: JSONB.FieldType,
     isOneOf = false,
     innerLeading = "",
-    depth = 0,
+    depth = 0
   ): string => {
     const fieldType = getFieldTypeObj(rawFieldType);
     const nullType = fieldType.nullable ? `null | ` : "";
 
     /** Primitives */
-    if (typeof fieldType?.type === "string") {
+    if (typeof fieldType.type === "string") {
       const correctType = fieldType.type
         .replace("integer", "number")
         .replace("time", "string")
@@ -86,16 +67,14 @@ export function getJSONBSchemaTSTypes(
 
       if (fieldType.allowedValues && fieldType.type.endsWith("[]")) {
         return (
-          nullType +
-          ` (${fieldType.allowedValues.map((v) => JSON.stringify(v)).join(" | ")})[]`
+          nullType + ` (${fieldType.allowedValues.map((v) => JSON.stringify(v)).join(" | ")})[]`
         );
       }
       return nullType + correctType;
 
       /** Object */
     } else if (isObject(fieldType.type)) {
-      const addSemicolonIfMissing = (v: string) =>
-        v.trim().endsWith(";") ? v : v.trim() + ";";
+      const addSemicolonIfMissing = (v: string) => (v.trim().endsWith(";") ? v : v.trim() + ";");
       const { type } = fieldType;
       const spacing = isOneOf ? " " : "  ";
       let objDef =
@@ -103,14 +82,10 @@ export function getJSONBSchemaTSTypes(
         getKeys(type)
           .map((key) => {
             const fieldType = getFieldTypeObj(type[key]!);
-            const escapedKey = isValidIdentifier(key)
-              ? key
-              : JSON.stringify(key);
+            const escapedKey = isValidIdentifier(key) ? key : JSON.stringify(key);
             return (
               `${spacing}${escapedKey}${fieldType.optional ? "?" : ""}: ` +
-              addSemicolonIfMissing(
-                getFieldType(fieldType, true, undefined, depth + 1),
-              )
+              addSemicolonIfMissing(getFieldType(fieldType, true, undefined, depth + 1))
             );
           })
           .join(" ") +
@@ -124,31 +99,25 @@ export function getJSONBSchemaTSTypes(
         objDef = objDef.split("\n").join("");
       }
       return nullType + objDef;
-    } else if (fieldType?.enum) {
+    } else if (fieldType.enum) {
       return nullType + fieldType.enum.map((v) => asValue(v)).join(" | ");
-    } else if (fieldType?.oneOf || fieldType?.oneOfType) {
-      const oneOf =
-        fieldType?.oneOf || fieldType?.oneOfType.map((type) => ({ type }));
+    } else if (fieldType.oneOf || fieldType.oneOfType) {
+      const oneOf = fieldType.oneOf || fieldType.oneOfType.map((type) => ({ type }));
       return (
         (fieldType.nullable ? `\n${innerLeading} | null` : "") +
         oneOf
-          .map(
-            (v) =>
-              `\n${innerLeading} | ` +
-              getFieldType(v, true, undefined, depth + 1),
-          )
+          .map((v) => `\n${innerLeading} | ` + getFieldType(v, true, undefined, depth + 1))
           .join("")
       );
-    } else if (fieldType?.arrayOf || fieldType?.arrayOfType) {
-      const arrayOf = fieldType?.arrayOf || { type: fieldType?.arrayOfType };
+    } else if (fieldType.arrayOf || fieldType.arrayOfType) {
+      const arrayOf = fieldType.arrayOf || { type: fieldType.arrayOfType };
       return `${fieldType.nullable ? `null | ` : ""} ( ${getFieldType(arrayOf, true, undefined, depth + 1)} )[]`;
-    } else if (fieldType?.record) {
+    } else if (fieldType.record) {
       const { keysEnum, values, partial } = fieldType.record;
       // TODO: ensure props with undefined values are not allowed in the TS type (strict union)
-      const getRecord = (v: string) =>
-        partial ? `Partial<Record<${v}>>` : `Record<${v}>`;
+      const getRecord = (v: string) => (partial ? `Partial<Record<${v}>>` : `Record<${v}>`);
       return `${fieldType.nullable ? `null |` : ""} ${getRecord(`${keysEnum?.map((v) => asValue(v)).join(" | ") ?? "string"}, ${!values ? "any" : getFieldType(values, true, undefined, depth + 1)}`)}`;
-    } else if (fieldType?.lookup) {
+    } else if (fieldType.lookup) {
       const l = fieldType.lookup;
       if (l.type === "data-def") {
         return `${fieldType.nullable ? `null |` : ""} ${getFieldType({
@@ -170,36 +139,28 @@ export function getJSONBSchemaTSTypes(
       }
 
       const isSChema = l.type === "schema";
-      let type = isSChema
-        ? l.object === "table"
-          ? "string"
+      let type =
+        isSChema ?
+          l.object === "table" ?
+            "string"
           : `{ "table": string; "column": string; }`
         : "";
       if (!isSChema) {
         const cols = tables.find((t) => t.name === l.table)?.columns;
         if (!l.isFullRow) {
-          type = postgresToTsType(
-            cols?.find((c) => c.name === l.column)?.udt_name ?? "text",
-          );
+          type = postgresToTsType(cols?.find((c) => c.name === l.column)?.udt_name ?? "text");
         } else {
-          type = !cols
-            ? "any"
-            : `{ ${cols.map((c) => `${JSON.stringify(c.name)}: ${c.is_nullable ? "null | " : ""} ${postgresToTsType(c.udt_name)}; `).join(" ")} }`;
+          type =
+            !cols ? "any" : (
+              `{ ${cols.map((c) => `${JSON.stringify(c.name)}: ${c.is_nullable ? "null | " : ""} ${postgresToTsType(c.udt_name)}; `).join(" ")} }`
+            );
         }
       }
       return `${fieldType.nullable ? `null | ` : ""}${type}${l.isArray ? "[]" : ""}`;
-    } else
-      throw (
-        "Unexpected getSchemaTSTypes: " +
-        JSON.stringify({ fieldType, schema }, null, 2)
-      );
+    } else throw "Unexpected getSchemaTSTypes: " + JSON.stringify({ fieldType, schema }, null, 2);
   };
 
-  return getFieldType(
-    { ...(schema as any), nullable: colOpts.nullable },
-    undefined,
-    outerLeading,
-  );
+  return getFieldType({ ...(schema as any), nullable: colOpts.nullable }, undefined, outerLeading);
 }
 
 const isValidIdentifier = (str: string) => {

package/lib/Logging.ts

@@ -97,7 +97,7 @@ export namespace EventTypes {
   export type Auth = ClientInfo &
     DebugInfo & {
       type: "auth";
-    } & ({ command: "getClientInfo" } | { command: "login" });
+    } & ({ command: "getClientInfo" } | { command: "login"; success: boolean });
 
   export type Debug = DebugInfo &
     (

package/lib/PostgresNotifListenManager.ts

@@ -26,14 +26,9 @@ export class PostgresNotifListenManager {
   static create = (
     db_pg: DB,
     notifListener: PrglNotifListener,
-    db_channel_name: string,
+    db_channel_name: string
   ): Promise<PostgresNotifListenManager> => {
-    const res = new PostgresNotifListenManager(
-      db_pg,
-      notifListener,
-      db_channel_name,
-      true,
-    );
+    const res = new PostgresNotifListenManager(db_pg, notifListener, db_channel_name, true);
     return res.init();
   };
 
@@ -41,9 +36,9 @@ export class PostgresNotifListenManager {
     db_pg: DB,
     notifListener: PrglNotifListener,
     db_channel_name: string,
-    noInit = false,
+    noInit = false
   ) {
-    if (!db_pg || !notifListener || !db_channel_name)
+    if (!db_channel_name)
       throw "PostgresNotifListenManager: db_pg OR notifListener OR db_channel_name MISSING";
     this.db_pg = db_pg;
     this.notifListener = notifListener;
@@ -64,14 +59,8 @@ export class PostgresNotifListenManager {
   }
 
   startListening() {
-    if (!this.db_pg || !this.notifListener)
-      throw "PostgresNotifListenManager: db_pg OR notifListener missing";
-
     return this.reconnect().catch((error) => {
-      console.log(
-        "PostgresNotifListenManager: Failed Initial Connection:",
-        error,
-      );
+      console.log("PostgresNotifListenManager: Failed Initial Connection:", error);
     });
   }
 
@@ -92,13 +81,7 @@ export class PostgresNotifListenManager {
     }
   };
 
-  reconnect(
-    delay: number | undefined = 0,
-    maxAttempts: number | undefined = 0,
-  ) {
-    if (!this.db_pg || !this.notifListener)
-      throw "db_pg OR notifListener missing";
-
+  reconnect(delay: number | undefined = 0, maxAttempts: number | undefined = 0) {
     if (this.destroyed) {
       return Promise.reject("Destroyed");
     }
@@ -109,7 +92,7 @@ export class PostgresNotifListenManager {
     const setListeners = (
         client: pg.IClient,
         notifListener: PrglNotifListener,
-        db_channel_name: string,
+        db_channel_name: string
       ) => {
         client.on("notification", notifListener);
         this.client = client;
@@ -117,13 +100,10 @@ export class PostgresNotifListenManager {
         return this.connection
           .none(
             `/* prostgles-server internal query used for subscriptions and schema hot reload */ \nLISTEN $1~`,
-            db_channel_name,
+            db_channel_name
           )
           .catch((error) => {
-            console.log(
-              "PostgresNotifListenManager: unexpected error: ",
-              error,
-            ); // unlikely to ever happen
+            console.log("PostgresNotifListenManager: unexpected error: ", error); // unlikely to ever happen
           });
       },
       removeListeners = (client: pg.IClient) => {
@@ -141,7 +121,7 @@ export class PostgresNotifListenManager {
           .catch(() => {
             // failed after 10 attempts
             console.log(
-              "PostgresNotifListenManager: Connection Lost Permanently. No more retryies",
+              "PostgresNotifListenManager: Connection Lost Permanently. No more retryies"
             );
             // process.exit(); // exiting the process
           });
@@ -154,11 +134,7 @@ export class PostgresNotifListenManager {
           .then((obj) => {
             this.connection = obj; // global connection is now available
             resolve(obj);
-            return setListeners(
-              obj.client,
-              this.notifListener,
-              this.db_channel_name,
-            );
+            return setListeners(obj.client, this.notifListener, this.db_channel_name);
           })
           .catch((error) => {
             /** Database was destroyed */

package/lib/Prostgles.ts

@@ -9,10 +9,7 @@ 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 { clientCanRunSqlRequest, runClientSqlRequest } from "./runClientRequest";
 import pg = require("pg-promise/typescript/pg-subset");
 const { version } = require("../package.json");
 
@@ -30,33 +27,15 @@ import {
 export { DBHandlerServer };
 export type PGP = pgPromise.IMain<{}, pg.IClient>;
 
-import {
-  CHANNELS,
-  ClientSchema,
-  SQLRequest,
-  isObject,
-  omitKeys,
-  tryCatch,
-} from "prostgles-types";
+import { CHANNELS, ClientSchema, SQLRequest, isObject, omitKeys, tryCatch } from "prostgles-types";
 import { DBEventsManager } from "./DBEventsManager";
 import { PublishParser } from "./PublishParser/PublishParser";
-export {
-  getOrSetTransporter,
-  sendEmail,
-  verifySMTPConfig,
-} from "./Auth/sendEmail";
+export { getOrSetTransporter, sendEmail, verifySMTPConfig } from "./Auth/sendEmail";
 
 export type DB = pgPromise.IDatabase<{}, pg.IClient>;
 export type DBorTx = DB | pgPromise.ITask<{}>;
 
-export const TABLE_METHODS = [
-  "update",
-  "find",
-  "findOne",
-  "insert",
-  "delete",
-  "upsert",
-] as const;
+export const TABLE_METHODS = ["update", "find", "findOne", "insert", "delete", "upsert"] as const;
 
 /*
     1. Connect to db
@@ -132,12 +111,10 @@ export class Prostgles {
   tableConfigurator?: TableConfigurator;
 
   isMedia(tableName: string) {
-    return this.opts?.fileTable?.tableName === tableName;
+    return this.opts.fileTable?.tableName === tableName;
   }
 
   constructor(params: ProstglesInitOptions) {
-    if (!params) throw "ProstglesInitOptions missing";
-
     const config: Record<keyof ProstglesInitOptions, 1> = {
       transactions: 1,
       joins: 1,
@@ -167,18 +144,16 @@ export class Prostgles {
       testRulesOnConnect: 1,
     };
     const unknownParams = Object.keys(params).filter(
-      (key: string) => !Object.keys(config).includes(key),
+      (key: string) => !Object.keys(config).includes(key)
     );
     if (unknownParams.length) {
-      console.error(
-        `Unrecognised ProstglesInitOptions params: ${unknownParams.join()}`,
-      );
+      console.error(`Unrecognised ProstglesInitOptions params: ${unknownParams.join()}`);
     }
 
     Object.assign(this.opts, params);
 
     /* set defaults */
-    if (this.opts?.fileTable) {
+    if (this.opts.fileTable) {
       this.opts.fileTable.tableName ??= "media";
     }
     this.opts.schemaFilter ??= { public: 1 };
@@ -191,8 +166,7 @@ export class Prostgles {
   destroyed = false;
 
   checkDb() {
-    if (!this.db || !this.db.connect)
-      throw "something went wrong getting a db connection";
+    if (!this.db || !(this.db as any).connect) throw "something went wrong getting a db connection";
   }
 
   getTSFileName() {
@@ -230,16 +204,11 @@ export class Prostgles {
       fs.readFile(fullPath, "utf8", function (err, data) {
         if (err || force || data !== fileContent) {
           fs.writeFileSync(fullPath, fileContent);
-          console.log(
-            "Prostgles: Created typescript schema definition file: \n " +
-              fileName,
-          );
+          console.log("Prostgles: Created typescript schema definition file: \n " + fileName);
         }
       });
     } else if (force) {
-      console.error(
-        "Schema changed. tsGeneratedTypesDir needs to be set to reload server",
-      );
+      console.error("Schema changed. tsGeneratedTypesDir needs to be set to reload server");
     }
   }
 
@@ -259,7 +228,6 @@ export class Prostgles {
     } else {
       this.dboBuilder = await DboBuilder.create(this);
     }
-    if (!this.dboBuilder) throw "this.dboBuilder";
     this.dbo = this.dboBuilder.dbo;
     await this.opts.onLog?.({
       type: "debug",
@@ -280,7 +248,10 @@ export class Prostgles {
 
   initAuthHandler = async () => {
     this.authHandler?.destroy();
-    this.authHandler = new AuthHandler(this as any);
+    if (!this.opts.auth) {
+      return;
+    }
+    this.authHandler = new AuthHandler(this);
     await this.authHandler.init();
   };
 
@@ -330,10 +301,7 @@ export class Prostgles {
         if (!cloudClient && !localConfig)
           throw "fileTable missing param: Must provide awsS3Config OR localConfig";
 
-        this.fileManager = new FileManager(
-          cloudClient || localConfig!,
-          imageOptions,
-        );
+        this.fileManager = new FileManager(cloudClient || localConfig!, imageOptions);
 
         try {
           await this.fileManager.init(this);
@@ -368,9 +336,7 @@ export class Prostgles {
       const result = await this.db
         ?.multi(fileContent)
         .then((data) => {
-          console.log(
-            "Prostgles: SQL file executed successfuly \n    -> " + filePath,
-          );
+          console.log("Prostgles: SQL file executed successfuly \n    -> " + filePath);
           return data;
         })
         .catch((err) => {
@@ -381,17 +347,14 @@ export class Prostgles {
           if (position && length && fileContent) {
             const startLine = Math.max(
                 0,
-                fileContent.substring(0, position).split("\n").length - 2,
+                fileContent.substring(0, position).split("\n").length - 2
               ),
               endLine = startLine + 3;
 
             errMsg += "\n\n";
             errMsg += lines
               .slice(startLine, endLine)
-              .map(
-                (txt, i) =>
-                  `${startLine + i + 1} ${i === 1 ? "->" : "  "} ${txt}`,
-              )
+              .map((txt, i) => `${startLine + i + 1} ${i === 1 ? "->" : "  "} ${txt}`)
               .join("\n");
             errMsg += "\n\n";
           }
@@ -418,7 +381,7 @@ export class Prostgles {
       this.opts.publishRawSQL,
       this.dbo,
       this.db!,
-      this,
+      this
     );
     this.publishParser = publishParser;
 
@@ -437,29 +400,22 @@ export class Prostgles {
     this.opts.io.removeAllListeners("connection");
     this.opts.io.on("connection", this.onSocketConnected);
     /** In some cases io will re-init with already connected sockets */
-    this.opts.io?.sockets.sockets.forEach((socket) =>
-      this.onSocketConnected(socket),
-    );
+    this.opts.io.sockets.sockets.forEach((socket) => this.onSocketConnected(socket));
   }
 
   onSocketConnected = onSocketConnected.bind(this);
 
-  getClientSchema = async (
-    clientReq: Pick<LocalParams, "socket" | "httpReq">,
-  ) => {
+  getClientSchema = async (clientReq: Pick<LocalParams, "socket" | "httpReq">) => {
     const result = await tryCatch(async () => {
-      const clientInfo = clientReq.socket
-        ? { type: "socket" as const, socket: clientReq.socket }
-        : clientReq.httpReq
-          ? { type: "http" as const, httpReq: clientReq.httpReq }
-          : undefined;
+      const clientInfo =
+        clientReq.socket ? { type: "socket" as const, socket: clientReq.socket }
+        : clientReq.httpReq ? { type: "http" as const, httpReq: clientReq.httpReq }
+        : undefined;
       if (!clientInfo) throw "Invalid client";
-      if (!this.authHandler) throw "this.authHandler missing";
-      const userData = await this.authHandler.getClientInfo(clientInfo);
+      // if (!this.authHandler) throw "this.authHandler missing";
+      const userData = await this.authHandler?.getClientInfo(clientInfo);
       const { publishParser } = this;
-      let fullSchema:
-        | Awaited<ReturnType<PublishParser["getSchemaFromPublish"]>>
-        | undefined;
+      let fullSchema: Awaited<ReturnType<PublishParser["getSchemaFromPublish"]>> | undefined;
       let publishValidationError;
 
       try {
@@ -470,16 +426,10 @@ export class Prostgles {
         });
       } catch (e) {
         publishValidationError = e;
-        console.error(
-          `\nProstgles Publish validation failed (after socket connected):\n    ->`,
-          e,
-        );
+        console.error(`\nProstgles Publish validation failed (after socket connected):\n    ->`, e);
       }
       let rawSQL = false;
-      if (
-        this.opts.publishRawSQL &&
-        typeof this.opts.publishRawSQL === "function"
-      ) {
+      if (this.opts.publishRawSQL && typeof this.opts.publishRawSQL === "function") {
         const { allowed } = await clientCanRunSqlRequest.bind(this)(clientInfo);
         rawSQL = allowed;
       }
@@ -493,10 +443,7 @@ export class Prostgles {
       if (this.opts.joins) {
         const _joinTables2 = this.dboBuilder
           .getAllJoinPaths()
-          .filter(
-            (jp) =>
-              ![jp.t1, jp.t2].find((t) => !schema[t] || !schema[t]?.findOne),
-          )
+          .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())) {
@@ -505,13 +452,11 @@ export class Prostgles {
         });
       }
 
-      const methods = await publishParser?.getAllowedMethods(
-        clientInfo,
-        userData,
-      );
+      const methods = await publishParser?.getAllowedMethods(clientInfo, userData);
 
-      const methodSchema: ClientSchema["methods"] = !methods
-        ? []
+      const methodSchema: ClientSchema["methods"] =
+        !methods ?
+          []
         : Object.entries(methods)
             .map(([methodName, method]) => {
               if (isObject(method) && "run" in method) {
@@ -528,7 +473,7 @@ export class Prostgles {
               return aName.localeCompare(bName);
             });
 
-      const { auth } = await this.authHandler.getClientAuth(clientReq);
+      const authInfo = await this.authHandler?.getClientAuth(clientReq);
 
       const clientSchema: ClientSchema = {
         schema,
@@ -537,11 +482,9 @@ export class Prostgles {
         rawSQL,
         joinTables: joinTables2,
         tableSchemaErrors,
-        auth,
+        auth: authInfo?.auth,
         version,
-        err: publishValidationError
-          ? "Server Error: User publish validation failed."
-          : undefined,
+        err: publishValidationError ? "Server Error: User publish validation failed." : undefined,
       };
 
       return {
@@ -550,8 +493,7 @@ export class Prostgles {
         userData,
       };
     });
-    const sid =
-      result.userData?.sid ?? this.authHandler?.getSIDNoError(clientReq);
+    const sid = result.userData?.sid ?? this.authHandler?.getSIDNoError(clientReq);
     await this.opts.onLog?.({
       type: "connect.getClientSchema",
       duration: result.duration,
@@ -575,7 +517,7 @@ export class Prostgles {
             { query, params, options }: SQLRequest,
             cb = (..._callback: any) => {
               /* Empty */
-            },
+            }
           ) => {
             runClientSqlRequest
               .bind(this)({
@@ -591,7 +533,7 @@ export class Prostgles {
               .catch((err) => {
                 makeSocketError(cb, err);
               });
-          },
+          }
         );
       }
       await this.dboBuilder.prostgles.opts.onLog?.({