prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -1,11 +1,13 @@
-import * as pgPromise from 'pg-promise';
+import * as pgPromise from "pg-promise";
 import {
   AnyObject,
-  ColumnInfo, FieldFilter, SelectParams,
+  ColumnInfo,
+  FieldFilter,
+  SelectParams,
   SubscribeParams,
   asName,
   isEmpty,
-  isObject
+  isObject,
 } from "prostgles-types";
 import { TableEvent } from "../../Logging";
 import { DB } from "../../Prostgles";
@@ -16,12 +18,13 @@ import {
   DboBuilder,
   Filter,
   LocalParams,
-  TableHandlers, ValidatedTableRules,
+  TableHandlers,
+  ValidatedTableRules,
   escapeTSNames,
   getSerializedClientErrorFromPGError,
-  postgresToTsType
+  postgresToTsType,
 } from "../DboBuilder";
-import { TableSchema } from '../DboBuilderTypes';
+import { TableSchema } from "../DboBuilderTypes";
 import { COMPUTED_FIELDS, FieldSpec } from "../QueryBuilder/Functions";
 import { asNameAlias } from "../QueryBuilder/QueryBuilder";
 import { getColumns } from "../getColumns";
@@ -57,7 +60,7 @@ export class ViewHandler {
   tx?: {
     t: pgPromise.ITask<{}>;
     dbTX: TableHandlers;
-  }
+  };
   get dbHandler() {
     return this.tx?.t ?? this.db;
   }
@@ -65,7 +68,13 @@ export class ViewHandler {
   is_view = true;
   filterDef = "";
   is_media = false;
-  constructor(db: DB, tableOrViewInfo: TableSchema, dboBuilder: DboBuilder, tx?: { t: pgPromise.ITask<{}>, dbTX: TableHandlers }, joinPaths?: JoinPaths) {
+  constructor(
+    db: DB,
+    tableOrViewInfo: TableSchema,
+    dboBuilder: DboBuilder,
+    tx?: { t: pgPromise.ITask<{}>; dbTX: TableHandlers },
+    joinPaths?: JoinPaths
+  ) {
     if (!db || !tableOrViewInfo) throw "";
 
     this.db = db;
@@ -76,115 +85,161 @@ export class ViewHandler {
     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.columnsForTypes = tableOrViewInfo.columns
+      .slice(0)
+      .sort((a, b) => a.name.localeCompare(b.name));
+
+    this.column_names = tableOrViewInfo.columns.map((c) => c.name);
 
-    this.column_names = tableOrViewInfo.columns.map(c => c.name);
- 
     this.dboBuilder = dboBuilder;
-    this.joins = this.dboBuilder.joins ?? []; 
+    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 " : ""};`);
+      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) {
+  _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, 
+    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, 
+      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(" +
+    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'))`)
+        .map((f) => (tableAlias ? asName(tableAlias) + "." : "") + asName(f))
+        .map((f) => `md5(coalesce(${f}::text, 'dd'))`)
         .join(" || ") +
-      `)` + (alias ? ` as ${asName(alias)}` : "");
+      `)` +
+      (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 ")
-    }
+  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) => {
+    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 }
+      })
+      .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 } } ... `;
+    if (filter === null || (filter && !isObject(filter)))
+      throw `invalid filter -> ${JSON.stringify(filter)} \nExpecting:    undefined | {} | { field_name: "value" } | { field: { $gt: 22 } } ... `;
   }
 
-  getInfo = getInfo.bind(this)
+  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
-    })));
+    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 }`;
-      },
+      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 firstValid = fieldParams.find((fp) => fp !== undefined);
+          return this.parseFieldFilter(firstValid);
         };
 
       const res: ValidatedTableRules = {
@@ -197,19 +252,30 @@ export class ViewHandler {
         if (!tableRules.select.fields) return throwFieldsErr("select");
 
         let maxLimit: number | null = null;
-        if (!localParams?.bypassLimit && tableRules.select.maxLimit !== undefined && tableRules.select.maxLimit !== maxLimit) {
+        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;
+          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)
+        const fields = this.parseFieldFilter(tableRules.select.fields);
         res.select = {
           fields,
-          orderByFields: tableRules.select.orderByFields ? this.parseFieldFilter(tableRules.select.orderByFields) : fields,
+          orderByFields:
+            tableRules.select.orderByFields ?
+              this.parseFieldFilter(tableRules.select.orderByFields)
+            : fields,
           forcedFilter: { ...tableRules.select.forcedFilter },
           filterFields: this.parseFieldFilter(tableRules.select.filterFields),
-          maxLimit
+          maxLimit,
         };
       }
 
@@ -220,9 +286,13 @@ export class ViewHandler {
           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)
-        }
+          returningFields: getFirstSpecified(
+            tableRules.update?.returningFields,
+            tableRules?.select?.fields,
+            tableRules.update.fields
+          ),
+          filterFields: this.parseFieldFilter(tableRules.update.filterFields),
+        };
       }
 
       if (tableRules.insert) {
@@ -231,8 +301,12 @@ export class ViewHandler {
         res.insert = {
           fields: this.parseFieldFilter(tableRules.insert.fields),
           forcedData: { ...tableRules.insert.forcedData },
-          returningFields: getFirstSpecified(tableRules.insert.returningFields, tableRules?.select?.fields, tableRules.insert.fields)
-        }
+          returningFields: getFirstSpecified(
+            tableRules.insert.returningFields,
+            tableRules?.select?.fields,
+            tableRules.insert.fields
+          ),
+        };
       }
 
       if (tableRules.delete) {
@@ -241,8 +315,12 @@ export class ViewHandler {
         res.delete = {
           forcedFilter: { ...tableRules.delete.forcedFilter },
           filterFields: this.parseFieldFilter(tableRules.delete.filterFields),
-          returningFields: getFirstSpecified(tableRules.delete.returningFields, tableRules?.select?.fields, tableRules.delete.filterFields)
-        }
+          returningFields: getFirstSpecified(
+            tableRules.delete.returningFields,
+            tableRules?.select?.fields,
+            tableRules.delete.filterFields
+          ),
+        };
       }
 
       if (!tableRules.select && !tableRules.update && !tableRules.delete && !tableRules.insert) {
@@ -269,65 +347,125 @@ export class ViewHandler {
           filterFields: allCols,
           forcedFilter: {},
           forcedData: {},
-          returningFields: allCols
+          returningFields: allCols,
         },
         insert: {
           fields: allCols,
           forcedData: {},
-          returningFields: allCols
+          returningFields: allCols,
         },
         delete: {
           filterFields: allCols,
           forcedFilter: {},
-          returningFields: allCols
-        }
+          returningFields: allCols,
+        },
       };
-
     }
-
   }
   find = find.bind(this);
-  
-  async findOne(filter?: Filter, selectParams?: SelectParams, _param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
 
+  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 });
+      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 });
+      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> {
+  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,
       //@ts-ignore
-      return subscribe.bind(this)(filter, params, localFuncs, table_rules, localParams);
+      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);
+  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[] {
+  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[] = [];
@@ -338,22 +476,26 @@ export class ViewHandler {
     if (allowed_cols) {
       allowedFields = this.parseFieldFilter(allowed_cols, allow_empty);
     }
-    let col_names = (resultFields || []).filter(f => !allowedFields || allowedFields.includes(f));
+    let col_names = (resultFields || []).filter((f) => !allowedFields || allowedFields.includes(f));
 
     /* Maintain allowed cols order */
-    if (selectParams === "*" && allowedFields && allowedFields.length){ 
+    if (selectParams === "*" && allowedFields && allowedFields.length) {
       col_names = allowedFields;
     }
 
     return col_names;
-  } 
+  }
 
   /**
    * Parses group or simple filter
    */
-  prepareWhere = prepareWhere.bind(this); 
+  prepareWhere = prepareWhere.bind(this);
 
-  intersectColumns(allowedFields: FieldFilter, dissallowedFields: FieldFilter, removeDisallowedFields = false): string[] {
+  intersectColumns(
+    allowedFields: FieldFilter,
+    dissallowedFields: FieldFilter,
+    removeDisallowedFields = false
+  ): string[] {
     let result: string[] = [];
     if (allowedFields) {
       result = this.parseFieldFilter(allowedFields);
@@ -362,32 +504,33 @@ export class ViewHandler {
       const _dissalowed = this.parseFieldFilter(dissallowedFields);
 
       if (!removeDisallowedFields) {
-
-        throw `dissallowed/invalid field found for ${this.name}: `
+        throw `dissallowed/invalid field found for ${this.name}: `;
       }
-      result = result.filter(key => !_dissalowed.includes(key));
+      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))
+  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
-*/
+/**
+ * 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));
+    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

@@ -1,38 +1,69 @@
 import { SelectParams } from "prostgles-types";
 import { TableRule } from "../../PublishParser/publishTypesAndUtils";
 import { Filter, LocalParams } from "../DboBuilder";
-import { getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../dboBuilderUtils";
+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> {
+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);
-      });
+    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 });
+    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 });
+    await this._log({
+      command: "count",
+      localParams,
+      data: { filter },
+      duration: Date.now() - start,
+      error: getErrorAsObject(e),
+    });
+    throw getSerializedClientErrorFromPGError(e, {
+      type: "tableMethod",
+      localParams,
+      view: this,
+    });
   }
-}
+}