prostgles-server 4.2.157 → 4.2.159

package/lib/DboBuilder/QueryBuilder/getNewQuery.ts

@@ -1,271 +0,0 @@
-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

@@ -1,136 +0,0 @@
-
-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

@@ -1,22 +0,0 @@
-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

@@ -1,250 +0,0 @@
-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,
-    }
-  }
-}