prostgles-server 4.2.623 → 4.2.625

package/lib/DboBuilder/QueryBuilder/getQuerySource.ts

@@ -0,0 +1,55 @@
+import { asName, type SelectParams } from "prostgles-types";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type {
+  Awaitable,
+  SelectRequestData,
+  SelectRule,
+} from "../../PublishParser/publishTypesAndUtils";
+import type { PGIdentifier } from "../DboBuilder";
+import type { ViewHandler } from "../ViewHandler/ViewHandler";
+
+const GET_TABLE_EXPRESSION = Symbol("getTableExpression");
+const TABLE_EXPRESSION_ALIAS = "prostgles_table_expression";
+
+type SelectRuleWithTableExpression = SelectRule & {
+  [GET_TABLE_EXPRESSION]?: (request: SelectRequestData) => Awaitable<string | undefined>;
+};
+
+export type QuerySource = {
+  expression: string;
+  alias?: PGIdentifier;
+};
+
+export const withTableExpression = <T extends SelectRule>(
+  selectRule: T,
+  getTableExpression: NonNullable<SelectRuleWithTableExpression[typeof GET_TABLE_EXPRESSION]>,
+): T => {
+  return Object.assign(selectRule, { [GET_TABLE_EXPRESSION]: getTableExpression });
+};
+
+export const getQuerySource = async (
+  viewHandler: ViewHandler,
+  tableRules: ParsedTableRule | undefined,
+  filter: SelectRequestData["filter"],
+  params: SelectParams,
+  preferredAlias?: PGIdentifier,
+): Promise<QuerySource> => {
+  const selectRule = tableRules?.select as SelectRuleWithTableExpression | undefined;
+  const getTableExpression = selectRule?.[GET_TABLE_EXPRESSION];
+  const tableExpression =
+    getTableExpression ? await getTableExpression({ filter, params }) : undefined;
+  const alias =
+    preferredAlias ??
+    (tableExpression ?
+      { raw: TABLE_EXPRESSION_ALIAS, escaped: asName(TABLE_EXPRESSION_ALIAS) }
+    : undefined);
+
+  return {
+    expression: tableExpression ?? viewHandler.escapedName,
+    alias,
+  };
+};
+
+export const getQuerySourceSQL = ({ expression, alias }: QuerySource) => {
+  return `${expression}${alias ? ` ${alias.escaped}` : ""}`;
+};

package/lib/DboBuilder/QueryBuilder/getSelectQuery.ts

@@ -3,6 +3,7 @@ import { isDefined, asName } from "prostgles-types";
 import type { NewQuery } from "./QueryBuilder";
 import type { ViewHandler } from "../ViewHandler/ViewHandler";
 import { getJoinQuery } from "./getJoinQuery";
+import { getQuerySourceSQL } from "./getQuerySource";
 
 /**
  * Used to prevent single row nested results in case of OR join conditions
@@ -46,6 +47,7 @@ export function getSelectQuery(
 
   /** OR joins cannot be easily aggregated to one-many with the root table. Must group by root table id */
   const hasOrJoins = parsedJoins.some((j) => j.isOrJoin);
+  const tableExpression = getQuerySourceSQL(q.source);
 
   const joinCtes: string[][] = parsedJoins
     .map((j) => {
@@ -58,7 +60,7 @@ export function getSelectQuery(
     joinCtes.unshift([
       `${q.table.escaped} AS (`,
       `  SELECT *, ${pkey ? asName(pkey.name) : "ROW_NUMBER() OVER()"} as ${ROOT_TABLE_ROW_NUM_ID}`,
-      `  FROM ${q.table.escaped}`,
+      `  FROM ${tableExpression}`,
       `)`,
     ]);
   }
@@ -80,7 +82,11 @@ export function getSelectQuery(
     ...indentLines(selectItems, { appendCommas: true }),
     `FROM ( `,
     `  SELECT *`,
-    `  FROM ${q.table.escaped}`,
+    `  FROM ${
+      hasOrJoins ?
+        getQuerySourceSQL({ expression: q.table.escaped, alias: q.source.alias })
+      : tableExpression
+    }`,
     ...(q.where ? [`  ${q.where}`] : []),
     `) ${ROOT_TABLE_ALIAS}`,
     ...parsedJoins.flatMap((j) => j.joinLines),

package/lib/DboBuilder/QueryBuilder/parseJoinSelect.ts

@@ -0,0 +1,73 @@
+import type {
+  DetailedJoinSelect,
+  JoinPath,
+  JoinSelect,
+  RawJoinPath,
+  SimpleJoinSelect,
+} from "prostgles-types";
+import { getKeys, includes } from "prostgles-types";
+
+const JOIN_KEYS = ["$innerJoin", "$leftJoin"] as const;
+const JOIN_PARAM_KEYS = getKeys({
+  $condition: 1,
+  filter: 1,
+  having: 1,
+  limit: 1,
+  offset: 1,
+  orderBy: 1,
+  select: 1,
+} satisfies Record<keyof Omit<DetailedJoinSelect, (typeof JOIN_KEYS)[number]>, 1>);
+
+export type ParsedJoin =
+  | {
+      type: "detailed";
+      params: DetailedJoinSelect & {
+        table: DetailedJoinSelect["$leftJoin"];
+        path: RawJoinPath;
+      };
+    }
+  | { type: "simple"; params: SimpleJoinSelect };
+
+export const parseJoinSelect = (joinParams: JoinSelect): ParsedJoin | string => {
+  if (!(joinParams as string)) {
+    return "Empty join params";
+  }
+  if (typeof joinParams === "string") {
+    if ((joinParams as string) !== "*") {
+      throw "Join select can be * or { field: 1 }";
+    }
+    return {
+      type: "simple",
+      params: joinParams,
+    };
+  }
+  const [joinKey, ...otherKeys] = getKeys(joinParams).filter((k) => includes(JOIN_KEYS, k));
+  if (otherKeys.length) {
+    return "Cannot specify more than one join type ( $innerJoin OR $leftJoin )";
+  } else if (joinKey) {
+    /* Full option join  { field_name: db.innerJoin.table_name(filter, select)  } */
+    const invalidParams = Object.keys(joinParams).filter(
+      (k) => !includes([...JOIN_PARAM_KEYS, ...JOIN_KEYS], k),
+    );
+    if (invalidParams.length) {
+      throw "Invalid join params: " + invalidParams.join(", ");
+    }
+    const path = joinParams[joinKey] as string | JoinPath[];
+    if (Array.isArray(path) && !path.length) {
+      throw `Cannot have an empty join path/tableName ${joinKey}`;
+    }
+    return {
+      type: "detailed",
+      params: {
+        ...(joinParams as DetailedJoinSelect),
+        path,
+        table: typeof path === "string" ? path : path.at(-1)!.table,
+      },
+    };
+  }
+
+  return {
+    type: "simple",
+    params: joinParams as SimpleJoinSelect,
+  };
+};

package/lib/DboBuilder/TableHandler/TableHandler.ts

@@ -19,11 +19,7 @@ import type {
 import { getSyncBatchOptions } from "../../PubSubManager/SyncReplication/getSyncBatchOptions";
 import type { TableDefinition } from "../../TableConfig/TableConfigTypes";
 import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
-import {
-  getErrorAsObject,
-  getSerializedClientErrorFromPGError,
-  withUserRLS,
-} from "../DboBuilder";
+import { getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../DboBuilder";
 import type { TableSchema } from "../DboBuilderTypes";
 import { parseUpdateRules } from "../parseUpdateRules";
 import { COMPUTED_FIELDS } from "../QueryBuilder/Functions/COMPUTED_FIELDS";
@@ -41,6 +37,7 @@ import { isApplicableHook } from "./isApplicableHook";
 import type { TableConfigurator } from "../../TableConfig/TableConfigurator";
 import type { TableHooksDefinition } from "../../TableHooks/TableHooks";
 import type { TransactionCallbacks } from "../../PublishParser/publishTypesAndUtils";
+import { prepareWhere } from "../ViewHandler/prepareWhere";
 
 export type ValidatedParams = {
   row: AnyObject;
@@ -359,7 +356,7 @@ export class TableHandler extends ViewHandler {
       ).then(async (data: AnyObject[]) => {
         const { filterFields, forcedFilter } = table_rules.select || {};
         const condition = (
-          await this.prepareWhere({
+          await prepareWhere(this, {
             select: undefined,
             filter,
             forcedFilter,

package/lib/DboBuilder/TableHandler/delete.ts

@@ -11,6 +11,7 @@ import {
 import { getReturnTypeQuery } from "../ViewHandler/getReturnTypeQuery";
 import type { TableHandler } from "./TableHandler";
 import { executeAfterHooksCheckAndPostValidation } from "./executeAfterHooksCheckAndPostValidation";
+import { prepareWhere } from "../ViewHandler/prepareWhere";
 
 export async function _delete(
   this: TableHandler,
@@ -86,7 +87,7 @@ export async function _delete(
 
     let queryType: keyof pgPromise.ITask<{}> = "none";
     let queryWithoutRLS = `DELETE FROM ${this.escapedName} `;
-    const filterOpts = await this.prepareWhere({
+    const filterOpts = await prepareWhere(this, {
       select: undefined,
       filter,
       forcedFilter,

package/lib/DboBuilder/TableHandler/runInsertUpdateQuery.ts

@@ -6,6 +6,7 @@ import { rejectWithPGClientError, withUserRLS } from "../DboBuilder";
 import type { TableHandler } from "./TableHandler";
 import { getSelectItemQuery } from "./TableHandler";
 import { executeAfterHooksCheckAndPostValidation } from "./executeAfterHooksCheckAndPostValidation";
+import { prepareWhere } from "../ViewHandler/prepareWhere";
 
 type RunInsertUpdateQueryArgs = {
   tableHandler: TableHandler;
@@ -54,7 +55,7 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
   // let checkCondition = "WHERE FALSE";
   let checkCondition = "FALSE";
   if (checkFilter) {
-    const checkCond = await tableHandler.prepareWhere({
+    const checkCond = await prepareWhere(tableHandler, {
       select: undefined,
       localParams: undefined,
       tableRule: undefined,

package/lib/DboBuilder/TableHandler/update.ts

@@ -9,6 +9,7 @@ import { getReferenceColumnInserts } from "./insert/getReferenceColumnInserts";
 import { runInsertUpdateQuery } from "./runInsertUpdateQuery";
 import { lockFileForUpdate } from "./updateFile";
 import type { TableHandler } from "./TableHandler";
+import { prepareWhere } from "../ViewHandler/prepareWhere";
 
 export async function update(
   this: TableHandler,
@@ -66,7 +67,7 @@ export async function update(
         );
     }
 
-    const updateFilter = await this.prepareWhere({
+    const updateFilter = await prepareWhere(this, {
       select: undefined,
       filter,
       forcedFilter,

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -13,26 +13,25 @@ import type { TableEvent } from "../../Logging";
 import type { DB } from "../../Prostgles";
 import type { Join } from "../../ProstglesTypes";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { Graph } from "../joins/shortestPath";
+import type { VoidFunction } from "../../SchemaWatch/SchemaWatch";
+import type { TableDefinition } from "../../TableConfig/TableConfigTypes";
+import type { TableHooksDefinition } from "../../TableHooks/TableHooks";
+import { escapeTSNames } from "../../utils/utils";
 import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
 import { getSerializedClientErrorFromPGError } from "../DboBuilder";
 import type { TableSchema } from "../DboBuilderTypes";
 import { getValidatedTableRules } from "../TableRules/getValidatedTableRules";
 import { getColumns } from "../getColumns";
+import type { Graph } from "../joins/shortestPath";
 import { count } from "./count";
 import { find, type Param3 } from "./find";
+import { getDbHandlerWithAbort } from "./getDbHandlerWithAbort";
 import { getInfo } from "./getInfo";
 import { parseFieldFilter } from "./parseFieldFilter";
-import { prepareWhere } from "./prepareWhere";
 import { size } from "./size";
 import type { OnData } from "./subscribe";
 import { subscribe } from "./subscribe";
 import { validateViewRules } from "./validateViewRules";
-import { escapeTSNames } from "../../utils/utils";
-import type { TableDefinition } from "../../TableConfig/TableConfigTypes";
-import { getDbHandlerWithAbort } from "./getDbHandlerWithAbort";
-import type { VoidFunction } from "../../SchemaWatch/SchemaWatch";
-import type { TableHooksDefinition } from "../../TableHooks/TableHooks";
 
 export type JoinPaths = {
   t1: string;
@@ -338,11 +337,6 @@ export class ViewHandler {
     return col_names;
   }
 
-  /**
-   * Parses group or simple filter
-   */
-  prepareWhere = prepareWhere.bind(this);
-
   intersectColumns(
     allowedFields: FieldFilter,
     disallowedFields: FieldFilter,

package/lib/DboBuilder/ViewHandler/find.ts

@@ -101,7 +101,6 @@ export const find = async function (
       this,
       filter,
       selectParamsLimitCheck,
-      undefined,
       tableRules,
       localParams,
     );

package/lib/DboBuilder/ViewHandler/getExistsCondition.ts

@@ -1,10 +1,11 @@
-import type { AnyObject, EXISTS_KEY, FieldFilter } from "prostgles-types";
-import { EXISTS_KEYS, asName } from "prostgles-types";
-import type { LocalParams, ExistsFilterConfig } from "../DboBuilder";
-import type { ViewHandler } from "./ViewHandler";
+import type { EXISTS_KEY } from "prostgles-types";
+import { EXISTS_KEYS } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { TableHandler } from "../TableHandler/TableHandler";
-import { getTableJoinQuery } from "./getTableJoinQuery";
+import type { ExistsFilterConfig, LocalParams } from "../DboBuilder";
+import { getQuerySourceSQL } from "../QueryBuilder/getQuerySource";
+import { getTableJoinAlias, getTableJoinQuery } from "./getTableJoinQuery";
+import type { ViewHandler } from "./ViewHandler";
+import { prepareWhere } from "./prepareWhere";
 
 export async function getExistsCondition(
   this: ViewHandler,
@@ -25,17 +26,22 @@ export async function getExistsCondition(
     };
   }
 
-  let t2Rules: ParsedTableRule | undefined = undefined,
-    forcedFilter: AnyObject | undefined,
-    filterFields: FieldFilter | undefined;
-
   /* Check if allowed to view data - forcedFilters will bypass this check through isForcedFilterBypass */
   if (localParams?.isRemoteRequest && !localParams.clientReq) {
     throw "Unexpected: localParams isRemoteRequest and missing clientReq";
   }
+
+  let targetTableRules: ParsedTableRule | undefined = undefined;
   const targetTable = eConfig.isJoined ? eConfig.parsedPath.at(-1)!.table : eConfig.targetTable;
-  if (localParams?.clientReq && this.dboBuilder.publishParser) {
-    t2Rules = await this.dboBuilder.publishParser.getValidatedRequestRuleWusr(
+  const tableHandler = this.dboBuilder.dboMap.get(targetTable);
+  if (!tableHandler) {
+    throw `Table handler for ${targetTable} not found`;
+  }
+  if (localParams?.clientReq) {
+    if (!this.dboBuilder.publishParser) {
+      throw "Unexpected: missing publishParser";
+    }
+    targetTableRules = await this.dboBuilder.publishParser.getValidatedRequestRuleWusr(
       {
         tableName: targetTable,
         command: "find",
@@ -44,27 +50,27 @@ export async function getExistsCondition(
       localParams.scope,
     );
 
-    if (!t2Rules.select) throw "Disallowed";
-    ({ forcedFilter, filterFields } = t2Rules.select);
+    if (!targetTableRules.select) throw "Disallowed";
   }
 
-  const tableHandler = this.dboBuilder.dbo[targetTable] as TableHandler;
-  const finalWhere = (
-    await tableHandler.prepareWhere({
-      select: undefined,
-      filter: targetTableFilter,
-      forcedFilter,
-      filterFields,
-      addWhere: false,
-      tableAlias: undefined,
-      localParams,
-      tableRule: t2Rules,
-    })
-  ).where;
+  const targetAlias =
+    eConfig.isJoined ? getTableJoinAlias(targetTable, eConfig.parsedPath.length - 1) : undefined;
+  const whereOpts = await prepareWhere(tableHandler, {
+    select: undefined,
+    selectParams: {},
+    filter: targetTableFilter,
+    forcedFilter: targetTableRules?.select?.forcedFilter,
+    filterFields: targetTableRules?.select?.filterFields,
+    tableRule: targetTableRules,
+    addWhere: false,
+    tableAlias: targetAlias,
+    localParams,
+  });
+  const { source: targetSource, where: finalWhere } = whereOpts;
 
   let innerQuery = [
     `SELECT 1`,
-    `FROM ${asName(targetTable)}`,
+    `FROM ${getQuerySourceSQL(targetSource)}`,
     `${finalWhere ? `WHERE ${finalWhere}` : ""}`,
   ].join("\n");
 
@@ -74,6 +80,7 @@ export async function getExistsCondition(
       rootTableAlias: rootTableAlias ?? rootTable,
       type: "EXISTS",
       finalWhere,
+      finalTableExpression: targetSource.expression,
     });
     innerQuery = query;
   }

package/lib/DboBuilder/ViewHandler/getTableJoinQuery.ts

@@ -1,10 +1,12 @@
 import { asName } from "prostgles-types";
+import type { PGIdentifier } from "../DboBuilder";
 import type { ParsedJoinPath } from "./parseJoinPath";
 
 type getTableJoinsArgs = {
   rootTableAlias: string;
   type: "INNER" | "LEFT" | "EXISTS";
   finalWhere?: string;
+  finalTableExpression?: string;
   path: ParsedJoinPath[];
 };
 export const getTableJoinQuery = ({
@@ -12,14 +14,14 @@ export const getTableJoinQuery = ({
   type,
   rootTableAlias,
   finalWhere,
+  finalTableExpression,
 }: getTableJoinsArgs): { targetAlias: string; query: string } => {
   const [firstPath] = path;
   if (!firstPath) {
     throw `Cannot create join query for empty path`;
   }
-  const aliasSufix = "jd";
   const getTableAlias = (table: string, pathIndex: number) =>
-    asName(`${aliasSufix}_${pathIndex}_${table}`);
+    getTableJoinAlias(table, pathIndex).escaped;
 
   const query = path
     .map(({ table, on }, i) => {
@@ -45,19 +47,19 @@ export const getTableJoinQuery = ({
        */
       const whereJoinCondition =
         isLast && isExists ?
-          `WHERE (${getJoinOnCondition({
-            on: firstPath.on,
-            leftAlias: rootTableAlias,
-            rightAlias: getTableAlias(firstPath.table, 0),
-          })})`
+          `WHERE (${[
+            getJoinOnCondition({
+              on: firstPath.on,
+              leftAlias: rootTableAlias,
+              rightAlias: getTableAlias(firstPath.table, 0),
+            }),
+            finalWhere,
+          ]
+            .filter(Boolean)
+            .join(") AND (")})`
         : "";
 
-      const tableSelect =
-        isExists && isLast ?
-          [`(`, ` SELECT *`, ` FROM ${tableName}`, finalWhere ? `  WHERE ${finalWhere}` : "", `)`]
-            .filter((v) => v)
-            .join("\n")
-        : tableName;
+      const tableSelect = isLast ? (finalTableExpression ?? tableName) : tableName;
       if (isExists && isFirst) {
         return [`SELECT 1`, `FROM ${tableSelect} ${tableAlias}`, whereJoinCondition]
           .filter((v) => v)
@@ -76,6 +78,12 @@ export const getTableJoinQuery = ({
   };
 };
 
+export const getTableJoinAlias = (table: string, pathIndex: number): PGIdentifier => {
+  const prefix = "jd";
+  const raw = `${prefix}_${pathIndex}_${table}`;
+  return { raw, escaped: asName(raw) };
+};
+
 type GetJoinOnConditionArgs = {
   on: Record<string, string>[];
   leftAlias: string;
@@ -95,7 +103,7 @@ export const getJoinOnConditions = ({
       .map(([leftCol, rightCol]) => {
         return `${leftAlias}.${getLeftColName(leftCol)} = ${rightAlias}.${getRightColName(rightCol)}`;
       })
-      .join(" AND ")
+      .join(" AND "),
   );
 };
 

package/lib/DboBuilder/ViewHandler/prepareWhere.ts

@@ -1,9 +1,10 @@
-import type { AnyObject, FieldFilter } from "prostgles-types/dist";
+import type { AnyObject, FieldFilter, SelectParams } from "prostgles-types/dist";
 import { getKeys, isDefined, isObject } from "prostgles-types/dist";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import type { ExistsFilterConfig, Filter, LocalParams, PGIdentifier } from "../DboBuilder";
 import { getCondition } from "../getCondition";
 import { type SelectItemValidated } from "../QueryBuilder/QueryBuilder";
+import { getQuerySource, type QuerySource } from "../QueryBuilder/getQuerySource";
 import type { ViewHandler } from "./ViewHandler";
 
 export type PrepareWhereParams = {
@@ -16,46 +17,61 @@ export type PrepareWhereParams = {
   localParams: LocalParams | undefined;
   tableRule: ParsedTableRule | undefined;
   isHaving?: boolean;
+  selectParams?: SelectParams;
 };
 
-export async function prepareWhere(
-  this: ViewHandler,
-  params: PrepareWhereParams,
-): Promise<{
+export type WhereOptions = {
   columnsUsed: string[];
   condition: string;
   where: string;
   filter: AnyObject;
   exists: ExistsFilterConfig[];
-}> {
-  const {
+  source: QuerySource;
+};
+
+export const prepareWhere = async (
+  viewHandler: ViewHandler,
+  {
     filter,
     select,
     forcedFilter,
-    filterFields: ff,
     addWhere: addKeywords = true,
     tableAlias,
     localParams,
     tableRule,
-  } = params;
-  const { $and: $and_key, $or: $or_key } = this.dboBuilder.prostgles.keywords;
+    /* Local update allow all. TODO: tidy all calls */
+    filterFields = !tableRule ? "*" : undefined,
+    isHaving,
+    selectParams,
+  }: PrepareWhereParams,
+): Promise<WhereOptions> => {
+  const { $and: $and_key, $or: $or_key } = viewHandler.dboBuilder.prostgles.keywords;
+
+  if (localParams?.isRemoteRequest && !tableRule) {
+    throw "Unexpected: localParams isRemoteRequest and missing tableRule";
+  }
 
-  let filterFields = ff;
-  /* Local update allow all. TODO -> FIX THIS */
-  if (!ff && !tableRule) filterFields = "*";
+  const source = await getQuerySource(
+    viewHandler,
+    selectParams ? tableRule : undefined,
+    filter ?? {},
+    selectParams ?? {},
+    tableAlias,
+  );
 
   const exists: ExistsFilterConfig[] = [];
 
   type FilterItemResult = { condition: string; columnsUsed: string[] };
   const parseFullFilter = async (
-    f: any,
+    fullFilter: any,
     parentFilter: AnyObject | null = null,
     isForcedFilterBypass: boolean,
   ): Promise<FilterItemResult | undefined> => {
-    if (!f) throw "Invalid/missing group filter provided";
-    if (!isObject(f)) throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(f);
+    if (!fullFilter) throw "Invalid/missing group filter provided";
+    if (!isObject(fullFilter))
+      throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(fullFilter);
 
-    const keys = getKeys(f);
+    const keys = getKeys(fullFilter);
     if (!keys.length) {
       return;
     }
@@ -66,8 +82,8 @@ export async function prepareWhere(
         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[] | undefined = $and || $or;
+    const { [$and_key]: $and, [$or_key]: $or } = fullFilter;
+    const group = ($and || $or) as AnyObject[] | undefined;
 
     if (group && group.length) {
       const operand = $and ? " AND " : " OR ";
@@ -82,20 +98,24 @@ export async function prepareWhere(
       if (conditionItems.length) {
         const conditions = conditionItems.map((c) => c.condition);
         const columnsUsed = conditionItems.map((c) => c.columnsUsed).flat();
-        if (conditions.length === 1) return { columnsUsed, condition: conditions.join(operand) };
-        else return { columnsUsed, condition: ` ( ${conditions.sort().join(operand)} ) ` };
+        if (conditions.length === 1) {
+          return { columnsUsed, condition: conditions.join(operand) };
+        }
+        return { columnsUsed, condition: ` ( ${conditions.sort().join(operand)} ) ` };
       }
     } else if (!group) {
       /** forcedFilters do not get checked against publish and are treated as server-side requests */
-      const itemInfo = await getCondition.bind(this)({
-        filter: { ...f },
+      const itemInfo = await getCondition.bind(viewHandler)({
+        filter: { ...fullFilter },
         select,
         allowed_colnames:
-          isForcedFilterBypass ? this.column_names.slice(0) : this.parseFieldFilter(filterFields),
-        tableAlias,
+          isForcedFilterBypass ?
+            viewHandler.column_names.slice(0)
+          : viewHandler.parseFieldFilter(filterFields),
+        tableAlias: source.alias,
         localParams: isForcedFilterBypass ? undefined : localParams,
         tableRules: isForcedFilterBypass ? undefined : tableRule,
-        isHaving: params.isHaving,
+        isHaving,
       });
       exists.push(...itemInfo.exists);
       return {
@@ -135,5 +155,6 @@ export async function prepareWhere(
     where: combinedConditions || "",
     filter: finalFilter,
     exists,
+    source,
   };
-}
+};