prostgles-server 4.2.160 → 4.2.162

package/lib/DboBuilder/QueryBuilder/getNewQuery.ts

@@ -0,0 +1,271 @@
+import { DetailedJoinSelect, JoinPath, JoinSelect, RawJoinPath, SelectParams, SimpleJoinSelect, getKeys, isEmpty, omitKeys } from "prostgles-types";
+import { TableRule } from "../../PublishParser/PublishParser";
+import { Filter, LocalParams, ValidatedTableRules } from "../DboBuilder";
+import { ViewHandler } from "../ViewHandler/ViewHandler";
+import { parseJoinPath } from "../ViewHandler/parseJoinPath";
+import { prepareSortItems } from "../ViewHandler/prepareSortItems";
+import { PrepareWhereParams } from "../ViewHandler/prepareWhere";
+import { COMPUTED_FIELDS, FUNCTIONS } from "./Functions";
+import { NewQuery, NewQueryJoin, SelectItemBuilder } from "./QueryBuilder";
+
+const JOIN_KEYS = ["$innerJoin", "$leftJoin"] as const;
+const JOIN_PARAM_KEYS = getKeys({ 
+  $condition: 1, 
+  filter: 1, 
+  having: 1, 
+  limit: 1, 
+  offset: 1, 
+  orderBy: 1, 
+  select: 1 
+} satisfies Record<keyof Omit<DetailedJoinSelect, typeof JOIN_KEYS[number]>, 1>);
+
+type ParsedJoin = 
+| { type: "detailed"; params: DetailedJoinSelect & { table: DetailedJoinSelect["$leftJoin"]; path: RawJoinPath } } 
+| { type: "simple"; params: SimpleJoinSelect; }
+| { type?: undefined; error: string; };
+
+const parseJoinSelect = (joinParams: string | JoinSelect): ParsedJoin => {
+  if(!joinParams){
+    return {
+      error: "Empty join params"
+    }
+  }
+  if(typeof joinParams === "string"){
+    if(joinParams !== "*"){
+      throw "Join select can be * or { field: 1 }"
+    }
+    return {
+      type: "simple",
+      params: joinParams
+    }
+  }
+  const [joinKey, ...otherKeys] = getKeys(joinParams).filter(k => JOIN_KEYS.includes(k as any));
+  if(otherKeys.length) {
+    return {
+      error: "Cannot specify more than one join type ( $innerJoin OR $leftJoin )"
+    }
+  } else if(joinKey) {
+
+    /* Full option join  { field_name: db.innerJoin.table_name(filter, select)  } */
+    const invalidParams = Object.keys(joinParams).filter(k => ![ ...JOIN_PARAM_KEYS, ...JOIN_KEYS ].includes(k as any));
+    if(invalidParams.length) {
+      throw "Invalid join params: " + invalidParams.join(", ");
+    }
+    const path = joinParams[joinKey] as string | JoinPath[];
+    if(Array.isArray(path) && !path.length){
+      throw `Cannot have an empty join path/tableName ${joinKey}`
+    }
+    return { 
+      type: "detailed",
+      params: {
+        ...(joinParams as DetailedJoinSelect),
+        path,
+        table: typeof path === "string"? path : path.at(-1)!.table,
+      },
+    };
+  }
+
+  return {
+    type: "simple",
+    params: joinParams as SimpleJoinSelect
+  }
+}
+
+export async function getNewQuery(
+  _this: ViewHandler,
+  filter: Filter, 
+  selectParams: (SelectParams & { alias?: string })  = {}, 
+  param3_unused = null, 
+  tableRules: TableRule | undefined, 
+  localParams: LocalParams | undefined,
+): Promise<NewQuery> {
+  const { columns } = _this;
+
+  if(localParams?.isRemoteRequest && !tableRules?.select?.fields){
+    throw `INTERNAL ERROR: publish.${_this.name}.select.fields rule missing`;
+  }
+
+  const allowedOrderByFields = !tableRules? _this.column_names.slice(0) : _this.parseFieldFilter(tableRules?.select?.orderByFields ?? tableRules?.select?.fields);
+  const allowedSelectFields = !tableRules? _this.column_names.slice(0) :  _this.parseFieldFilter(tableRules?.select?.fields);
+
+  const joinQueries: NewQueryJoin[] = [];
+
+  const { select: userSelect = "*" } = selectParams,
+    sBuilder = new SelectItemBuilder({ 
+      allowedFields: allowedSelectFields, 
+      allowedOrderByFields,
+      computedFields: COMPUTED_FIELDS, 
+      isView: _this.is_view, 
+      functions: FUNCTIONS, 
+      allFields: _this.column_names.slice(0), 
+      columns 
+    });
+
+ 
+  await sBuilder.parseUserSelect(userSelect, async (fTable, _joinParams, throwErr) => {
+
+    const j_selectParams: SelectParams = {};
+    let j_filter: Filter = {},
+        j_isLeftJoin = true,
+        j_tableRules: TableRule | undefined;
+    const j_alias = fTable;
+
+    const parsedJoin = parseJoinSelect(_joinParams);
+
+    if(!parsedJoin.type){
+      throwErr(parsedJoin.error);
+      return;
+    }
+    const j_path = parseJoinPath({ 
+      rawPath: parsedJoin.type === "simple"? fTable : parsedJoin.params.path,
+      rootTable: _this.name,
+      viewHandler: _this,
+      allowMultiOrJoin: true,
+      addShortestJoinIfMissing: true,
+    });
+
+    if(parsedJoin.params === "*"){
+        j_selectParams.select = "*";
+    } else if(parsedJoin.type === "detailed") {
+      const joinParams = parsedJoin.params;
+
+      j_isLeftJoin = !!joinParams.$leftJoin;
+      
+      j_selectParams.select = joinParams.select || "*";
+      j_filter = joinParams.filter || {};
+      j_selectParams.limit = joinParams.limit;
+      j_selectParams.offset = joinParams.offset;
+      j_selectParams.orderBy = joinParams.orderBy;
+      j_selectParams.having = joinParams.having;
+    } else {
+      j_selectParams.select = parsedJoin.params;
+    }
+    
+    const jTable = parsedJoin.type === "simple"? fTable : (typeof j_path === "string"? j_path : j_path?.at(-1)?.table);
+    if(!jTable) {
+      throw "jTable missing";
+    }
+    const _thisJoinedTable: any = _this.dboBuilder.dbo[jTable];
+    if(!_thisJoinedTable) {
+      throw `Joined table ${JSON.stringify(jTable)} is disallowed or inexistent \nOr you've forgot to put the function arguments into an array`;
+    }
+
+    let isLocal = true;
+    if(localParams && (localParams.socket || localParams.httpReq)){
+      isLocal = false;
+      j_tableRules = await _this.dboBuilder.publishParser?.getValidatedRequestRuleWusr({ tableName: jTable, command: "find", localParams });
+    }
+    
+    const isAllowedAccessToTable = isLocal || j_tableRules;
+    if(isAllowedAccessToTable){
+
+      const joinQuery: NewQuery = await getNewQuery(
+          _thisJoinedTable,
+          j_filter, 
+          { ...j_selectParams, alias: j_alias }, 
+          param3_unused, 
+          j_tableRules, 
+          localParams,
+        );
+      joinQuery.isLeftJoin = j_isLeftJoin;
+      joinQuery.tableAlias = j_alias;
+      joinQueries.push({
+        ...joinQuery,
+        joinPath: j_path,
+        joinAlias: joinQuery.tableAlias ?? joinQuery.table,
+      });
+    }
+  })
+
+  /**
+   * Is this still needed?!!!
+   * Add non selected columns
+   * This ensures all fields are available for orderBy in case of nested select
+   * */
+  Array.from(new Set([...allowedSelectFields, ...allowedOrderByFields])).map(key => {
+    if(!sBuilder.select.find(s => s.alias === key && s.type === "column")){
+      sBuilder.addColumn(key, false);
+    }
+  });
+
+  const select = sBuilder.select;
+    
+  const tableAlias = selectParams.alias;
+  const commonWhereParams: PrepareWhereParams = {
+    filter, 
+    select, 
+    forcedFilter: tableRules?.select?.forcedFilter, 
+    filterFields: tableRules?.select?.filterFields, 
+    tableAlias, 
+    localParams,
+    tableRule: tableRules,
+    isHaving: false,
+  }
+  const filterOpts = await _this.prepareWhere({
+    ...commonWhereParams,
+    isHaving: false,
+  });
+  const havingOpts = !isEmpty(selectParams.having)? await _this.prepareWhere({
+    ...omitKeys(commonWhereParams, ["forcedFilter"]),
+    filter: selectParams.having,
+    isHaving: true,
+  }) : undefined;
+  const where = filterOpts.where;
+  const validatedRules = _this.getValidatedRules(tableRules, localParams);
+
+  const resQuery: NewQuery = {
+    allFields: _this.column_names.slice(0),
+    select,
+    table: _this.name,
+    joins: joinQueries,
+    where,
+    whereOpts: filterOpts,
+    having: havingOpts?.condition ?? "",
+    isLeftJoin: false,
+    limit: prepareLimitQuery(selectParams.limit, validatedRules),
+    orderByItems: prepareSortItems(
+      selectParams.orderBy, 
+      allowedOrderByFields, 
+      selectParams.alias, 
+      select, 
+      joinQueries
+    ),
+    offset: prepareOffsetQuery(selectParams.offset)
+  };
+
+  if(resQuery.select.some(s => s.type === "aggregation") && resQuery.joins?.length){
+    throw new Error(`Root query aggregation AND nested joins not allowed`);
+  }
+
+  return resQuery;
+}
+
+const prepareOffsetQuery = (offset?: number) => {
+  if (Number.isInteger(offset)) {
+    return offset!;
+  }
+
+  return 0;
+}
+
+const prepareLimitQuery = (limit: number | null | undefined = null, p: ValidatedTableRules): number | null => {
+
+  if (limit !== undefined && limit !== null && !Number.isInteger(limit)) {
+    throw "Unexpected LIMIT. Must be null or an integer";
+  }
+
+  let _limit = limit;
+  /* If no limit then set as the lesser of (100, maxLimit) */
+  if (_limit !== null && !Number.isInteger(_limit) && p.select.maxLimit !== null) {
+    _limit = [100, p.select.maxLimit].filter(Number.isInteger).sort((a, b) => a - b)[0]!;
+  } else {
+
+    /* If a limit higher than maxLimit specified throw error */
+    if (Number.isInteger(p.select.maxLimit) && _limit !== null && _limit > p.select.maxLimit!) {
+      throw `Unexpected LIMIT ${_limit}. Must be less than the published maxLimit: ` + p.select.maxLimit;
+    }
+  }
+
+
+  return _limit;
+}

package/lib/DboBuilder/QueryBuilder/getSelectQuery.ts

@@ -0,0 +1,136 @@
+
+import { prepareOrderByQuery } from "../DboBuilder";
+import { isDefined, asName } from "prostgles-types";
+import { NewQuery } from "./QueryBuilder";
+import { ViewHandler } from "../ViewHandler/ViewHandler";
+import { getJoinQuery } from "./getJoinQuery"; 
+
+/**
+ * Used to prevent single row nested results in case of OR join conditions
+ */
+export const ROOT_TABLE_ROW_NUM_ID = "prostgles_root_table_row_id" as const;
+export const ROOT_TABLE_ALIAS = 'prostgles_root_table_alias' as const;
+
+/**
+ * Creating the text query from the NewQuery spec
+ * No validation/authorisation at this point 
+ * */
+export function getSelectQuery(
+  viewHandler: ViewHandler,
+  q: NewQuery,
+  depth = 0,
+  selectParamsGroupBy: boolean,
+): string {
+
+  const rootSelect = q.select.filter(s => s.selected).map(s => [s.getQuery(ROOT_TABLE_ALIAS), " AS ", asName(s.alias)].join(""));
+
+  const parsedJoins = q.joins?.flatMap(q2 => {
+    const parsed = getJoinQuery(
+      viewHandler, 
+      { 
+        q1: { ...q, tableAlias: ROOT_TABLE_ALIAS }, 
+        q2: { ...q2 }, 
+        selectParamsGroupBy 
+      }
+    );
+    return {
+      ...q2,
+      ...parsed
+    }
+  }) ?? [];
+
+  const selectItems = rootSelect.concat(
+    parsedJoins?.map(join => {
+      const { joinAlias } = join;
+      return `COALESCE(${asName(joinAlias)}.${join.resultAlias}, '[]') as ${asName(joinAlias)}`
+    }) ?? []);
+
+  /** OR joins cannot be easily aggregated to one-many with the root table. Must group by root table id */
+  const hasOrJoins = parsedJoins.some(j => j.isOrJoin)
+  
+  let joinCtes = !parsedJoins.length? [] : [
+    ...parsedJoins.flatMap((j, i) => {
+      const needsComma = parsedJoins.length > 1 && i < parsedJoins.length -1;
+      return j.cteLines.concat(needsComma? [","] : []);
+    })
+  ];
+
+  
+  if(hasOrJoins){
+    const pkey = viewHandler.columns.find(c => c.is_pkey);
+    joinCtes = [
+      `${q.table} AS (`,
+      `  SELECT *, ${pkey? asName(pkey.name): "ROW_NUMBER() OVER()"} as ${ROOT_TABLE_ROW_NUM_ID}`,
+      `  FROM ${q.table}`,
+      `),`,
+      ...joinCtes
+    ]
+  }
+
+  if(joinCtes.length){
+    joinCtes.unshift(`WITH `)
+  }
+
+  const query = [
+    ...joinCtes,
+    `SELECT`
+    ,...indentLines(selectItems, { appendCommas: true })
+    , `FROM ( `
+    , `  SELECT *`
+    , `  FROM ${q.table}`
+    , ...(q.where? [`  ${q.where}`] : [])
+    , `) ${ROOT_TABLE_ALIAS}`
+    , ...parsedJoins.flatMap(j => j.joinLines)
+    , ...getRootGroupBy(q, selectParamsGroupBy)
+    , ...prepareOrderByQuery(q.orderByItems)
+    , ...(q.having ? [`HAVING ${q.having} `] : [])
+    , ...(depth || q.limit === null ? [] : [`LIMIT ${q.limit || 0}`])
+    , ...(q.offset? [`OFFSET ${q.offset || 0}`] : [])
+  ];
+
+  return indentLinesToString(query);
+}
+
+const indentLine = (numberOfSpaces: number, str: string, indentStr = "    "): string => new Array(numberOfSpaces).fill(indentStr).join("") + str;
+type IndentLinesOpts = {
+  numberOfSpaces?: number;
+  indentStr?: string;
+  appendCommas?: boolean;
+}
+export const indentLines = (strArr: (string | undefined | null)[],  { numberOfSpaces = 2, indentStr = " ", appendCommas = false }: IndentLinesOpts = {}): string[] => {
+  const nonEmptyLines = strArr
+    .filter(v => v);
+
+  return nonEmptyLines.map((str, idx) => {
+      const res = indentLine(numberOfSpaces, str as string, indentStr);
+      if(appendCommas && idx < nonEmptyLines.length - 1){
+        return `${res},`;
+      }
+      return res;
+    });
+}
+const indentLinesToString = (strArr: (string | undefined | null)[], numberOfSpaces = 0, separator = " \n ", indentStr = " ") => indentLines(strArr, { numberOfSpaces, indentStr }).join(separator);
+const getTableAlias = (q: NewQuery) => !q.tableAlias ? q.table : `${q.tableAlias || ""}_${q.table}`;
+export const getTableAliasAsName = (q: NewQuery) => asName(getTableAlias(q));
+
+
+export const getRootGroupBy = (q: NewQuery, selectParamsGroupBy?: boolean) => {
+
+  const aggs = q.select.filter(s => s.selected && s.type === "aggregation");
+  const nonAggs = q.select.filter(s => s.selected && s.type !== "aggregation");
+  
+  if ((selectParamsGroupBy || aggs.length) && nonAggs.length) {
+    
+    /** Add ORDER BY items not included in root select */
+    const orderByItems: string[] = [];
+    // q.orderByItems.forEach(sortItem => {
+    //   if (!sortItem.nested && "fieldQuery" in sortItem && !orderByItems.includes(sortItem.fieldQuery)) {
+    //     orderByItems.push(sortItem.fieldQuery);
+    //   }
+    // });
+
+    return [`GROUP BY ${q.select.map((s, i)=> s.selected && s.type !== "aggregation"? `${i+1}` : undefined).concat(orderByItems).filter(isDefined).join(", ")} `]
+  }
+
+  return []
+}

package/lib/DboBuilder/QueryBuilder/prepareHaving.ts

@@ -0,0 +1,22 @@
+import { isEmpty } from "prostgles-types";
+import type { Filter } from "../DboBuilderTypes";
+import type { SelectItemValidated } from "./QueryBuilder";
+import { parseFilterItem } from "../../Filtering";
+
+type Args = {
+  having: Filter | undefined;
+  select: SelectItemValidated[];
+  tableAlias: string | undefined;
+  filterFieldNames: string[];
+}
+export const prepareHaving = ({ having, select, tableAlias, filterFieldNames }: Args) => {
+  if(!having || isEmpty(having)) return "";
+  
+  const havingStr = parseFilterItem({
+    filter: having,
+    select,
+    tableAlias,
+    allowedColumnNames: filterFieldNames,
+  });
+  return havingStr;
+}

package/lib/DboBuilder/QueryStreamer.ts

@@ -0,0 +1,250 @@
+import * as pg from "pg";
+import CursorType from 'pg-cursor';
+import { CHANNELS, SQLOptions, SocketSQLStreamPacket, SocketSQLStreamServer, omitKeys, pickKeys } from "prostgles-types";
+import { BasicCallback } from "../PubSubManager/PubSubManager";
+import { VoidFunction } from "../SchemaWatch/SchemaWatch";
+import { DB } from "../initProstgles";
+import { DboBuilder } from "./DboBuilder";
+import { PRGLIOSocket } from "./DboBuilderTypes";
+import { getErrorAsObject, getSerializedClientErrorFromPGError } from "./dboBuilderUtils";
+import { getDetailedFieldInfo } from "./runSQL";
+const Cursor: typeof CursorType = require('pg-cursor');
+
+type ClientStreamedRequest = {
+  socket: PRGLIOSocket;
+  query: string;
+  options: SQLOptions | undefined;
+  persistConnection?: boolean;
+}
+type StreamedQuery = ClientStreamedRequest & {
+  cursor: CursorType | undefined;
+  client: pg.Client | undefined;
+  stop?: VoidFunction;
+  onError: ((error: any) => void);
+}
+type Info = { 
+  command: string; 
+  fields: any[]; 
+  rowCount: number; 
+  duration: number; 
+};
+
+const shortSocketIds: Record<string, number> = {};
+const getSetShortSocketId = (socketId: string) => {
+  const shortId = socketId.slice(0, 3);
+  const currId = shortSocketIds[shortId] ?? 0;
+  const newId = currId + 1;
+  shortSocketIds[shortId] = newId;
+  return newId;
+};
+
+export class QueryStreamer {
+  db: DB;
+  dboBuilder: DboBuilder;
+  socketQueries: Record<string, Record<string, StreamedQuery>> = {};
+  adminClient: pg.Client;
+  constructor(dboBuilder: DboBuilder) {
+    this.dboBuilder = dboBuilder;
+    this.db = dboBuilder.db;
+    const setAdminClient = () => {
+      this.adminClient = this.getConnection(undefined, { keepAlive: true });
+      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();
+    }, { keepAlive: true });
+    this.adminClient.connect();
+  }
+
+  getConnection = (onError: ((err: any) => void) | undefined, extraOptions?: pg.ClientConfig) => {
+    const connectionInfo = typeof this.db.$cn === "string"? { connectionString: this.db.$cn } : this.db.$cn as any;
+    const client = new pg.Client({ ...connectionInfo, ...extraOptions });
+    client.on("error", (err) => { 
+      onError?.(err);
+    });
+    return client;
+  }
+  onDisconnect = (socketId: string) => {
+    const socketQueries = this.socketQueries[socketId];
+    if(!socketQueries) return;
+    Object.values(socketQueries).forEach(({ client, stop }) => {
+      stop?.();
+      /** end does not stop active query?! */
+      client?.end();
+    });
+    delete this.socketQueries[socketId];
+  }
+
+  create = async (query: ClientStreamedRequest): Promise<SocketSQLStreamServer> => {
+    const { socket, persistConnection } = query;
+    const socketId = socket.id;
+    const id = getSetShortSocketId(socketId);
+    const channel = `${CHANNELS.SQL_STREAM}__${socketId}_${id}`;
+    const unsubChannel = `${channel}.unsubscribe`;
+    if(this.socketQueries[id] && !persistConnection){
+      throw `Must stop existing query ${id} first`;
+    }
+
+    this.socketQueries[socketId] ??= {};
+    let errored = false;
+    const socketQuery = {
+      ...query,
+      id,
+      client: undefined,
+      cursor: undefined,
+      onError: (rawError: any) => {
+        if(errored) return;
+        errored = true;
+
+        const errorWithoutQuery = getSerializedClientErrorFromPGError(rawError, { type: "sql" });
+        // For some reason query is not present on the error object from sql stream mode
+        const error = { ...errorWithoutQuery, query: query.query };
+        socket.emit(channel, { type: "error", error } satisfies SocketSQLStreamPacket);
+      },
+    };
+    this.socketQueries[socketId]![id] ??= socketQuery;
+    let processID = -1;
+    let streamState: "started" | "ended" | "errored" | undefined;
+
+    const startStream = async (client: pg.Client | undefined, query: ClientStreamedRequest) => {
+      const socketQuery = this.socketQueries[socketId]?.[id];
+      if(!socketQuery){
+        throw "socket query not found";
+      } 
+      
+      /** Only send fields on first request */
+      let fieldsWereSent = false;
+      const emit = ({ reachedEnd, rows, info }: { reachedEnd: true; rows: any[]; info: Info } | { reachedEnd: false; rows: any[]; info: Omit<Info, "command"> }) => {
+        if(!info?.fields) throw "No fields";
+        const fields = getDetailedFieldInfo.bind(this.dboBuilder)(info.fields as any);
+        const packet: SocketSQLStreamPacket = { type: "data", rows, fields: fieldsWereSent? undefined : fields, info: reachedEnd? info : undefined, ended: reachedEnd, processId: processID };
+        socket.emit(channel, packet);
+        if(reachedEnd){
+          this.dboBuilder.prostgles.schemaWatch?.onSchemaChangeFallback?.({ command: info.command, query: query.query });
+        }
+        fieldsWereSent = true;
+      }
+      const currentClient = client ?? this.getConnection(err => {
+        socketQuery.onError(err);
+        currentClient.end();
+      });
+      this.socketQueries[socketId]![id]!.client = currentClient;
+      try {
+        if(!client){
+          await currentClient.connect();
+        }
+        processID = (currentClient as any).processID;
+
+        if(query.options?.streamLimit && (!Number.isInteger(query.options.streamLimit) || query.options.streamLimit < 0)){
+          throw "streamLimit must be a positive integer";
+        }
+        const batchSize = query.options?.streamLimit? Math.min(1e3, query.options?.streamLimit) : 1e3;
+        const cursor = currentClient.query(new Cursor(query.query, undefined, { rowMode: "array" }));
+        this.socketQueries[socketId]![id]!.cursor = cursor;
+        let streamLimitReached = false;
+        let reachedEnd = false;
+        (async () => {
+          try {
+            let rowChunk: any[] = [];
+            let rowsSent = 0;
+            do {
+              rowChunk = await cursor.read(batchSize);
+              const info = pickKeys((cursor as any)._result, ["fields", "rowCount", "command", "duration"]) as Info;
+              rowsSent += rowChunk.length;
+              streamLimitReached = Boolean(query.options?.streamLimit && rowsSent >= query.options.streamLimit);
+              reachedEnd = rowChunk.length < batchSize;
+              emit({ info, rows: rowChunk, reachedEnd: reachedEnd || streamLimitReached });
+            } while (!reachedEnd && !streamLimitReached);
+            
+            streamState = "ended"; 
+  
+            if(!query.options?.persistStreamConnection){
+              delete this.socketQueries[socketId]?.[id];
+              currentClient.end();
+            }
+            cursor.close();
+          } catch(error: any){
+            streamState = "errored";
+            if(error.message === "cannot insert multiple commands into a prepared statement") {
+              this.dboBuilder.dbo.sql!(query.query, {}, { returnType: "arrayMode", hasParams: false }).then(res => {
+                emit({ info: omitKeys(res, ["rows"]), reachedEnd: true, rows: res.rows});
+              }).catch(newError => {
+                socketQuery.onError(newError);
+              });
+            } else {
+              socketQuery.onError(error);
+            }
+          } 
+        })()
+      } catch(err){
+        socketQuery.onError(err);
+        await currentClient.end();
+      }
+    }
+
+    const cleanup = () => {
+      socket.removeAllListeners(unsubChannel);
+      socket.removeAllListeners(channel);
+      delete this.socketQueries[socketId]?.[id];
+    }
+    const stop = async (opts: { terminate?: boolean; } | undefined, cb: BasicCallback) => {
+      const { client: queryClient } = this.socketQueries[socketId]?.[id] ?? {};
+      if(!queryClient) return;
+      if(opts?.terminate){
+        setTimeout(() => {
+          queryClient.end();
+        }, 4e3);
+      }
+      try {
+        const stopFunction = opts?.terminate? "pg_terminate_backend" : "pg_cancel_backend";
+        const rows = await this.adminClient.query(`SELECT ${stopFunction}(pid), pid, state, query FROM pg_stat_activity WHERE pid = $1`, [processID]);
+        cleanup();
+        cb({ processID, info: rows.rows[0] });
+      } catch (error){
+        cb(null, error);
+      }
+    }
+    this.socketQueries[socketId]![id]!.stop = () => stop({ terminate: true }, () => { /* Empty */ });
+
+    socket.removeAllListeners(unsubChannel);
+    socket.once(unsubChannel, stop);
+
+    let runCount = 0;
+    socket.removeAllListeners(channel);
+    socket.on(channel, async (_data: { query: string; params: any } | undefined, cb: BasicCallback) => {
+      if(streamState === "started"){
+        return cb(processID, "Already started");
+      }
+      streamState = "started";
+      try {
+        /* Persisted connection query */
+        if(runCount){
+          const persistedClient = this.socketQueries[socketId]?.[id];
+          if(!persistedClient) throw "Persisted query client not found"; 
+
+          await startStream(persistedClient.client, { ...query, query: _data!.query! });
+        } else {
+          await startStream(undefined, query);
+        }
+        cb(processID);
+      } catch(err){
+        console.error(err)
+        cb(processID, getErrorAsObject(err) ?? "Something went wrong");
+      }
+      runCount++;
+    });
+
+    /** If not started within 5 seconds then assume it will never happen */
+    setTimeout(() => {
+      if(streamState) return;
+      cleanup();
+    }, 5e3);
+
+    return {
+      channel,
+      unsubChannel,
+    }
+  }
+}