prostgles-server 4.2.624 → 4.2.625

package/lib/DboBuilder/QueryBuilder/getNewQuery.ts

@@ -1,255 +1,172 @@
-import type {
-  DetailedJoinSelect,
-  JoinPath,
-  JoinSelect,
-  RawJoinPath,
-  SelectParams,
-  SimpleJoinSelect,
-} from "prostgles-types";
-import { asName, getKeys, includes, isEmpty, omitKeys } from "prostgles-types";
+import type { SelectParams } from "prostgles-types";
+import { asName, isEmpty, omitKeys } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import type { Filter, LocalParams, PGIdentifier, ValidatedTableRules } from "../DboBuilder";
 import type { ViewHandler } from "../ViewHandler/ViewHandler";
 import { parseJoinPath } from "../ViewHandler/parseJoinPath";
 import { prepareSortItems } from "../ViewHandler/prepareSortItems";
-import type { PrepareWhereParams } from "../ViewHandler/prepareWhere";
+import { prepareWhere, type PrepareWhereParams } from "../ViewHandler/prepareWhere";
 import { COMPUTED_FIELDS } from "./Functions/COMPUTED_FIELDS";
 import { FUNCTIONS } from "./Functions/Functions";
 import type { NewQuery, NewQueryJoin } from "./QueryBuilder";
 import { SelectItemBuilder } from "./QueryBuilder";
+import { ROOT_TABLE_ALIAS } from "./getSelectQuery";
 
-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>);
-
-type ParsedJoin =
-  | {
-      type: "detailed";
-      params: DetailedJoinSelect & {
-        table: DetailedJoinSelect["$leftJoin"];
-        path: RawJoinPath;
-      };
-    }
-  | { type: "simple"; params: SimpleJoinSelect }
-  | { type?: undefined; error: string };
-
-const parseJoinSelect = (joinParams: JoinSelect): ParsedJoin => {
-  if (!(joinParams as string)) {
-    return {
-      error: "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 {
-      error: "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,
-  };
-};
-
-export async function getNewQuery(
-  _this: ViewHandler,
+export const getNewQuery = async (
+  viewHandler: ViewHandler,
   filter: Filter,
   selectParams: SelectParams & { joinExpressionAlias?: PGIdentifier } = {},
-  param3_unused = null,
   tableRules: ParsedTableRule | undefined,
   localParams: LocalParams | undefined,
-): Promise<NewQuery> {
-  const { columns } = _this;
+): Promise<NewQuery> => {
+  const { columns } = viewHandler;
 
   if (localParams?.isRemoteRequest && !tableRules?.select?.fields) {
-    throw `INTERNAL ERROR: publish.${_this.name}.select.fields rule missing`;
+    throw `INTERNAL ERROR: publish.${viewHandler.name}.select.fields rule missing`;
   }
 
   const allowedOrderByFields =
     !tableRules ?
-      _this.column_names.slice(0)
-    : _this.parseFieldFilter(tableRules.select?.orderByFields ?? tableRules.select?.fields);
+      viewHandler.column_names.slice(0)
+    : viewHandler.parseFieldFilter(tableRules.select?.orderByFields ?? tableRules.select?.fields);
   const allowedSelectFields =
-    !tableRules ? _this.column_names.slice(0) : _this.parseFieldFilter(tableRules.select?.fields);
+    !tableRules ?
+      viewHandler.column_names.slice(0)
+    : viewHandler.parseFieldFilter(tableRules.select?.fields);
 
   const joinQueries: NewQueryJoin[] = [];
 
-  const { select: userSelect = "*" } = selectParams,
-    sBuilder = new SelectItemBuilder({
-      allowedFields: allowedSelectFields,
-      allowedOrderByFields,
-      computedFields: COMPUTED_FIELDS,
-      isView: _this.isView,
-      functions: FUNCTIONS,
-      allFields: _this.column_names.slice(0),
-      columns,
-    });
-
-  await sBuilder.parseUserSelect(userSelect, async (joinColumnName, _joinParams, throwErr) => {
-    const j_selectParams: SelectParams = {};
-    let j_filter: Filter = {},
-      j_isLeftJoin = true;
+  const { select: userSelect = "*" } = selectParams;
 
-    const parsedJoin = parseJoinSelect(_joinParams);
-
-    if (!parsedJoin.type) {
-      throwErr(parsedJoin.error);
-      return;
-    }
-    const joinExpressionAlias = { raw: joinColumnName, escaped: asName(joinColumnName) };
-    const j_path = parseJoinPath({
-      rawPath: parsedJoin.type === "simple" ? joinColumnName : parsedJoin.params.path,
-      rootTable: _this.name,
-      viewHandler: _this,
-      allowMultiOrJoin: true,
-      addShortestJoinIfMissing: true,
-    });
-
-    if (parsedJoin.params === "*") {
-      j_selectParams.select = "*";
-    } else if (parsedJoin.type === "detailed") {
-      const joinParams = parsedJoin.params;
-
-      j_isLeftJoin = !!joinParams.$leftJoin;
-
-      j_selectParams.select = joinParams.select || "*";
-      j_filter = joinParams.filter || {};
-      j_selectParams.limit = joinParams.limit;
-      j_selectParams.offset = joinParams.offset;
-      j_selectParams.orderBy = joinParams.orderBy;
-      j_selectParams.having = joinParams.having;
-    } else {
-      j_selectParams.select = parsedJoin.params;
-    }
-
-    const joinTableName =
-      parsedJoin.type === "simple" ? joinColumnName
-      : typeof j_path === "string" ? j_path
-      : j_path.at(-1)?.table;
-    if (!joinTableName) {
-      throw "jTable missing";
-    }
-    const joinTableHandler = _this.dboBuilder.dbo[joinTableName] as ViewHandler | undefined;
-    if (!joinTableHandler) {
-      throw `Joined table ${JSON.stringify(joinTableName)} is disallowed or inexistent \nOr you forgot to put the function arguments into an array`;
-    }
+  const selectItemBuilder = new SelectItemBuilder({
+    allowedFields: allowedSelectFields,
+    allowedOrderByFields,
+    computedFields: COMPUTED_FIELDS,
+    isView: viewHandler.isView,
+    functions: FUNCTIONS,
+    allFields: viewHandler.column_names.slice(0),
+    columns,
+  });
 
-    let joinTableRules: ParsedTableRule | undefined;
-    let isLocal = true;
-    if (localParams && localParams.clientReq) {
-      isLocal = false;
-      joinTableRules = await _this.dboBuilder.publishParser?.getValidatedRequestRuleWusr(
-        {
-          tableName: joinTableName,
-          command: "find",
-          clientReq: localParams.clientReq,
-        },
-        localParams.scope,
-      );
-    }
+  await selectItemBuilder.parseUserSelectWithJoins(
+    userSelect,
+    async (joinColumnName, parsedJoin) => {
+      const j_selectParams: SelectParams = {};
+      let j_filter: Filter = {},
+        j_isLeftJoin = true;
+
+      const joinExpressionAlias = { raw: joinColumnName, escaped: asName(joinColumnName) };
+      const j_path = parseJoinPath({
+        rawPath: parsedJoin.type === "simple" ? joinColumnName : parsedJoin.params.path,
+        rootTable: viewHandler.name,
+        viewHandler: viewHandler,
+        allowMultiOrJoin: true,
+        addShortestJoinIfMissing: true,
+      });
 
-    const isAllowedAccessToTable = isLocal || joinTableRules;
-    if (isAllowedAccessToTable) {
+      if (parsedJoin.params === "*") {
+        j_selectParams.select = "*";
+      } else if (parsedJoin.type === "detailed") {
+        const joinParams = parsedJoin.params;
+
+        j_isLeftJoin = !!joinParams.$leftJoin;
+
+        j_filter = joinParams.filter || {};
+        j_selectParams.select = joinParams.select || "*";
+        j_selectParams.limit = joinParams.limit;
+        j_selectParams.offset = joinParams.offset;
+        j_selectParams.orderBy = joinParams.orderBy;
+        j_selectParams.having = joinParams.having;
+      } else {
+        j_selectParams.select = parsedJoin.params;
+      }
+
+      const joinTableName =
+        parsedJoin.type === "simple" ? joinColumnName
+        : typeof j_path === "string" ? j_path
+        : j_path.at(-1)?.table;
+      if (!joinTableName) {
+        throw "jTable missing";
+      }
+      const joinTableHandler = viewHandler.dboBuilder.dboMap.get(joinTableName);
+      if (!joinTableHandler) {
+        throw `Joined table ${JSON.stringify(joinTableName)} is disallowed or inexistent \nOr you forgot to put the function arguments into an array`;
+      }
+
+      let joinTableRules: ParsedTableRule | undefined;
+      let isLocal = true;
+      if (localParams && localParams.clientReq) {
+        isLocal = false;
+        joinTableRules = await viewHandler.dboBuilder.publishParser?.getValidatedRequestRuleWusr(
+          {
+            tableName: joinTableName,
+            command: "find",
+            clientReq: localParams.clientReq,
+          },
+          localParams.scope,
+        );
+      }
+
+      const isAllowedAccessToTable = isLocal || joinTableRules?.select;
+      if (!isAllowedAccessToTable) {
+        throw `Join select for ${JSON.stringify(joinTableName)} is invalid or not allowed`;
+      }
       const joinQuery: NewQuery = await getNewQuery(
         joinTableHandler,
         j_filter,
         { ...j_selectParams, joinExpressionAlias },
-        param3_unused,
         joinTableRules,
         localParams,
       );
       joinQuery.isLeftJoin = j_isLeftJoin;
-      joinQuery.tableAlias = joinExpressionAlias;
       joinQueries.push({
         ...joinQuery,
         joinPath: j_path,
         joinAlias: joinQuery.tableAlias ?? joinQuery.table,
       });
-    }
-  });
+    },
+  );
 
-  /**
-   * Is this still needed?!!!
-   * Add non selected columns
-   * This ensures all fields are available for orderBy in case of nested select
-   * */
-  Array.from(new Set([...allowedSelectFields, ...allowedOrderByFields])).map((key) => {
-    if (!sBuilder.select.find((s) => s.alias === key && s.type === "column")) {
-      sBuilder.addColumn(key, false);
-    }
-  });
-
-  const select = sBuilder.select;
+  const select = selectItemBuilder.select;
 
-  const tableAlias = selectParams.joinExpressionAlias;
   const commonWhereParams: PrepareWhereParams = {
     filter,
     select,
     forcedFilter: tableRules?.select?.forcedFilter,
     filterFields: tableRules?.select?.filterFields,
-    tableAlias,
+    tableAlias: selectParams.joinExpressionAlias,
     localParams,
     tableRule: tableRules,
     isHaving: false,
+    selectParams,
   };
-  const filterOpts = await _this.prepareWhere({
+  const filterOpts = await prepareWhere(viewHandler, {
     ...commonWhereParams,
     isHaving: false,
   });
+  const { source } = filterOpts;
   const havingOpts =
-    !isEmpty(selectParams.having) ?
-      await _this.prepareWhere({
-        ...omitKeys(commonWhereParams, ["forcedFilter"]),
+    isEmpty(selectParams.having) ? undefined : (
+      await prepareWhere(viewHandler, {
+        ...omitKeys(commonWhereParams, ["forcedFilter", "selectParams"]),
         filter: selectParams.having,
+        tableAlias:
+          selectParams.joinExpressionAlias ? source.alias : (
+            { raw: ROOT_TABLE_ALIAS, escaped: ROOT_TABLE_ALIAS }
+          ),
         isHaving: true,
       })
-    : undefined;
-  const where = filterOpts.where;
-  const validatedRules = _this.getValidatedRules(tableRules, localParams);
+    );
+  const validatedRules = viewHandler.getValidatedRules(tableRules, localParams);
 
-  const resQuery: NewQuery = {
-    allFields: _this.column_names.slice(0),
+  const newQuery: NewQuery = {
+    allFields: viewHandler.column_names.slice(0),
     select,
-    table: { raw: _this.name, escaped: _this.name },
+    table: { raw: viewHandler.name, escaped: viewHandler.name },
+    tableAlias: selectParams.joinExpressionAlias,
+    source,
     joins: joinQueries,
-    where,
+    where: filterOpts.where,
     whereOpts: filterOpts,
     having: havingOpts?.condition ?? "",
     isLeftJoin: false,
@@ -264,12 +181,12 @@ export async function getNewQuery(
     offset: prepareOffsetQuery(selectParams.offset),
   };
 
-  if (resQuery.select.some((s) => s.type === "aggregation") && resQuery.joins?.length) {
+  if (newQuery.select.some((s) => s.type === "aggregation") && newQuery.joins?.length) {
     throw new Error(`Root query aggregation AND nested joins not allowed`);
   }
 
-  return resQuery;
-}
+  return newQuery;
+};
 
 const prepareOffsetQuery = (offset?: number) => {
   if (Number.isInteger(offset)) {

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,
     );