prostgles-server 4.2.159 → 4.2.161

package/lib/DboBuilder/TableHandler/update.ts

@@ -0,0 +1,126 @@
+import { AnyObject, UpdateParams } from "prostgles-types";
+import { TableRule } from "../../PublishParser/PublishParser";
+import { Filter, LocalParams, getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import { getInsertTableRules, getReferenceColumnInserts } from "../insertNestedRecords";
+import { prepareNewData } from "./DataValidator";
+import { runInsertUpdateQuery } from "./runInsertUpdateQuery";
+import { TableHandler } from "./TableHandler";
+import { updateFile } from "./updateFile";
+
+export async function update(this: TableHandler, filter: Filter, _newData: AnyObject, params?: UpdateParams, tableRules?: TableRule, localParams?: LocalParams): Promise<AnyObject | void> {
+  const ACTION = "update";
+  const start = Date.now();
+  try {
+    /** postValidate */
+    const finalDBtx = this.getFinalDBtx(localParams);
+    const wrapInTx = () => this.dboBuilder.getTX(_dbtx => _dbtx[this.name]?.[ACTION]?.(filter, _newData, params, tableRules, localParams))
+    const rule = tableRules?.[ACTION]
+    if(rule?.postValidate && !finalDBtx){
+      return wrapInTx();
+    }
+
+    let newData = _newData;
+    if(this.is_media){
+      ({ newData } = await updateFile.bind(this)({ newData, filter, localParams, tableRules }));
+    }
+
+    const parsedRules = await this.parseUpdateRules(filter, params, tableRules, localParams)
+    if (localParams?.testRule) {
+      return parsedRules;
+    }
+
+    if (!newData || !Object.keys(newData).length) {
+      throw "no update data provided\nEXPECTING db.table.update(filter, updateData, options)";
+    }
+
+    const { fields, validateRow, forcedData,  returningFields, forcedFilter, filterFields } = parsedRules;
+    const { onConflict, fixIssues = false } = params || {};
+    const { returnQuery = false } = localParams ?? {};
+
+    if (params) {
+      const good_paramsObj: Record<keyof UpdateParams, 1> = { returning: 1, returnType: 1, fixIssues: 1, onConflict: 1, multi: 1 };
+      const good_params = Object.keys(good_paramsObj);
+      const bad_params = Object.keys(params).filter(k => !good_params.includes(k));
+      if (bad_params && bad_params.length) throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
+    }
+
+    const { data, allowedCols } = await prepareNewData({ 
+      row: newData, 
+      forcedData, 
+      allowedFields: fields, 
+      tableRules, 
+      fixIssues,
+      tableConfigurator: this.dboBuilder.prostgles.tableConfigurator,
+      tableHandler: this, 
+    });
+
+    const updateFilter = await this.prepareWhere({
+      select: undefined,
+      filter,
+      forcedFilter,
+      filterFields,
+      localParams,
+      tableRule: tableRules
+    })
+    
+    /**
+     * Nested inserts
+     */
+    const nData = { ...data };
+    const nestedInserts = getReferenceColumnInserts(this, nData, true);
+    const nestedInsertsResultsObj: Record<string, any> = {};
+    if(nestedInserts.length){
+      const updateCount = await this.count(updateFilter.filter);
+      if(+updateCount > 1){
+        throw "Cannot do a nestedInsert from an update that targets more than 1 row";
+      }
+      if(!finalDBtx){
+        return wrapInTx();
+      }
+      await Promise.all(nestedInserts.map(async nestedInsert => {
+        const nesedTableHandler = finalDBtx[nestedInsert.tableName] as TableHandler | undefined;
+        if(!nesedTableHandler) throw `nestedInsert Tablehandler not found for ${nestedInsert.tableName}`;
+        const refTableRules = !localParams? undefined : await getInsertTableRules(this, nestedInsert.tableName, localParams);
+        const nestedLocalParams: LocalParams = { ...localParams, nestedInsert: { depth: 1, previousData: nData, previousTable: this.name, referencingColumn: nestedInsert.col } }
+        const nestedInsertResult = await nesedTableHandler.insert(nestedInsert.data, { returning: "*" }, undefined, refTableRules, nestedLocalParams);
+        nestedInsertsResultsObj[nestedInsert.col] = nestedInsertResult;
+
+        nData[nestedInsert.col] = nestedInsertResult[nestedInsert.fcol];
+        return {
+          ...nestedInsert,
+          result: nestedInsertResult,
+        }
+      }));
+    }
+
+    // let query = await this.colSet.getUpdateQuery(nData, allowedCols, this.getFinalDbo(localParams), validateRow, localParams)
+    let query = (await this.dataValidator.parse({ command: "update", rows: [nData], allowedCols, dbTx: this.getFinalDbo(localParams), validationOptions: { validate: validateRow, localParams }})).getQuery()
+    query += "\n" + updateFilter.where;
+    if (onConflict === "DoNothing") query += " ON CONFLICT DO NOTHING ";
+    if(onConflict === "DoUpdate"){
+      throw "onConflict 'DoUpdate' not possible for an update";
+    }
+    const queryWithoutUserRLS = query;
+    query = withUserRLS(localParams, query);
+
+    if (returnQuery) return query as unknown as void;
+
+    const result = await runInsertUpdateQuery({
+      tableHandler: this,
+      data: undefined,
+      fields,
+      localParams,
+      params,
+      queryWithoutUserRLS,
+      returningFields,
+      rule,
+      type: "update",
+      nestedInsertsResultsObj
+    });
+    await this._log({ command: "update", localParams, data: { filter, _newData, params }, duration: Date.now() - start });
+    return result;
+  } catch (e) {
+    await this._log({ command: "update", localParams, data: { filter, _newData, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
+    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+  }
+} 

package/lib/DboBuilder/TableHandler/updateBatch.ts

@@ -0,0 +1,49 @@
+import { AnyObject, UpdateParams } from "prostgles-types";
+import { TableRule } from "../../PublishParser/PublishParser";
+import { Filter, LocalParams, getClientErrorFromPGError, getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import { TableHandler } from "./TableHandler";
+
+
+export async function updateBatch(this: TableHandler, updates: [Filter, AnyObject][], params?: UpdateParams, tableRules?: TableRule, localParams?: LocalParams): Promise<any> {
+  const start = Date.now();
+  try {
+    const { checkFilter, postValidate } = tableRules?.update ?? {};
+    if(checkFilter || postValidate){
+      throw `updateBatch not allowed for tables with checkFilter or postValidate rules`
+    }
+    const updateQueries: string[] = await Promise.all(
+      updates.map(async ([filter, data]) => { 
+        const query = (await this.update(
+          filter,
+          data,
+          { ...(params ?? {}), returning: undefined },
+          tableRules,
+          { ...(localParams ?? {}), returnQuery: "noRLS" }
+        )) as unknown as string;
+
+        return query;
+      })
+    );
+    const queries = [
+      withUserRLS(localParams, ""),
+      ...updateQueries
+    ];
+    
+    const t = localParams?.tx?.t ?? this.tx?.t;
+    if(t){
+      const result = await t.none(queries.join(";\n"));
+      await this._log({ command: "updateBatch", localParams, data: { data: updates, params }, duration: Date.now() - start });
+      return result;
+    }
+    const result = await this.db.tx(t => {
+        return t.none(queries.join(";\n"));
+      })
+      .catch(err => getClientErrorFromPGError(err, { type: "tableMethod", localParams, view: this, allowedKeys: []}));
+
+    await this._log({ command: "updateBatch", localParams, data: { data: updates, params }, duration: Date.now() - start });
+    return result;
+  } catch (e) {
+    await this._log({ command: "updateBatch", localParams, data: { data: updates, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
+    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+  }
+}

package/lib/DboBuilder/TableHandler/updateFile.ts

@@ -0,0 +1,48 @@
+import { AnyObject, getKeys, isObject } from "prostgles-types";
+import { LocalParams, Media } from "../DboBuilder";
+import { TableRule, ValidateRow, ValidateRowBasic } from "../../PublishParser/PublishParser";
+import { omitKeys } from "../../PubSubManager/PubSubManager";
+import { isFile, uploadFile } from "../uploadFile";
+import { TableHandler } from "./TableHandler";
+import { DBOFullyTyped } from "../../DBSchemaBuilder";
+
+type Args = {
+  newData: AnyObject; 
+  filter: AnyObject;
+  tableRules: TableRule | undefined; 
+  localParams: LocalParams | undefined;
+}
+export const updateFile = async function(this: TableHandler, { filter, newData, tableRules, localParams }: Args): Promise<{ newData: AnyObject }> {
+
+  const rule = tableRules?.update;
+
+  if(tableRules && !tableRules.update){
+    throw "Not allowed"
+  }
+  if(localParams?.testRule){
+    return { newData: {} };
+  }
+  const existingMediaId: string = !(!filter || !isObject(filter) || getKeys(filter).join() !== "id" || typeof (filter as any).id !== "string")? (filter as any).id : undefined
+  if(!existingMediaId){
+    throw new Error(`Updating the file table with file data can only be done by providing a single id filter. E.g. { id: "9ea4e23c-2b1a-4e33-8ec0-c15919bb45ec" } `);
+  }
+  if(!isFile(newData)){
+    throw new Error("Expecting { data: Buffer, name: string } but received " + JSON.stringify(newData))
+  }
+
+  const fileManager = this.dboBuilder.prostgles.fileManager
+  if(!fileManager) throw new Error("fileManager missing");
+  if(rule?.validate && !localParams) throw new Error("localParams missing");
+  const validate: ValidateRowBasic | undefined = rule?.validate? async (row) => {
+    return rule.validate!({ update: row, filter, dbx:  (this.tx?.dbTX || this.dboBuilder.dbo) as any, localParams: localParams! })
+  } : undefined;
+
+  const existingFile: Media | undefined = await (localParams?.tx?.dbTX?.[this.name] as TableHandler || this).findOne({ id: existingMediaId });
+    
+  if(!existingFile?.name) throw new Error("Existing file record not found");
+
+  await fileManager.deleteFile(existingFile.name);
+  const newFile = await uploadFile.bind(this)({ row: newData, validate, localParams, mediaId: existingFile.id })
+  return { newData: omitKeys(newFile, ["id"]) };
+
+}

package/lib/DboBuilder/TableHandler/upsert.ts

@@ -0,0 +1,34 @@
+import { AnyObject, UpdateParams } from "prostgles-types";
+import { TableRule } from "../../PublishParser/publishTypesAndUtils";
+import { Filter, LocalParams } from "../DboBuilderTypes";
+import { getErrorAsObject, getSerializedClientErrorFromPGError } from "../dboBuilderUtils";
+import { TableHandler } from "./TableHandler";
+
+export const upsert = async function(this: TableHandler, filter: Filter, newData: AnyObject, params?: UpdateParams, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
+  const start = Date.now();
+  try {
+    const _upsert = async function (tblH: TableHandler) {
+      return tblH.find(filter, { select: "", limit: 1 }, undefined, table_rules, localParams)
+        .then(exists => {
+          if (exists && exists.length) {
+            return tblH.update(filter, newData, params, table_rules, localParams);
+          } else {
+            return tblH.insert({ ...newData, ...filter }, params, undefined, table_rules, localParams);
+          }
+        });
+    }
+
+    /* Do it within a transaction to ensure consisency */
+    if (!this.tx) {
+      return this.dboBuilder.getTX(dbTX => _upsert(dbTX[this.name] as TableHandler))
+    } else {
+      const result = await _upsert(this);
+      await this._log({ command: "upsert", localParams, data: { filter, newData, params }, duration: Date.now() - start });
+      return result;
+    }
+
+  } catch (e) {
+    await this._log({ command: "upsert", localParams, data: { filter, newData, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
+    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+  }
+}

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -0,0 +1,393 @@
+import * as pgPromise from 'pg-promise';
+import {
+  AnyObject,
+  ColumnInfo, FieldFilter, SelectParams,
+  SubscribeParams,
+  asName,
+  isEmpty,
+  isObject
+} from "prostgles-types";
+import { TableEvent } from "../../Logging";
+import { DB } from "../../Prostgles";
+import { Join } from "../../ProstglesTypes";
+import { TableRule } from "../../PublishParser/PublishParser";
+import { Graph } from "../../shortestPath";
+import {
+  DboBuilder,
+  Filter,
+  LocalParams,
+  TableHandlers, ValidatedTableRules,
+  escapeTSNames,
+  getSerializedClientErrorFromPGError,
+  postgresToTsType
+} from "../DboBuilder";
+import { TableSchema } from '../DboBuilderTypes';
+import { COMPUTED_FIELDS, FieldSpec } from "../QueryBuilder/Functions";
+import { asNameAlias } from "../QueryBuilder/QueryBuilder";
+import { getColumns } from "../getColumns";
+import { count } from "./count";
+import { find } from "./find";
+import { getInfo } from "./getInfo";
+import { parseFieldFilter } from "./parseFieldFilter";
+import { prepareWhere } from "./prepareWhere";
+import { size } from "./size";
+import { LocalFuncs, subscribe } from "./subscribe";
+import { validateViewRules } from "./validateViewRules";
+
+export type JoinPaths = {
+  t1: string;
+  t2: string;
+  path: string[];
+}[];
+
+export class ViewHandler {
+  db: DB;
+  name: string;
+  escapedName: string;
+  columns: TableSchema["columns"];
+  columnsForTypes: ColumnInfo[];
+  column_names: string[];
+  tableOrViewInfo: TableSchema;
+  tsColumnDefs: string[] = [];
+  joins: Join[];
+  joinGraph?: Graph;
+  joinPaths?: JoinPaths;
+  dboBuilder: DboBuilder;
+
+  tx?: {
+    t: pgPromise.ITask<{}>;
+    dbTX: TableHandlers;
+  }
+  get dbHandler() {
+    return this.tx?.t ?? this.db;
+  }
+
+  is_view = true;
+  filterDef = "";
+  is_media = false;
+  constructor(db: DB, tableOrViewInfo: TableSchema, dboBuilder: DboBuilder, tx?: { t: pgPromise.ITask<{}>, dbTX: TableHandlers }, joinPaths?: JoinPaths) {
+    if (!db || !tableOrViewInfo) throw "";
+
+    this.db = db;
+    this.tx = tx;
+    this.joinPaths = joinPaths;
+    this.tableOrViewInfo = tableOrViewInfo;
+    this.name = tableOrViewInfo.escaped_identifier;
+    this.escapedName = tableOrViewInfo.escaped_identifier;
+    this.columns = tableOrViewInfo.columns;
+    /* cols are sorted by name to reduce .d.ts schema rewrites */
+    this.columnsForTypes = tableOrViewInfo.columns.slice(0).sort((a, b) => a.name.localeCompare(b.name));
+
+    this.column_names = tableOrViewInfo.columns.map(c => c.name);
+ 
+    this.dboBuilder = dboBuilder;
+    this.joins = this.dboBuilder.joins ?? []; 
+    this.columnsForTypes.map(({ name, udt_name, is_nullable }) => {
+      this.tsColumnDefs.push(`${escapeTSNames(name)}?: ${postgresToTsType(udt_name) as string} ${is_nullable ? " | null " : ""};`);
+    });
+  } 
+
+  _log = ({ command, data, localParams, duration, error }: Pick<TableEvent, "command" | "data" | "localParams"> & { duration: number; error?: any; }) => {
+    if(localParams?.noLog){
+      if(localParams?.socket || localParams.httpReq) {
+        throw new Error("noLog option is not allowed from a remote client");
+      }
+      return;
+    }
+    const sid = this.dboBuilder.prostgles.authHandler?.getSIDNoError(localParams);
+    return this.dboBuilder.prostgles.opts.onLog?.({ 
+      type: "table", 
+      command, 
+      duration, 
+      error,
+      txInfo: this.tx?.t.ctx,
+      sid, 
+      socketId: localParams?.socket?.id, 
+      tableName: this.name, 
+      data, 
+      localParams, 
+    });
+  }
+
+  getRowHashSelect(allowedFields: FieldFilter, alias?: string, tableAlias?: string): string {
+    let allowed_cols = this.column_names;
+    if (allowedFields) allowed_cols = this.parseFieldFilter(allowedFields);
+    return "md5(" +
+      allowed_cols
+        /* CTID not available in AFTER trigger */
+        // .concat(this.is_view? [] : ["ctid"])
+        .sort()
+        .map(f => (tableAlias ? (asName(tableAlias) + ".") : "") + asName(f))
+        .map(f => `md5(coalesce(${f}::text, 'dd'))`)
+        .join(" || ") +
+      `)` + (alias ? ` as ${asName(alias)}` : "");
+  }
+
+  validateViewRules = validateViewRules.bind(this);
+
+  getShortestJoin(table1: string, table2: string, startAlias: number, isInner = false): { query: string, toOne: boolean } { 
+    const getJoinCondition = (on: Record<string, string>[], leftTable: string, rightTable: string) => {
+      return on.map(cond => Object.keys(cond).map(lKey => `${leftTable}.${lKey} = ${rightTable}.${cond[lKey]}`).join("\nAND ")).join(" OR ")
+    }
+
+    // let toOne = true;
+    const query = this.joins.map(({ tables, on, type }, i) => {
+        if (type.split("-")[1] === "many") {
+          // toOne = false;
+        }
+        const tl = `tl${startAlias + i}`,
+          tr = `tr${startAlias + i}`;
+        return `FROM ${tables[0]} ${tl} ${isInner ? "INNER" : "LEFT"} JOIN ${tables[1]} ${tr} ON ${getJoinCondition(on, tl, tr)}`;
+      }).join("\n");
+    return { query, toOne: false }
+  }
+
+  checkFilter(filter: any) {
+    if (filter === null || filter && !isObject(filter)) throw `invalid filter -> ${JSON.stringify(filter)} \nExpecting:    undefined | {} | { field_name: "value" } | { field: { $gt: 22 } } ... `;
+  }
+
+  getInfo = getInfo.bind(this)
+
+  getColumns = getColumns.bind(this);
+
+  getValidatedRules(tableRules?: TableRule, localParams?: LocalParams): ValidatedTableRules {
+
+    if (localParams?.socket && !tableRules) {
+      throw "INTERNAL ERROR: Unexpected case -> localParams && !tableRules";
+    }
+
+    /* Computed fields are allowed only if select is allowed */
+    const allColumns: FieldSpec[] = this.column_names.slice(0).map(fieldName => ({
+      type: "column",
+      name: fieldName,
+      getQuery: ({ tableAlias }) => asNameAlias(fieldName, tableAlias),
+      selected: false
+    } as FieldSpec)).concat(COMPUTED_FIELDS.map(c => ({
+      type: c.type,
+      name: c.name,
+      getQuery: ({ tableAlias, allowedFields }) => c.getQuery({
+        allowedFields,
+        ctidField: undefined,
+        allColumns: this.columns,
+
+        /* CTID not available in AFTER trigger */
+        // ctidField: this.is_view? undefined : "ctid",
+        tableAlias
+      }),
+      selected: false
+    })));
+
+    if (tableRules) {
+      if (isEmpty(tableRules)) throw "INTERNAL ERROR: Unexpected case -> Empty table rules for " + this.name;
+      const throwFieldsErr = (command: "select" | "update" | "delete" | "insert", fieldType = "fields") => {
+        throw `Invalid publish.${this.name}.${command} rule -> ${fieldType} setting is missing.\nPlease specify allowed ${fieldType} in this format: "*" | { col_name: false } | { col1: true, col2: true }`;
+      },
+        getFirstSpecified = (...fieldParams: (FieldFilter | undefined)[]): string[] => {
+          const firstValid = fieldParams.find(fp => fp !== undefined);
+          return this.parseFieldFilter(firstValid)
+        };
+
+      const res: ValidatedTableRules = {
+        allColumns,
+        getColumns: tableRules?.getColumns ?? true,
+        getInfo: tableRules?.getColumns ?? true,
+      } as ValidatedTableRules;
+
+      if (tableRules.select) {
+        if (!tableRules.select.fields) return throwFieldsErr("select");
+
+        let maxLimit: number | null = null;
+        if (!localParams?.bypassLimit && tableRules.select.maxLimit !== undefined && tableRules.select.maxLimit !== maxLimit) {
+          const ml = tableRules.select.maxLimit;
+          if (ml !== null && (!Number.isInteger(ml) || ml < 0)) throw ` Invalid publish.${this.name}.select.maxLimit -> expecting   a positive integer OR null    but got ` + ml;
+          maxLimit = ml;
+        }
+
+        const fields = this.parseFieldFilter(tableRules.select.fields)
+        res.select = {
+          fields,
+          orderByFields: tableRules.select.orderByFields ? this.parseFieldFilter(tableRules.select.orderByFields) : fields,
+          forcedFilter: { ...tableRules.select.forcedFilter },
+          filterFields: this.parseFieldFilter(tableRules.select.filterFields),
+          maxLimit
+        };
+      }
+
+      if (tableRules.update) {
+        if (!tableRules.update.fields) return throwFieldsErr("update");
+
+        res.update = {
+          fields: this.parseFieldFilter(tableRules.update.fields),
+          forcedData: { ...tableRules.update.forcedData },
+          forcedFilter: { ...tableRules.update.forcedFilter },
+          returningFields: getFirstSpecified(tableRules.update?.returningFields, tableRules?.select?.fields, tableRules.update.fields),
+          filterFields: this.parseFieldFilter(tableRules.update.filterFields)
+        }
+      }
+
+      if (tableRules.insert) {
+        if (!tableRules.insert.fields) return throwFieldsErr("insert");
+
+        res.insert = {
+          fields: this.parseFieldFilter(tableRules.insert.fields),
+          forcedData: { ...tableRules.insert.forcedData },
+          returningFields: getFirstSpecified(tableRules.insert.returningFields, tableRules?.select?.fields, tableRules.insert.fields)
+        }
+      }
+
+      if (tableRules.delete) {
+        if (!tableRules.delete.filterFields) return throwFieldsErr("delete", "filterFields");
+
+        res.delete = {
+          forcedFilter: { ...tableRules.delete.forcedFilter },
+          filterFields: this.parseFieldFilter(tableRules.delete.filterFields),
+          returningFields: getFirstSpecified(tableRules.delete.returningFields, tableRules?.select?.fields, tableRules.delete.filterFields)
+        }
+      }
+
+      if (!tableRules.select && !tableRules.update && !tableRules.delete && !tableRules.insert) {
+        if ([null, false].includes(tableRules.getInfo as any)) res.getInfo = false;
+        if ([null, false].includes(tableRules.getColumns as any)) res.getColumns = false;
+      }
+
+      return res;
+    } else {
+      const allCols = this.column_names.slice(0);
+      return {
+        allColumns,
+        getColumns: true,
+        getInfo: true,
+        select: {
+          fields: allCols,
+          filterFields: allCols,
+          orderByFields: allCols,
+          forcedFilter: {},
+          maxLimit: null,
+        },
+        update: {
+          fields: allCols,
+          filterFields: allCols,
+          forcedFilter: {},
+          forcedData: {},
+          returningFields: allCols
+        },
+        insert: {
+          fields: allCols,
+          forcedData: {},
+          returningFields: allCols
+        },
+        delete: {
+          filterFields: allCols,
+          forcedFilter: {},
+          returningFields: allCols
+        }
+      };
+
+    }
+
+  }
+  find = find.bind(this);
+  
+  async findOne(filter?: Filter, selectParams?: SelectParams, _param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
+
+    try {
+      const { limit, ...params } = selectParams ?? {};
+      if (limit) {
+        throw "limit not allowed in findOne()";
+      }
+      const start = Date.now();
+      const result = await this.find(filter, { ...params, limit: 1, returnType: "row" }, undefined, table_rules, localParams);
+      await this._log({ command: "find", localParams, data: { filter, selectParams }, duration: Date.now() - start });
+      return result;
+    } catch (e) {
+      throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+    }
+  }
+
+  async subscribe(filter: Filter, params: SubscribeParams, localFuncs: LocalFuncs): Promise<{ unsubscribe: () => any }> 
+  async subscribe(filter: Filter, params: SubscribeParams, localFuncs: undefined, table_rules: TableRule | undefined, localParams: LocalParams): Promise<string>
+  async subscribe(filter: Filter, params: SubscribeParams, localFuncs?: LocalFuncs, table_rules?: TableRule, localParams?: LocalParams): 
+    Promise<{ unsubscribe: () => any } | string> {
+      //@ts-ignore
+      return subscribe.bind(this)(filter, params, localFuncs, table_rules, localParams);
+  }
+
+  /* This should only be called from server */
+  subscribeOne(filter: Filter, params: SubscribeParams, localFunc: (item: AnyObject) => any): Promise<{ unsubscribe: () => any }>
+  subscribeOne(filter: Filter, params: SubscribeParams, localFunc: undefined, table_rules: TableRule, localParams: LocalParams): Promise<string>
+  subscribeOne(filter: Filter, params: SubscribeParams = {}, localFunc?: (item: AnyObject) => any, table_rules?: TableRule, localParams?: LocalParams):
+    Promise<string | { unsubscribe: () => any }> {
+       
+      //@ts-ignore
+      const func = localParams? undefined : (rows: AnyObject[]) => localFunc(rows[0]); 
+      //@ts-ignore
+      return this.subscribe(filter, { ...params, limit: 2 }, func, table_rules, localParams);
+  }
+
+  count = count.bind(this);
+  size = size.bind(this);
+
+  getAllowedSelectFields(selectParams: FieldFilter = "*", allowed_cols: FieldFilter, allow_empty = true): string[] {
+    const all_columns = this.column_names.slice(0);
+    let allowedFields = all_columns.slice(0),
+      resultFields: string[] = [];
+
+    if (selectParams) {
+      resultFields = this.parseFieldFilter(selectParams, allow_empty);
+    }
+    if (allowed_cols) {
+      allowedFields = this.parseFieldFilter(allowed_cols, allow_empty);
+    }
+    let col_names = (resultFields || []).filter(f => !allowedFields || allowedFields.includes(f));
+
+    /* Maintain allowed cols order */
+    if (selectParams === "*" && allowedFields && allowedFields.length){ 
+      col_names = allowedFields;
+    }
+
+    return col_names;
+  } 
+
+  /**
+   * Parses group or simple filter
+   */
+  prepareWhere = prepareWhere.bind(this); 
+
+  intersectColumns(allowedFields: FieldFilter, dissallowedFields: FieldFilter, fixIssues = false): string[] {
+    let result: string[] = [];
+    if (allowedFields) {
+      result = this.parseFieldFilter(allowedFields);
+    }
+    if (dissallowedFields) {
+      const _dissalowed = this.parseFieldFilter(dissallowedFields);
+
+      if (!fixIssues) {
+
+        throw `dissallowed/invalid field found for ${this.name}: `
+      }
+      result = result.filter(key => !_dissalowed.includes(key));
+    }
+
+    return result;
+  }
+
+  parseFieldFilter(fieldParams: FieldFilter = "*", allow_empty = true, allowed_cols?: string[]): string[] {
+    return parseFieldFilter(fieldParams, allow_empty, allowed_cols ?? this.column_names.slice(0))
+  }
+
+}
+
+
+/** 
+* Throw error if illegal keys found in object
+*/
+export const validateObj = <T extends Record<string, any>>(obj: T, allowedKeys: string[]): T => {
+  if (obj && Object.keys(obj).length) {
+    const invalid_keys = Object.keys(obj).filter(k => !allowedKeys.includes(k));
+    if (invalid_keys.length) {
+      throw "Invalid/Illegal fields found: " + invalid_keys.join(", ");
+    }
+  }
+
+  return obj;
+}

package/lib/DboBuilder/ViewHandler/count.ts

@@ -0,0 +1,38 @@
+import { SelectParams } from "prostgles-types";
+import { TableRule } from "../../PublishParser/publishTypesAndUtils";
+import { Filter, LocalParams } from "../DboBuilder";
+import { getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../dboBuilderUtils";
+import { ViewHandler } from "./ViewHandler";
+
+export async function count(this: ViewHandler, _filter?: Filter, selectParams?: SelectParams, _param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<number> {
+  const filter = _filter || {};
+  const { limit: _limit, ...selectParamsWithoutLimit } = selectParams ?? {};
+  const start = Date.now();
+  try {
+    const result = await this.find(filter, { select: selectParamsWithoutLimit?.select ?? "", limit: 0 }, undefined, table_rules, localParams)
+      .then(async _allowed => {
+        const findQuery = await this.find(
+          filter, 
+          selectParamsWithoutLimit,
+          undefined,
+          table_rules,
+          { ...localParams, returnQuery: "noRLS", bypassLimit: true }
+        ) as unknown as string;
+        const query = [
+          withUserRLS(localParams, ""),
+          "SELECT COUNT(*)",
+          "FROM (",
+          findQuery,
+          ") t"
+        ].join("\n");
+        const handler = this.tx?.t ?? this.db;
+        return handler.one(query).then(({ count }) => +count);
+      });
+
+    await this._log({ command: "count", localParams, data: { filter }, duration: Date.now() - start });
+    return result;
+  } catch (e) {
+    await this._log({ command: "count", localParams, data: { filter }, duration: Date.now() - start, error: getErrorAsObject(e) });
+    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+  }
+}