prostgles-server 4.2.157 → 4.2.159

package/lib/DboBuilder/ViewHandler/parseJoinPath.ts

@@ -1,208 +0,0 @@
-import { JoinPath, RawJoinPath, reverseJoinOn } from "prostgles-types";
-import { ViewHandler } from "./ViewHandler";
-
-type parseJoinPathArgs = {
-  rawPath: RawJoinPath;
-  rootTable: string;
-  viewHandler: ViewHandler;
-  allowMultiOrJoin?: boolean;
-  addShortestJoinIfMissing?: boolean;
-}
-export type ParsedJoinPath = { table: string; on: Record<string, string>[] };
-
-/**
- * Return a valid join path
- */
-export const parseJoinPath = ({ rawPath, rootTable, viewHandler, allowMultiOrJoin = false, addShortestJoinIfMissing }: parseJoinPathArgs): ParsedJoinPath[] => {
-  const result: ParsedJoinPath[] = [];
-  let cleanPath = typeof rawPath === "string"? [{ table: rawPath }] : rawPath;
-  if(addShortestJoinIfMissing && cleanPath[0] !== "**"){
-    cleanPath = ["**", ...cleanPath]
-  }
-  cleanPath.forEach((item, i) => {
-    const prevTable = result.at(-1)?.table ?? rootTable;
-    if(!prevTable) throw `prevTable missing`;
-
-    const pushJoinPath = (targetPath: JoinPath) => {
-      const getShortestJoin = i === 1 && cleanPath[0] === "**";
-      const joinInfo = getJoins(viewHandler, prevTable, [targetPath], { allowMultiOrJoin, getShortestJoin });
-      
-      joinInfo.paths.forEach(path => {
-
-        /** Check if join tables are valid */
-        if (!viewHandler.dboBuilder.dbo[path.table]) {
-          throw { stack: ["prepareExistCondition()"], message: `Invalid or dissallowed table in join path: ${path.table}` };
-        }
-        result.push({
-          table: path.table,
-          on: path.on.map(constraint => Object.fromEntries(constraint))
-        });
-      })
-    }
-
-    /** Shortest join */
-    if(item === "**"){
-
-    } else if(typeof item === "string"){
-      const table = item;
-      pushJoinPath({ table })
-    } else {
-      pushJoinPath(item);
-    }
-  });
-
-  const missingPath = result.find(r => !r.on.length || r.on.some(v => !Object.keys(v).length));
-  if(missingPath){
-    throw `Missing join on condition for: ${missingPath.table}`
-  }
-
-  return result;
-}
-
-import { JoinInfo } from "../DboBuilder";
-
-type Opts = {
-  allowMultiOrJoin?: boolean;
-  getShortestJoin?: boolean;
-}
-
-/**
- * Returns all tables and fields required to join from source table to target table
- * Respecting the path.on condition
- */
-function getJoins(viewHandler: ViewHandler, source: string, path: JoinPath[], { allowMultiOrJoin = true, getShortestJoin }: Opts = {}): JoinInfo {
-  const [lastItem] = path;
-  if(!lastItem){
-    throw `Empty path`;
-  }
-  if(getShortestJoin && path.length !== 1){
-    throw `getShortestJoin requires exactly 1 path item`
-  }
-  const target = lastItem.table;
-  if (!viewHandler.joinPaths) {
-    throw `Join info missing`;
-  }
-
-  /* Self join */
-  if (source === target) {
-    const tableHandler = viewHandler.dboBuilder.tablesOrViews?.find(t => t.name === source);
-    if (!tableHandler) throw `Table not found for joining ${source}`;
-
-    const fcols = tableHandler.columns.filter(c => c.references?.some(({ ftable }) => ftable === viewHandler.name));
-    if(!fcols.length){
-      throw `There is no self-join foreign key relationship for table ${JSON.stringify(target)}`
-    }
-    let allOnJoins: [string, string][][] = [];
-    fcols.forEach(fc => {
-      fc.references!.forEach(({ fcols, cols }) => {
-        const fieldArr = fcols.map((fcol, i) => [fcol,  cols[i]!] as [string, string]);
-        allOnJoins.push(fieldArr);
-      })
-    });
-    allOnJoins = [
-      ...allOnJoins,
-      /** Reverse as well */
-      ...allOnJoins.map(constraint => (constraint).map(([left, right]) => [right, left] as [string, string]))
-    ]
-    return {
-      paths: [{
-        source,
-        target,
-        table: target,
-        on: getValidOn(lastItem.on, allOnJoins.map(v => Object.fromEntries(v)))
-      }],
-      expectOne: false
-    }
-  }
-
-  /* Find the join path between tables */
-  const tableConfigJoinInfo = viewHandler.dboBuilder?.prostgles?.tableConfigurator?.getJoinInfo(source, target);
-  if (tableConfigJoinInfo) return tableConfigJoinInfo;
-
-  const actualPath = getShortestJoin? 
-    viewHandler.joinPaths.find(j => {
-      return j.t1 === source && j.t2 === target
-    })?.path.map(table => ({ table, on: undefined })).slice(1) : 
-    viewHandler.joinPaths.find(j => {
-      return j.path.join() === [{ table: source }, ...path].map(p => p.table).join()
-    })? path : undefined;
-
-  if(getShortestJoin && actualPath?.length && lastItem.on?.length){
-    actualPath[actualPath.length-1]!.on = lastItem.on;
-  }
-  
-  if (!actualPath) {
-    throw `Joining ${source} <-...-> ${target} dissallowed or missing`;
-  }
-
-  /* Make the join chain info */
-  const paths: JoinInfo["paths"] = [];
-  actualPath.forEach((tablePath, i, arr) => {
-    const prevTable = arr[i - 1]!;
-    const t1 = i === 0 ? source : prevTable.table;
-
-    viewHandler.joins ??= viewHandler.dboBuilder.joins;
-
-    /* Get join options */
-    const join = viewHandler.joins.find(j => j.tables.includes(t1) && j.tables.includes(tablePath.table));
-    if (!join) {
-      throw `Joining ${t1} <-> ${tablePath} dissallowed or missing`;
-    }
-    const isLtr = join.tables[0] === t1;
-    const joinOn = isLtr? join.on : reverseJoinOn(join.on);
-
-    const on = getValidOn(tablePath.on, joinOn);
-    paths.push({
-      source,
-      target,
-      table: tablePath.table,
-      on
-    });
-  });
-  const expectOne = false;
-  // paths.map(({ source, target, on }, i) => {
-  // if(expectOne && on.length === 1){
-  //     const sourceCol = on[0][1];
-  //     const targetCol = on[0][0];
-
-  //     const sCol = this.dboBuilder.dbo[source].columns.find(c => c.name === sourceCol)
-  //     const tCol = this.dboBuilder.dbo[target].columns.find(c => c.name === targetCol)
-  //     console.log({ sourceCol, targetCol, sCol, source, tCol, target, on})
-  //     expectOne = sCol.is_pkey && tCol.is_pkey
-  // }
-  // })
-
-  const isMultiOrJoin = paths.find(p => p.on.length > 1);
-  if(!allowMultiOrJoin && isMultiOrJoin){
-    throw `Table ${JSON.stringify(source)} can join to ${JSON.stringify(target)} through multiple constraints. Must chose one of ${JSON.stringify(isMultiOrJoin.on)}`
-  }
-  return {
-    paths,
-    expectOne
-  };
-}
-
-const getValidOn = (requested: JoinPath["on"], possible: ParsedJoinPath["on"]) => {
-
-  if(!requested){
-    return possible.map(v => Object.entries(v));
-  }
-  if(!requested.length){
-    throw `Invalid requested "tablePath.on". Cannot be empty`
-  }
-  const isValid = requested.every(requestedConstraint => {
-    return possible.some(possibleConstraint => conditionsMatch(possibleConstraint, requestedConstraint));
-  });
-
-  if(!isValid){
-    throw `Invalid path specified for join: ${JSON.stringify(requested)}. Allowed paths: ${JSON.stringify(possible)}`
-  }
-
-  return requested.map(v => Object.entries(v));
-}
-
-const conditionsMatch = (c1: Record<string, string>, c2: Record<string, string>) => {
-  const keys1 = Object.keys(c1);
-  const keys2 = Object.keys(c2);
-  return keys1.sort().join() === keys2.sort().join() && keys1.every(key => c1[key] === c2[key]);
-}

package/lib/DboBuilder/ViewHandler/prepareSortItems.ts

@@ -1,163 +0,0 @@
-import { OrderBy, asName, isDefined, isEmpty, isObject } from "prostgles-types/dist";
-import { SortItem } from "../DboBuilder";
-import { NewQueryJoin, SelectItemValidated, asNameAlias } from "../QueryBuilder/QueryBuilder";
-
-/* This relates only to SELECT */
-export const prepareSortItems = (
-  rawOrderBy: OrderBy | undefined,
-  allowed_cols: string[],
-  tableAlias: string | undefined,
-  select: SelectItemValidated[],
-  joinQueries: NewQueryJoin[],
-): SortItem[] => {
-
-  if (!rawOrderBy) return [];
-
-  let orderBy: { key: string, asc: boolean, nulls?: "first" | "last", nullEmpty?: boolean }[] = [];
-  if (isObject(rawOrderBy)) {
-    orderBy = parseOrderObj(rawOrderBy);
-  } else if (typeof rawOrderBy === "string") {
-    /* string */
-    orderBy = [{ key: rawOrderBy, asc: true }];
-  } else if (Array.isArray(rawOrderBy)) {
-
-    /* Order by is formed of a list of ascending field names */
-    const _orderBy = (rawOrderBy as any[]);
-    if (_orderBy && !_orderBy.find(v => typeof v !== "string")) {
-      /* [string] */
-      orderBy = _orderBy.map(key => ({ key, asc: true }));
-    } else if (_orderBy.find(v => isObject(v) && !isEmpty(v))) {
-      orderBy = _orderBy.map(v => parseOrderObj(v, true)[0]!);
-    } else return throwErr(rawOrderBy);
-  } else return throwErr(rawOrderBy);
-
-  if (!orderBy || !orderBy.length) return [];
-
-  const validatedAggAliases = select.filter(s =>
-    s.type !== "joinedColumn" &&
-    (!s.fields.length || s.fields.every(f => allowed_cols.includes(f)))
-  ).map(s => s.alias)
-
-  const sortableNestedColumns = joinQueries.flatMap(jq => jq.select.map(selectItem => {
-    const joinAlias = jq.tableAlias ?? jq.table;
-    return {
-      ...jq,
-      selectItem,
-      joinAlias,
-      key: `${joinAlias}.${selectItem.alias}`
-    }
-  }));
-  const bad_param = orderBy.find(({ key }) =>
-    !sortableNestedColumns.some(v => v.key === key) &&
-    !validatedAggAliases.includes(key) &&
-    !allowed_cols.includes(key)
-  );
-  if (bad_param) {
-    throw "Invalid/disallowed orderBy fields or params: " + bad_param.key;
-  }
-
-  const selectedAliases = select.filter(s => s.selected).map(s => s.alias);
-  
-  const result: SortItem[] = orderBy.map(({ key, asc, nulls, nullEmpty = false }) => {
-
-    const nestedField = sortableNestedColumns.find(f => f.key === key);
-    if (nestedField) {
-      const { table, selectItem, joinAlias } = nestedField;
-      
-      const comparableDataTypeCast = ["uuid", "xml"].includes(selectItem.column_udt_type ?? "")? "::TEXT" : "";
-      const sortItemAlias = asName(`prostgles_nested_sort_${selectItem.alias}`)
-      
-      return {
-        key,
-        type: "query",
-        asc,
-        nulls,
-        nullEmpty,
-        nested: {
-          table,
-          joinAlias,
-          selectItemAlias: selectItem.alias,
-          isNumeric: selectItem.tsDataType === "number",
-          wrapperQuerySortItem: `${asc? "MIN" : "MAX"}(${asNameAlias(selectItem.alias, joinAlias)}${comparableDataTypeCast}) as ${sortItemAlias}`,
-        },
-        fieldQuery: `${asName(joinAlias)}.${sortItemAlias + (asc? "" : " DESC")} ${nulls? `NULLS ${nulls === "last"? "LAST" : "FIRST" }` : ""}`,
-      }
-    }
-    /* Order by column index when possible to bypass name collision when ordering by a computed column. 
-        (Postgres will sort by existing columns wheundefined possible) 
-    */
-   
-    const index = selectedAliases.indexOf(key) + 1;
-    let colKey = (index > 0 && !nullEmpty) ? index : [tableAlias, key].filter(isDefined).map(asName).join(".");
-    if (nullEmpty) {
-      colKey = `nullif(trim(${colKey}::text), '')`
-    }
-
-    if (typeof colKey === "number") {
-      return {
-        key,
-        type: "position",
-        asc,
-        nulls,
-        nullEmpty,
-        fieldPosition: colKey
-      }
-    }
-
-    return {
-      key,
-      type: "query",
-      fieldQuery: colKey,
-      nulls,
-      nullEmpty,
-      asc,
-    }
-  });
-
-  return result;
-}
-
-const throwErr = (rawOrderBy: any) => {
-  throw "\nInvalid orderBy option -> " + JSON.stringify(rawOrderBy) +
-  "Expecting: \
-        { key2: false, \"nested.key2\": false, key1: true } \
-        { key1: 1, key2: -1 } \
-        [{ key1: true }, { key2: false }] \
-        [{ key: 'colName', asc: true, nulls: 'first', nullEmpty: true }]"
-};
-
-const parseOrderObj = (orderBy: any, expectOne = false): { key: string, asc: boolean, nulls?: "first" | "last", nullEmpty?: boolean }[] => {
-  if (!isObject(orderBy)) return throwErr(orderBy);
-
-  const keys = Object.keys(orderBy);
-  if (keys.length && keys.find(k => ["key", "asc", "nulls", "nullEmpty"].includes(k))) {
-    const { key, asc, nulls, nullEmpty = false } = orderBy;
-    if (
-      !["string"].includes(typeof key) ||
-      !["boolean"].includes(typeof asc) ||
-      !["first", "last", undefined, null].includes(nulls) ||
-      !["boolean"].includes(typeof nullEmpty)
-    ) {
-      throw `Invalid orderBy option (${JSON.stringify(orderBy, null, 2)}) \n 
-                      Expecting { key: string, asc?: boolean, nulls?: 'first' | 'last' | null | undefined, nullEmpty?: boolean } `
-    }
-    return [{ key, asc, nulls, nullEmpty }];
-  }
-
-  if (expectOne && keys.length > 1) {
-    throw "\nInvalid orderBy " + JSON.stringify(orderBy) +
-    "\nEach orderBy array element cannot have more than one key";
-  }
-  /* { key2: true, key1: false } */
-  if (!Object.values(orderBy).find(v => ![true, false].includes(<any>v))) {
-    return keys.map(key => ({ key, asc: Boolean(orderBy[key]) }))
-
-    /* { key2: -1, key1: 1 } */
-  } else if (!Object.values(orderBy).find(v => ![-1, 1].includes(<any>v))) {
-    return keys.map(key => ({ key, asc: orderBy[key] === 1 }))
-
-    /* { key2: "asc", key1: "desc" } */
-  } else if (!Object.values(orderBy).find(v => !["asc", "desc"].includes(<any>v))) {
-    return keys.map(key => ({ key, asc: orderBy[key] === "asc" }))
-  } else return throwErr(orderBy);
-};

package/lib/DboBuilder/ViewHandler/prepareWhere.ts

@@ -1,90 +0,0 @@
-import { AnyObject, FieldFilter, getKeys, isDefined, isObject } from "prostgles-types/dist";
-import { ViewHandler } from "./ViewHandler";
-import { ExistsFilterConfig, Filter, LocalParams } from "../DboBuilder";
-import { SelectItem } from "../QueryBuilder/QueryBuilder";
-import { TableRule } from "../../PublishParser/PublishParser";
-import { getCondition } from "../getCondition";
-
-export type PrepareWhereParams = {
-  filter?: Filter;
-  select: SelectItem[] | undefined;
-  forcedFilter?: AnyObject;
-  filterFields?: FieldFilter;
-  addWhere?: boolean;
-  tableAlias?: string,
-  localParams: LocalParams | undefined,
-  tableRule: TableRule | undefined,
-  isHaving?: boolean;
-};
-
-export async function prepareWhere(this: ViewHandler, params: PrepareWhereParams): Promise<{ condition: string; where: string; filter: AnyObject; exists: ExistsFilterConfig[]; }> {
-  const { filter, select, forcedFilter, filterFields: ff, addWhere: addKeywords = true, tableAlias, localParams, tableRule } = params;
-  const { $and: $and_key, $or: $or_key } = this.dboBuilder.prostgles.keywords;
-
-  let filterFields = ff;
-  /* Local update allow all. TODO -> FIX THIS */
-  if (!ff && !tableRule) filterFields = "*";
-
-  const exists: ExistsFilterConfig[] = [];
-
-  const parseFullFilter = async (f: any, parentFilter: any = null, isForcedFilterBypass: boolean): Promise<string> => {
-    if (!f) throw "Invalid/missing group filter provided";
-    if (!isObject(f)) throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(f);
-    let result = "";
-    const keys = getKeys(f);
-    if (!keys.length) {
-      return result;
-    }
-    if ((keys.includes($and_key) || keys.includes($or_key))) {
-      if (keys.length > 1) throw `\ngroup filter must contain only one array property. e.g.: { ${$and_key}: [...] } OR { ${$or_key}: [...] } `;
-      if (parentFilter && Object.keys(parentFilter).includes("")) throw "group filter ($and/$or) can only be placed at the root or within another group filter";
-    }
-
-    const { [$and_key]: $and, [$or_key]: $or } = f,
-      group: AnyObject[] = $and || $or;
-
-    if (group && group.length) {
-      const operand = $and ? " AND " : " OR ";
-      const conditions = (await Promise.all(
-          group.map(async gf => await parseFullFilter(gf, group, isForcedFilterBypass))
-        )).filter(c => c);
-        
-      if (conditions?.length) {
-        if (conditions.length === 1) return conditions.join(operand);
-        else return ` ( ${conditions.sort().join(operand)} ) `;
-      }
-    } else if (!group) {
-
-      /** forcedFilters do not get checked against publish and are treated as server-side requests */
-      const cond = await getCondition.bind(this)({
-        filter: { ...f },
-        select,
-        allowed_colnames: isForcedFilterBypass ? this.column_names.slice(0) : this.parseFieldFilter(filterFields),
-        tableAlias,
-        localParams: isForcedFilterBypass ? undefined : localParams,
-        tableRules: isForcedFilterBypass ? undefined : tableRule,
-        isHaving: params.isHaving,
-      });
-      result = cond.condition;
-      exists.push(...cond.exists);
-    }
-    return result;
-  }
-
-  /* A forced filter condition will not check if the existsJoined filter tables have been published */
-  const forcedFilterCond = forcedFilter ? await parseFullFilter(forcedFilter, null, true) : undefined;
-  const filterCond = await parseFullFilter(filter, null, false);
-  let cond = [
-    forcedFilterCond, filterCond
-  ].filter(c => c).join(" AND ");
-
-  const finalFilter = forcedFilter ? {
-    [$and_key]: [forcedFilter, filter].filter(isDefined)
-  } : { ...filter };
-
-  const condition = cond;
-  if (cond && addKeywords) {
-    cond = `WHERE ${cond}`;
-  }
-  return { condition, where: cond || "", filter: finalFilter, exists };
-}

package/lib/DboBuilder/ViewHandler/size.ts

@@ -1,37 +0,0 @@
-import { SelectParams } from "prostgles-types";
-import { TableRule } from "../../PublishParser/publishTypesAndUtils";
-import { Filter, LocalParams } from "../DboBuilderTypes";
-import { getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../dboBuilderUtils";
-import { ViewHandler } from "./ViewHandler";
-export async function size(this: ViewHandler, _filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<string> {
-  const filter = _filter || {};
-  const start = Date.now();
-  try {
-    const result = await this.find(filter, { ...selectParams, limit: 2 }, undefined, table_rules, localParams)
-      .then(async _allowed => {
-        
-        const q: string = await this.find(
-          filter, { ...selectParams, limit: selectParams?.limit ?? Number.MAX_SAFE_INTEGER },
-          undefined,
-          table_rules,
-          { ...localParams, returnQuery: "noRLS", bypassLimit: true }
-        ) as any;
-        const query = withUserRLS(
-          localParams,
-          `${withUserRLS(localParams, "")}
-            SELECT sum(pg_column_size((prgl_size_query.*))) as size 
-            FROM (
-              ${q}
-            ) prgl_size_query
-          `
-        );
-
-        return (this.tx?.t || this.db).one(query).then(({ size }) => size || '0');
-      });
-    await this._log({ command: "size", localParams, data: { filter, selectParams }, duration: Date.now() - start });
-    return result;
-  } catch (e) {
-    await this._log({ command: "size", localParams, data: { filter, selectParams }, duration: Date.now() - start, error: getErrorAsObject(e) });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
-  }
-}

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -1,118 +0,0 @@
-import { AnyObject, SubscribeParams, SubscriptionChannels } from "prostgles-types";
-import { TableRule } from "../../PublishParser/PublishParser";
-import { Filter, LocalParams, getClientErrorFromPGError, getErrorAsObject, getSerializedClientErrorFromPGError } from "../DboBuilder";
-import { getSubscribeRelatedTables } from "../getSubscribeRelatedTables";
-import { NewQuery } from "../QueryBuilder/QueryBuilder";
-import { ViewHandler } from "./ViewHandler";
-
-type OnData = (items: AnyObject[]) => any; 
-export type LocalFuncs = {
-  onData: OnData
-  onError?: (error: any) => void;
-} | OnData;
-
-export const getOnDataFunc = (localFuncs: LocalFuncs | undefined): OnData | undefined => {
-  return typeof localFuncs === "function"? localFuncs : localFuncs?.onData;
-}
-export const matchesLocalFuncs = (localFuncs1: LocalFuncs | undefined, localFuncs2: LocalFuncs | undefined) => {
-  return localFuncs1 && localFuncs2 && getOnDataFunc(localFuncs1) === getOnDataFunc(localFuncs2);
-}
-export const parseLocalFuncs = (localFuncs1: LocalFuncs | undefined): Extract<LocalFuncs, { onData: OnData }> | undefined=> {
-  return !localFuncs1? undefined : typeof localFuncs1 === "function"? {
-    onData: localFuncs1
-  } : localFuncs1;
-}
-
-async function subscribe(this: ViewHandler, filter: Filter, params: SubscribeParams, localFuncs: LocalFuncs): Promise<{ unsubscribe: () => any }> 
-async function subscribe(this: ViewHandler, filter: Filter, params: SubscribeParams, localFuncs: undefined, table_rules: TableRule | undefined, localParams: LocalParams): Promise<SubscriptionChannels>
-async function subscribe(this: ViewHandler, filter: Filter, params: SubscribeParams, localFuncs?: LocalFuncs, table_rules?: TableRule, localParams?: LocalParams): Promise<{ unsubscribe: () => any } | SubscriptionChannels> 
-{
-  const start = Date.now();
-  try {
-
-    if(!this.dboBuilder.canSubscribe){
-      throw "Cannot subscribe. PubSubManager not initiated";
-    }
-
-    if (this.tx) {
-      throw "subscribe not allowed within transactions";
-    }
-    if (!localParams && !localFuncs) {
-      throw " missing data. provide -> localFunc | localParams { socket } ";
-    }
-    if (localParams?.socket && localFuncs) {
-      console.error({ localParams, localFuncs })
-      throw " Cannot have localFunc AND socket ";
-    }
-
-    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";
-    // }
-
-    const newQuery: NewQuery = await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, { ...localParams, returnNewQuery: true }) as any;
-    const viewOptions = await getSubscribeRelatedTables.bind(this)({ 
-      filter, selectParams, 
-      table_rules, localParams, 
-      newQuery
-    });
-
-    const commonSubOpts = {
-      table_info: this.tableOrViewInfo,
-      viewOptions,
-      table_rules,
-      condition: newQuery.whereOpts.condition,
-      table_name: this.name,
-      filter: { ...filter },
-      params: { ...selectParams },
-      throttle,
-      throttleOpts,
-      last_throttled: 0,
-    } as const;
-
-    const pubSubManager = await this.dboBuilder.getPubSubManager();
-    if (!localFuncs) {    
-
-      const { socket } = localParams ?? {};
-      const result = await pubSubManager.addSub({
-        ...commonSubOpts,
-        socket, 
-        localFuncs: undefined,
-        socket_id: socket?.id, 
-      });
-
-      await this._log({ command: "subscribe", localParams, data: { filter, params }, duration: Date.now() - start });
-      return result;
-    } else {
-
-      const { channelName, sendFirstData } = await pubSubManager.addSub({ 
-        ...commonSubOpts,
-        socket: undefined,  
-        localFuncs, 
-        socket_id: undefined, 
-      });
-      
-      const unsubscribe = async () => {
-        const pubSubManager = await this.dboBuilder.getPubSubManager();
-        pubSubManager.removeLocalSub(channelName, localFuncs)
-      };
-      await this._log({ command: "subscribe", localParams, data: { filter, params }, duration: Date.now() - start });
-      const res: { unsubscribe: () => any } = Object.freeze({ unsubscribe });
-      /** Send first data after subscription is initialised to prevent race conditions */
-      setTimeout(() => {
-        sendFirstData?.();
-      }, 0);
-      return res;
-    }
-  } catch (e) {
-    await this._log({ command: "subscribe", localParams, data: { filter, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
-  }
-}
-
-export { subscribe };

package/lib/DboBuilder/ViewHandler/validateViewRules.ts

@@ -1,70 +0,0 @@
-import { AnyObject, FieldFilter } from "prostgles-types/dist";
-import { UpdateRule } from "../../PublishParser/PublishParser";
-import { ViewHandler } from "./ViewHandler";
-
-export async function validateViewRules(
-  this: ViewHandler,
-  args: {
-    fields?: FieldFilter,
-    filterFields?: FieldFilter,
-    returningFields?: FieldFilter,
-    forcedFilter?: AnyObject,
-    dynamicFields?: UpdateRule["dynamicFields"],
-    rule: "update" | "select" | "insert" | "delete"
-  }
-) {
-  const {
-    fields,
-    filterFields,
-    returningFields,
-    forcedFilter,
-    dynamicFields,
-    rule,
-  } = args;
-
-  /* Safely test publish rules */
-  if (fields) {
-    try {
-      const _fields = this.parseFieldFilter(fields);
-      if (this.is_media && rule === "insert" && !_fields.includes("id")) {
-        throw "Must allow id insert for media table"
-      }
-    } catch (e) {
-      throw ` issue with publish.${this.name}.${rule}.fields: \nVALUE: ` + JSON.stringify(fields, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
-    }
-  }
-  if (filterFields) {
-    try {
-      this.parseFieldFilter(filterFields);
-    } catch (e) {
-      throw ` issue with publish.${this.name}.${rule}.filterFields: \nVALUE: ` + JSON.stringify(filterFields, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
-    }
-  }
-  if (returningFields) {
-    try {
-      this.parseFieldFilter(returningFields);
-    } catch (e) {
-      throw ` issue with publish.${this.name}.${rule}.returningFields: \nVALUE: ` + JSON.stringify(returningFields, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
-    }
-  }
-  if (forcedFilter) {
-    try {
-      await this.find(forcedFilter, { limit: 0 });
-    } catch (e) {
-      throw ` issue with publish.${this.name}.${rule}.forcedFilter: \nVALUE: ` + JSON.stringify(forcedFilter, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
-    }
-  }
-  if (dynamicFields) {
-    for await (const dfieldRule of dynamicFields) {
-      try {
-        const { fields, filter } = dfieldRule;
-        this.parseFieldFilter(fields);
-        await this.find(filter, { limit: 0 });
-      } catch (e) {
-        throw ` issue with publish.${this.name}.${rule}.dynamicFields: \nVALUE: ` + JSON.stringify(dfieldRule, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
-      }
-    }
-  }
-
-  return true;
-}