prostgles-server 4.2.192 → 4.2.193

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -109,12 +109,12 @@ export class ViewHandler {
     error?: any;
   }) => {
     if (localParams?.noLog) {
-      if (localParams.socket || localParams.httpReq) {
+      if (localParams.clientReq) {
         throw new Error("noLog option is not allowed from a remote client");
       }
       return;
     }
-    const sid = this.dboBuilder.prostgles.authHandler?.getSIDNoError(localParams);
+    const sid = this.dboBuilder.prostgles.authHandler?.getSIDNoError(localParams?.clientReq);
     return this.dboBuilder.prostgles.opts.onLog?.({
       type: "table",
       command,
@@ -122,7 +122,7 @@ export class ViewHandler {
       error,
       txInfo: this.tx?.t.ctx,
       sid,
-      socketId: localParams?.socket?.id,
+      socketId: localParams?.clientReq?.socket?.id,
       tableName: this.name,
       data,
       localParams,
@@ -148,39 +148,40 @@ export class ViewHandler {
 
   validateViewRules = validateViewRules.bind(this);
 
-  getShortestJoin(
-    table1: string,
-    table2: string,
-    startAlias: number,
-    isInner = false
-  ): { query: string; toOne: boolean } {
-    const getJoinCondition = (
-      on: Record<string, string>[],
-      leftTable: string,
-      rightTable: string
-    ) => {
-      return on
-        .map((cond) =>
-          Object.keys(cond)
-            .map((lKey) => `${leftTable}.${lKey} = ${rightTable}.${cond[lKey]}`)
-            .join("\nAND ")
-        )
-        .join(" OR ");
-    };
-
-    // let toOne = true;
-    const query = this.joins
-      .map(({ tables, on, type }, i) => {
-        if (type.split("-")[1] === "many") {
-          // toOne = false;
-        }
-        const tl = `tl${startAlias + i}`,
-          tr = `tr${startAlias + i}`;
-        return `FROM ${tables[0]} ${tl} ${isInner ? "INNER" : "LEFT"} JOIN ${tables[1]} ${tr} ON ${getJoinCondition(on, tl, tr)}`;
-      })
-      .join("\n");
-    return { query, toOne: false };
-  }
+  // DEAD CODE?!
+  // getShortestJoin(
+  //   table1: string,
+  //   table2: string,
+  //   startAlias: number,
+  //   isInner = false
+  // ): { query: string; toOne: boolean } {
+  //   const getJoinCondition = (
+  //     on: Record<string, string>[],
+  //     leftTable: string,
+  //     rightTable: string
+  //   ) => {
+  //     return on
+  //       .map((cond) =>
+  //         Object.keys(cond)
+  //           .map((lKey) => `${leftTable}.${lKey} = ${rightTable}.${cond[lKey]}`)
+  //           .join("\nAND ")
+  //       )
+  //       .join(" OR ");
+  //   };
+
+  //   // let toOne = true;
+  //   const query = this.joins
+  //     .map(({ tables, on, type }, i) => {
+  //       if (type.split("-")[1] === "many") {
+  //         // toOne = false;
+  //       }
+  //       const tl = `tl${startAlias + i}`,
+  //         tr = `tr${startAlias + i}`;
+  //       return `FROM ${tables[0]} ${tl} ${isInner ? "INNER" : "LEFT"} JOIN ${tables[1]} ${tr} ON ${getJoinCondition(on, tl, tr)}`;
+  //     })
+  //     .join("\n");
+  //   return { query, toOne: false };
+  // }
 
   checkFilter(filter: any) {
     if (filter === null || (filter && !isObject(filter)))
@@ -192,7 +193,7 @@ export class ViewHandler {
   getColumns = getColumns.bind(this);
 
   getValidatedRules(tableRules?: TableRule, localParams?: LocalParams): ValidatedTableRules {
-    if (localParams?.socket && !tableRules) {
+    if (localParams?.clientReq?.socket && !tableRules) {
       throw "INTERNAL ERROR: Unexpected case -> localParams && !tableRules";
     }
 

package/lib/DboBuilder/ViewHandler/find.ts

@@ -203,7 +203,7 @@ export const runQueryReturnType = async ({
         })
       );
   } else if (sqlTypes.some((v) => v === returnType)) {
-    if (!(await canRunSQL(handler.dboBuilder.prostgles, localParams))) {
+    if (!(await canRunSQL(handler.dboBuilder.prostgles, localParams?.clientReq))) {
       throw `Not allowed:  { returnType: ${JSON.stringify(returnType)} } requires execute sql privileges `;
     }
     if (returnType === "statement-no-rls") {

package/lib/DboBuilder/ViewHandler/getExistsCondition.ts

@@ -29,15 +29,15 @@ export async function getExistsCondition(
     tableAlias;
 
   /* Check if allowed to view data - forcedFilters will bypass this check through isForcedFilterBypass */
-  if (localParams?.isRemoteRequest && !localParams.socket && !localParams.httpReq) {
-    throw "Unexpected: localParams isRemoteRequest and missing socket/httpReq: ";
+  if (localParams?.isRemoteRequest && !localParams.clientReq) {
+    throw "Unexpected: localParams isRemoteRequest and missing clientReq";
   }
   const targetTable = eConfig.isJoined ? eConfig.parsedPath.at(-1)!.table : eConfig.targetTable;
-  if ((localParams?.socket || localParams?.httpReq) && this.dboBuilder.publishParser) {
+  if (localParams?.clientReq && this.dboBuilder.publishParser) {
     t2Rules = (await this.dboBuilder.publishParser.getValidatedRequestRuleWusr({
       tableName: targetTable,
       command: "find",
-      localParams,
+      clientReq: localParams.clientReq,
     })) as TableRule | undefined;
 
     if (!t2Rules || !t2Rules.select) throw "Dissallowed";

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -1,8 +1,4 @@
-import {
-  AnyObject,
-  SubscribeParams,
-  SubscriptionChannels,
-} from "prostgles-types";
+import { AnyObject, SubscribeParams, SubscriptionChannels } from "prostgles-types";
 import { TableRule } from "../../PublishParser/PublishParser";
 import {
   Filter,
@@ -23,38 +19,33 @@ export type LocalFuncs =
     }
   | OnData;
 
-export const getOnDataFunc = (
-  localFuncs: LocalFuncs | undefined,
-): OnData | undefined => {
+export const getOnDataFunc = (localFuncs: LocalFuncs | undefined): OnData | undefined => {
   return typeof localFuncs === "function" ? localFuncs : localFuncs?.onData;
 };
 export const matchesLocalFuncs = (
   localFuncs1: LocalFuncs | undefined,
-  localFuncs2: LocalFuncs | undefined,
+  localFuncs2: LocalFuncs | undefined
 ) => {
-  return (
-    localFuncs1 &&
-    localFuncs2 &&
-    getOnDataFunc(localFuncs1) === getOnDataFunc(localFuncs2)
-  );
+  return localFuncs1 && localFuncs2 && getOnDataFunc(localFuncs1) === getOnDataFunc(localFuncs2);
 };
 export const parseLocalFuncs = (
-  localFuncs1: LocalFuncs | undefined,
+  localFuncs1: LocalFuncs | undefined
 ): Extract<LocalFuncs, { onData: OnData }> | undefined => {
-  return !localFuncs1
-    ? undefined
-    : typeof localFuncs1 === "function"
-      ? {
-          onData: localFuncs1,
-        }
-      : localFuncs1;
+  return (
+    !localFuncs1 ? undefined
+    : typeof localFuncs1 === "function" ?
+      {
+        onData: localFuncs1,
+      }
+    : localFuncs1
+  );
 };
 
 async function subscribe(
   this: ViewHandler,
   filter: Filter,
   params: SubscribeParams,
-  localFuncs: LocalFuncs,
+  localFuncs: LocalFuncs
 ): Promise<{ unsubscribe: () => any }>;
 async function subscribe(
   this: ViewHandler,
@@ -62,7 +53,7 @@ async function subscribe(
   params: SubscribeParams,
   localFuncs: undefined,
   table_rules: TableRule | undefined,
-  localParams: LocalParams,
+  localParams: LocalParams
 ): Promise<SubscriptionChannels>;
 async function subscribe(
   this: ViewHandler,
@@ -70,7 +61,7 @@ async function subscribe(
   params: SubscribeParams,
   localFuncs?: LocalFuncs,
   table_rules?: TableRule,
-  localParams?: LocalParams,
+  localParams?: LocalParams
 ): Promise<{ unsubscribe: () => any } | SubscriptionChannels> {
   const start = Date.now();
   try {
@@ -81,10 +72,11 @@ async function subscribe(
     if (this.tx) {
       throw "subscribe not allowed within transactions";
     }
-    if (!localParams && !localFuncs) {
+    const clientReq = localParams?.clientReq;
+    if (!clientReq && !localFuncs) {
       throw " missing data. provide -> localFunc | localParams { socket } ";
     }
-    if (localParams?.socket && localFuncs) {
+    if (clientReq?.socket && localFuncs) {
       console.error({ localParams, localFuncs });
       throw " Cannot have localFunc AND socket ";
     }
@@ -92,25 +84,14 @@ async function subscribe(
     const { throttle = 0, throttleOpts, ...selectParams } = params;
 
     /** Ensure request is valid */
-    await this.find(
-      filter,
-      { ...selectParams, limit: 0 },
-      undefined,
-      table_rules,
-      localParams,
-    );
-
-    // TODO: Implement comprehensive canSubscribe check
-    // if (!this.dboBuilder.prostgles.isSuperUser) {
-    //   throw "Subscribe not possible. Must be superuser";
-    // }
+    await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, localParams);
 
     const newQuery: NewQuery = (await this.find(
       filter,
       { ...selectParams, limit: 0 },
       undefined,
       table_rules,
-      { ...localParams, returnNewQuery: true },
+      { ...localParams, returnNewQuery: true }
     )) as any;
     const viewOptions = await getSubscribeRelatedTables.bind(this)({
       filter,
@@ -135,7 +116,7 @@ async function subscribe(
 
     const pubSubManager = await this.dboBuilder.getPubSubManager();
     if (!localFuncs) {
-      const { socket } = localParams ?? {};
+      const { socket } = clientReq ?? {};
       const result = await pubSubManager.addSub({
         ...commonSubOpts,
         socket,

package/lib/DboBuilder/dboBuilderUtils.ts

@@ -89,7 +89,9 @@ export function getSerializedClientErrorFromPGError(
   const isServerSideRequest = !args.localParams;
   //TODO: add a rawSQL check for HTTP requests
   const showFullError =
-    isServerSideRequest || args.type === "sql" || args.localParams?.socket?.prostgles?.rawSQL;
+    isServerSideRequest ||
+    args.type === "sql" ||
+    args.localParams?.clientReq?.socket?.prostgles?.rawSQL;
   if (showFullError) {
     return err;
   }

package/lib/DboBuilder/insertNestedRecords.ts

@@ -3,12 +3,13 @@ import { LocalParams, TableHandlers } from "./DboBuilder";
 import { TableRule } from "../PublishParser/PublishParser";
 import { omitKeys } from "../PubSubManager/PubSubManager";
 import { TableHandler } from "./TableHandler/TableHandler";
+import { AuthClientRequest } from "../Auth/AuthTypes";
 
 type InsertNestedRecordsArgs = {
   data: AnyObject | AnyObject[];
   param2?: InsertParams;
-  tableRules?: TableRule;
-  localParams?: LocalParams;
+  tableRules: TableRule | undefined;
+  localParams: LocalParams | undefined;
 };
 
 /**
@@ -16,7 +17,7 @@ type InsertNestedRecordsArgs = {
  */
 export async function insertNestedRecords(
   this: TableHandler,
-  { data, param2, tableRules, localParams = {} }: InsertNestedRecordsArgs
+  { data, param2, tableRules, localParams }: InsertNestedRecordsArgs
 ): Promise<{
   data?: AnyObject | AnyObject[];
   insertResult?: AnyObject | AnyObject[];
@@ -60,7 +61,7 @@ export async function insertNestedRecords(
    * Make sure nested insert uses a transaction
    */
   const dbTX = this.getFinalDBtx(localParams);
-  const t = localParams.tx?.t || this.tx?.t;
+  const t = localParams?.tx?.t || this.tx?.t;
   if (hasNestedInserts && (!dbTX || !t)) {
     return {
       insertResult: await this.dboBuilder.getTX((dbTX, _t) =>
@@ -107,7 +108,7 @@ export async function insertNestedRecords(
             const newLocalParams: LocalParams = {
               ...localParams,
               nestedInsert: {
-                depth: (localParams.nestedInsert?.depth ?? 0) + 1,
+                depth: (localParams?.nestedInsert?.depth ?? 0) + 1,
                 previousData: rootData,
                 previousTable: this.name,
                 referencingColumn: colInsert.col,
@@ -165,9 +166,14 @@ export async function insertNestedRecords(
 
         await Promise.all(
           extraKeys.map(async (targetTable) => {
-            const childDataItems =
+            const childDataItems: AnyObject[] =
               Array.isArray(row[targetTable]) ? row[targetTable] : [row[targetTable]];
 
+            /** check */
+            if (childDataItems.some((d) => !isObject(d))) {
+              throw "Expected array of objects";
+            }
+
             const childInsert = async (cdata: AnyObject | AnyObject[], tableName: string) => {
               return referencedInsert(this, dbTX, localParams, tableName, cdata);
             };
@@ -176,7 +182,7 @@ export async function insertNestedRecords(
 
             const { path } = joinPath;
             const [tbl1, tbl2, tbl3] = path;
-            targetTableRules = await getInsertTableRules(this, targetTable, localParams);
+            targetTableRules = await getInsertTableRules(this, targetTable, localParams?.clientReq);
 
             const cols2 = this.dboBuilder.dbo[tbl2!]!.columns || [];
             if (!this.dboBuilder.dbo[tbl2!]) throw "Invalid/disallowed table: " + tbl2;
@@ -299,12 +305,12 @@ export async function insertNestedRecords(
 export const getInsertTableRules = async (
   tableHandler: TableHandler,
   targetTable: string,
-  localParams: LocalParams
+  clientReq: AuthClientRequest | undefined
 ) => {
   const childRules = await tableHandler.dboBuilder.publishParser?.getValidatedRequestRuleWusr({
     tableName: targetTable,
     command: "insert",
-    localParams,
+    clientReq,
   });
   if (!childRules || !childRules.insert) throw "Dissallowed nested insert into table " + childRules;
   return childRules;
@@ -332,22 +338,18 @@ const getJoinPath = async (
 const referencedInsert = async (
   tableHandler: TableHandler,
   dbTX: TableHandlers | undefined,
-  localParams: LocalParams,
+  localParams: LocalParams | undefined,
   targetTable: string,
   targetData: AnyObject | AnyObject[]
 ): Promise<AnyObject[]> => {
   await getJoinPath(tableHandler, targetTable);
 
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (!targetData || !dbTX?.[targetTable] || !("insert" in dbTX[targetTable]!)) {
+  if (!dbTX?.[targetTable] || !("insert" in dbTX[targetTable]!)) {
     throw new Error("childInsertErr: Table handler missing for referenced table: " + targetTable);
   }
 
-  const childRules = await getInsertTableRules(tableHandler, targetTable, localParams);
+  const childRules = await getInsertTableRules(tableHandler, targetTable, localParams?.clientReq);
 
-  // if (thisInfo.has_media === "one" && thisInfo.media_table_name === targetTable && Array.isArray(targetData) && targetData.length > 1) {
-  //   throw "Constraint check fail: Cannot insert more than one record into " + JSON.stringify(targetTable);
-  // }
   return Promise.all(
     (Array.isArray(targetData) ? targetData : [targetData]).map((m) =>
       (dbTX![targetTable] as TableHandler)

package/lib/DboBuilder/runSQL.ts

@@ -3,13 +3,14 @@ import pg from "pg-promise/typescript/pg-subset";
 import { AnyObject, SQLOptions, SQLResult, SQLResultInfo } from "prostgles-types";
 import { DB, Prostgles } from "../Prostgles";
 import { DboBuilder, LocalParams, pgp, postgresToTsType } from "./DboBuilder";
+import { AuthClientRequest } from "../Auth/AuthTypes";
 
 export async function runSQL(
   this: DboBuilder,
   queryWithoutRLS: string,
   args: undefined | AnyObject | any[],
   options: SQLOptions | undefined,
-  localParams?: LocalParams
+  localParams: LocalParams | undefined
 ) {
   const queryWithRLS = queryWithoutRLS;
   if (
@@ -29,17 +30,17 @@ export async function runSQL(
 
   await this.cacheDBTypes();
 
-  if (!(await canRunSQL(this.prostgles, localParams))) {
+  if (!(await canRunSQL(this.prostgles, localParams?.clientReq))) {
     throw "Not allowed to run SQL";
   }
 
   const { returnType, allowListen, hasParams = true }: SQLOptions = options || ({} as SQLOptions);
-  const { socket } = localParams || {};
+  const { socket } = localParams?.clientReq ?? {};
 
   const db = localParams?.tx?.t || this.db;
   if (returnType === "stream") {
     if (localParams?.tx) throw "Cannot use stream with localParams transaction";
-    if (!socket) throw "Only allowed with client socket";
+    if (!socket) throw "stream allowed only with client socket";
     const streamInfo = await this.queryStreamer.create({
       socket,
       query: pgp.as.format(queryWithRLS, args),
@@ -47,7 +48,7 @@ export async function runSQL(
     });
     return streamInfo;
   } else if (returnType === "noticeSubscription") {
-    if (!socket) throw "Only allowed with client socket";
+    if (!socket) throw "noticeSubscription allowed only with client socket";
     return await this.prostgles.dbEventsManager?.addNotice(socket);
   } else if (returnType === "statement") {
     try {
@@ -86,7 +87,7 @@ export async function runSQL(
     queryWithoutRLS,
     queryResult,
     allowListen,
-    localParams
+    localParams?.clientReq
   );
   if (listenHandlers) {
     return listenHandlers;
@@ -115,7 +116,7 @@ const onSQLResult = async function (
   queryWithoutRLS: string,
   { command }: Omit<SQLResultInfo, "duration">,
   allowListen: boolean | undefined,
-  localParams?: LocalParams
+  clientReq: AuthClientRequest | undefined
 ) {
   this.prostgles.schemaWatch?.onSchemaChangeFallback?.({
     command,
@@ -123,12 +124,12 @@ const onSQLResult = async function (
   });
 
   if (command === "LISTEN") {
-    const { socket } = localParams || {};
+    const { socket } = clientReq || {};
     if (!allowListen)
       throw new Error(
         `Your query contains a LISTEN command. Set { allowListen: true } to get subscription hooks. Or ignore this message`
       );
-    if (!socket) throw "Only allowed with client socket";
+    if (!socket) throw "LISTEN allowed only with client socket";
     return await this.prostgles.dbEventsManager?.addNotify(queryWithoutRLS, socket);
   }
 };
@@ -188,14 +189,11 @@ export function getDetailedFieldInfo(this: DboBuilder, fields: pg.IColumn[]) {
 
 export const canRunSQL = async (
   prostgles: Prostgles,
-  localParams?: LocalParams
+  clientReq: AuthClientRequest | undefined
 ): Promise<boolean> => {
-  if (!localParams?.socket || !localParams.httpReq) return true;
+  if (!clientReq) return true;
 
-  const { socket } = localParams;
-  const publishParams = await prostgles.publishParser!.getPublishParams({
-    socket,
-  });
+  const publishParams = await prostgles.publishParser!.getPublishParams(clientReq);
   //@ts-ignore
   const res = await prostgles.opts.publishRawSQL?.(publishParams);
   return Boolean((res && typeof res === "boolean") || res === "*");
@@ -204,5 +202,5 @@ export const canRunSQL = async (
 export const canCreateTables = async (db: DB): Promise<boolean> => {
   return db
     .any(`SELECT has_database_privilege(current_database(), 'create') as yes`)
-    .then((rows) => rows[0].yes === true);
+    .then((rows: { yes: boolean }[]) => rows[0]?.yes === true);
 };

package/lib/FileManager/initFileManager.ts

@@ -1,5 +1,5 @@
 import * as fs from "fs";
-import { asName, tryCatch } from "prostgles-types";
+import { asName, tryCatch, tryCatchV2 } from "prostgles-types";
 import { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
 import { canCreateTables } from "../DboBuilder/runSQL";
 import { Prostgles } from "../Prostgles";
@@ -24,7 +24,7 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
 
   const canCreate = await canCreateTables(this.db);
   const runQuery = async (q: string, debugInfo: string): Promise<void> => {
-    const res = await tryCatch(async () => {
+    const res = await tryCatchV2(async () => {
       if (!canCreate)
         throw "File table creation failed. Your postgres user does not have CREATE table privileges";
       await this.db.any(q);
@@ -35,7 +35,7 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
       ...res,
       data: { debugInfo },
     });
-    if (res.error) {
+    if (res.hasError) {
       throw res.error;
     }
   };
@@ -161,15 +161,19 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
           content_type: 1,
         },
       };
-      const media = await runClientRequest.bind(this.prostgles)({
-        type: "http",
-        httpReq: req,
-        command: "findOne",
-        tableName,
-        param1: { id },
-        param2: selectParams,
-        param3: undefined,
-      });
+      const media = await runClientRequest.bind(this.prostgles)(
+        {
+          command: "findOne",
+          tableName,
+          param1: { id },
+          param2: selectParams,
+          param3: undefined,
+        },
+        {
+          res,
+          httpReq: req,
+        }
+      );
 
       if (!media) {
         res.status(HTTP_FAIL_CODES.NOT_FOUND).send("File not found or not allowed");

package/lib/Prostgles.ts

@@ -20,7 +20,6 @@ import TableConfigurator from "./TableConfig/TableConfig";
 import {
   DBHandlerServer,
   DboBuilder,
-  LocalParams,
   PRGLIOSocket,
   getErrorAsObject,
 } from "./DboBuilder/DboBuilder";
@@ -67,6 +66,7 @@ const DEFAULT_KEYWORDS = {
 
 import { randomUUID } from "crypto";
 import * as fs from "fs";
+import { AuthClientRequest } from "./Auth/AuthTypes";
 
 export class Prostgles {
   /**
@@ -383,14 +383,7 @@ export class Prostgles {
 
     if (!this.dbo) throw "dbo missing";
 
-    const publishParser = new PublishParser(
-      this.opts.publish,
-      this.opts.publishMethods,
-      this.opts.publishRawSQL,
-      this.dbo,
-      this.db!,
-      this
-    );
+    const publishParser = new PublishParser(this);
     this.publishParser = publishParser;
 
     if (!this.opts.io) return;
@@ -413,15 +406,14 @@ export class Prostgles {
 
   onSocketConnected = onSocketConnected.bind(this);
 
-  getClientSchema = async (clientReq: Pick<LocalParams, "socket" | "httpReq">) => {
+  getClientSchema = async (clientReq: AuthClientRequest) => {
     const result = await tryCatchV2(async () => {
       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";
+        clientReq.socket ?
+          { type: "socket" as const, ...clientReq }
+        : { type: "http" as const, ...clientReq };
 
-      const userData = await this.authHandler?.getClientInfo(clientInfo);
+      const userData = await this.authHandler?.getUserFromRequest(clientInfo);
       const { publishParser } = this;
       let fullSchema: Awaited<ReturnType<PublishParser["getSchemaFromPublish"]>> | undefined;
       let publishValidationError;
@@ -501,7 +493,7 @@ export class Prostgles {
         userData,
       };
     });
-    const sid = result.data?.userData?.sid ?? this.authHandler?.getSIDNoError(clientReq);
+    const sid = this.authHandler?.getSIDNoError(clientReq);
     await this.opts.onLog?.({
       type: "connect.getClientSchema",
       duration: result.duration,
@@ -522,19 +514,13 @@ export class Prostgles {
         socket.on(
           CHANNELS.SQL,
           async (
-            { query, params, options }: SQLRequest,
+            sqlRequestData: SQLRequest,
             cb = (..._callback: any) => {
               /* Empty */
             }
           ) => {
             runClientSqlRequest
-              .bind(this)({
-                type: "socket",
-                socket,
-                query,
-                args: params,
-                options,
-              })
+              .bind(this)(sqlRequestData, { socket })
               .then((res) => {
                 cb(null, res);
               })