prostgles-server 4.2.159 → 4.2.161

package/lib/DboBuilder/ViewHandler/parseJoinPath.ts

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

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

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

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

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

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