prostgles-server 4.2.448 → 4.2.450

package/lib/DboBuilder/QueryBuilder/getJoinQuery.ts

@@ -6,7 +6,7 @@ import { type SelectItemValidated } from "./QueryBuilder";
 import { ROOT_TABLE_ALIAS, ROOT_TABLE_ROW_NUM_ID, indentLines } from "./getSelectQuery";
 import type { ViewHandler } from "../ViewHandler/ViewHandler";
 import { getJoinOnCondition } from "../ViewHandler/getTableJoinQuery";
-import { prepareOrderByQuery } from "../DboBuilder";
+import { prepareOrderByQuery, type PGIdentifier } from "../DboBuilder";
 import { asNameAlias } from "../../utils/asNameAlias";
 
 type Args = {
@@ -47,7 +47,7 @@ const getJoinTable = (
 };
 
 type GetJoinQueryResult = {
-  resultAlias: string;
+  resultAlias: PGIdentifier;
   firstJoinTableJoinFields: string[];
   isOrJoin: boolean;
   type: "cte";
@@ -68,7 +68,7 @@ type GetJoinQueryResult = {
  */
 export const getJoinQuery = (viewHandler: ViewHandler, { q1, q2 }: Args): GetJoinQueryResult => {
   const paths = parseJoinPath({
-    rootTable: q1.table,
+    rootTable: q1.table.raw,
     rawPath: q2.joinPath,
     viewHandler: viewHandler,
     allowMultiOrJoin: true,
@@ -78,7 +78,7 @@ export const getJoinQuery = (viewHandler: ViewHandler, { q1, q2 }: Args): GetJoi
   if (q2.joins?.length) {
     throw new Error("Nested joins not supported yet");
   }
-  const targetTableAliasRaw = q2.tableAlias || q2.table;
+  const targetTableAliasRaw = q2.tableAlias?.raw || q2.table.raw;
   const targetTableAlias = asName(targetTableAliasRaw);
 
   const firstJoinTablePath = paths[0]!;
@@ -101,7 +101,7 @@ export const getJoinQuery = (viewHandler: ViewHandler, { q1, q2 }: Args): GetJoi
 
   const joinCondition = getJoinOnCondition({
     on: firstJoinTablePath.on,
-    leftAlias: asName(q1.tableAlias || q1.table),
+    leftAlias: q1.tableAlias?.escaped || q1.table.escaped,
     rightAlias: targetTableAlias,
     getRightColName: (col) => getJoinCol(col).alias,
   });
@@ -110,7 +110,9 @@ export const getJoinQuery = (viewHandler: ViewHandler, { q1, q2 }: Args): GetJoi
   const selectedFields = rootSelectItems
     .filter((s) => s.selected)
     .map((s) => asNameAlias(s.alias, targetTableAliasRaw));
-  const rootNestedSort = q1.orderByItems.filter((d) => d.nested?.joinAlias === q2.joinAlias);
+  const rootNestedSort = q1.orderByItems.filter(
+    (d) => d.nested?.joinAlias.raw === q2.joinAlias.raw,
+  );
   const jsonAgg = `json_agg((SELECT x FROM (SELECT ${selectedFields.join(", ")}) as x )${jsonAggSort}) ${jsonAggLimit} as ${JSON_AGG_FIELD_NAME}`;
 
   const { innerQuery } = getInnerJoinQuery({
@@ -151,7 +153,7 @@ export const getJoinQuery = (viewHandler: ViewHandler, { q1, q2 }: Args): GetJoi
     ];
     return {
       type: "cte",
-      resultAlias: JSON_AGG_FIELD_NAME,
+      resultAlias: { raw: JSON_AGG_FIELD_NAME, escaped: JSON_AGG_FIELD_NAME },
       joinLines,
       cteLines: [],
       isOrJoin,
@@ -171,7 +173,9 @@ export const getJoinQuery = (viewHandler: ViewHandler, { q1, q2 }: Args): GetJoi
     `FROM (`,
     ...indentLines(innerQuery),
     `) ${targetTableAlias}`,
-    ...(isOrJoin ? [`LEFT JOIN ${q1.table} ${ROOT_TABLE_ALIAS}`, `ON ${joinCondition}`] : []),
+    ...(isOrJoin ?
+      [`LEFT JOIN ${q1.table.escaped} ${ROOT_TABLE_ALIAS}`, `ON ${joinCondition}`]
+    : []),
     `GROUP BY ${isOrJoin ? rootTableIdField : requiredJoinFields.join(", ")}`,
   ];
 
@@ -190,7 +194,7 @@ export const getJoinQuery = (viewHandler: ViewHandler, { q1, q2 }: Args): GetJoi
 
   return {
     type: "cte",
-    resultAlias: JSON_AGG_FIELD_NAME,
+    resultAlias: { raw: JSON_AGG_FIELD_NAME, escaped: JSON_AGG_FIELD_NAME },
     joinLines,
     cteLines,
     isOrJoin,
@@ -218,8 +222,8 @@ const getInnerJoinQuery = ({
     const prevTable = getJoinTable(
       !i ?
         q1.tableAlias ?
-          asName(q1.tableAlias)
-        : q1.table
+          q1.tableAlias.escaped
+        : q1.table.escaped
       : paths[i - 1]!.table,
       i - 1,
       undefined,
@@ -302,7 +306,7 @@ const getNestedSelectFields = ({
     .map((s) => ({
       ...s,
       isJoinCol: false,
-      query: s.getQuery(targetTableAlias) + " AS " + asName(s.alias),
+      query: s.getQuery(targetTableAlias.raw) + " AS " + asName(s.alias),
     }))
     .concat(
       requiredJoinFields.map((f) => ({

package/lib/DboBuilder/QueryBuilder/getNewQuery.ts

@@ -6,9 +6,9 @@ import type {
   SelectParams,
   SimpleJoinSelect,
 } from "prostgles-types";
-import { getKeys, includes, isEmpty, omitKeys } from "prostgles-types";
+import { asName, getKeys, includes, isEmpty, omitKeys } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { Filter, LocalParams, ValidatedTableRules } from "../DboBuilder";
+import type { Filter, LocalParams, PGIdentifier, ValidatedTableRules } from "../DboBuilder";
 import type { ViewHandler } from "../ViewHandler/ViewHandler";
 import { parseJoinPath } from "../ViewHandler/parseJoinPath";
 import { prepareSortItems } from "../ViewHandler/prepareSortItems";
@@ -91,7 +91,7 @@ const parseJoinSelect = (joinParams: JoinSelect): ParsedJoin => {
 export async function getNewQuery(
   _this: ViewHandler,
   filter: Filter,
-  selectParams: SelectParams & { joinExpressionAlias?: string } = {},
+  selectParams: SelectParams & { joinExpressionAlias?: PGIdentifier } = {},
   param3_unused = null,
   tableRules: ParsedTableRule | undefined,
   localParams: LocalParams | undefined,
@@ -133,7 +133,7 @@ export async function getNewQuery(
       throwErr(parsedJoin.error);
       return;
     }
-    const joinExpressionAlias = joinColumnName;
+    const joinExpressionAlias = { raw: joinColumnName, escaped: asName(joinColumnName) };
     const j_path = parseJoinPath({
       rawPath: parsedJoin.type === "simple" ? joinColumnName : parsedJoin.params.path,
       rootTable: _this.name,
@@ -247,7 +247,7 @@ export async function getNewQuery(
   const resQuery: NewQuery = {
     allFields: _this.column_names.slice(0),
     select,
-    table: _this.name,
+    table: { raw: _this.name, escaped: _this.name },
     joins: joinQueries,
     where,
     whereOpts: filterOpts,

package/lib/DboBuilder/QueryBuilder/getSelectQuery.ts

@@ -18,7 +18,7 @@ export function getSelectQuery(
   viewHandler: ViewHandler,
   q: NewQuery,
   depth = 0,
-  selectParamsGroupBy: boolean
+  selectParamsGroupBy: boolean,
 ): string {
   const rootSelect = q.select
     .filter((s) => s.selected)
@@ -27,7 +27,7 @@ export function getSelectQuery(
   const parsedJoins =
     q.joins?.flatMap((q2) => {
       const parsed = getJoinQuery(viewHandler, {
-        q1: { ...q, tableAlias: ROOT_TABLE_ALIAS },
+        q1: { ...q, tableAlias: { raw: ROOT_TABLE_ALIAS, escaped: ROOT_TABLE_ALIAS } },
         q2: { ...q2 },
         selectParamsGroupBy,
       });
@@ -40,8 +40,8 @@ export function getSelectQuery(
   const selectItems = rootSelect.concat(
     parsedJoins.map((join) => {
       const { joinAlias } = join;
-      return `COALESCE(${asName(joinAlias)}.${join.resultAlias}, '[]') as ${asName(joinAlias)}`;
-    })
+      return `COALESCE(${joinAlias.escaped}.${join.resultAlias.escaped}, '[]') as ${joinAlias.escaped}`;
+    }),
   );
 
   /** OR joins cannot be easily aggregated to one-many with the root table. Must group by root table id */
@@ -62,9 +62,9 @@ export function getSelectQuery(
   if (hasOrJoins) {
     const pkey = viewHandler.columns.find((c) => c.is_pkey);
     joinCtes = [
-      `${q.table} AS (`,
+      `${q.table.escaped} AS (`,
       `  SELECT *, ${pkey ? asName(pkey.name) : "ROW_NUMBER() OVER()"} as ${ROOT_TABLE_ROW_NUM_ID}`,
-      `  FROM ${q.table}`,
+      `  FROM ${q.table.escaped}`,
       `)`,
       joinCtes.length ? "," : "",
       ...joinCtes,
@@ -81,7 +81,7 @@ export function getSelectQuery(
     ...indentLines(selectItems, { appendCommas: true }),
     `FROM ( `,
     `  SELECT *`,
-    `  FROM ${q.table}`,
+    `  FROM ${q.table.escaped}`,
     ...(q.where ? [`  ${q.where}`] : []),
     `) ${ROOT_TABLE_ALIAS}`,
     ...parsedJoins.flatMap((j) => j.joinLines),
@@ -104,7 +104,7 @@ type IndentLinesOpts = {
 };
 export const indentLines = (
   strArr: (string | undefined | null)[],
-  { numberOfSpaces = 2, indentStr = " ", appendCommas = false }: IndentLinesOpts = {}
+  { numberOfSpaces = 2, indentStr = " ", appendCommas = false }: IndentLinesOpts = {},
 ): string[] => {
   const nonEmptyLines = strArr.filter((v) => v);
 
@@ -120,11 +120,10 @@ const indentLinesToString = (
   strArr: (string | undefined | null)[],
   numberOfSpaces = 0,
   separator = " \n ",
-  indentStr = " "
+  indentStr = " ",
 ) => indentLines(strArr, { numberOfSpaces, indentStr }).join(separator);
-const getTableAlias = (q: NewQuery) =>
-  !q.tableAlias ? q.table : `${q.tableAlias || ""}_${q.table}`;
-export const getTableAliasAsName = (q: NewQuery) => asName(getTableAlias(q));
+export const getTableAliasAsName = (q: NewQuery) =>
+  !q.tableAlias ? q.table.escaped : asName(`${q.tableAlias.raw || ""}_${q.table.raw}`);
 
 export const getRootGroupBy = (q: NewQuery, selectParamsGroupBy?: boolean) => {
   const aggs = q.select.filter((s) => s.selected && s.type === "aggregation");
@@ -133,11 +132,6 @@ export const getRootGroupBy = (q: NewQuery, selectParamsGroupBy?: boolean) => {
   if ((selectParamsGroupBy || aggs.length) && nonAggs.length) {
     /** Add ORDER BY items not included in root select */
     const orderByItems: string[] = [];
-    // q.orderByItems.forEach(sortItem => {
-    //   if (!sortItem.nested && "fieldQuery" in sortItem && !orderByItems.includes(sortItem.fieldQuery)) {
-    //     orderByItems.push(sortItem.fieldQuery);
-    //   }
-    // });
 
     return [
       `GROUP BY ${q.select

package/lib/DboBuilder/TableRules/getValidatedRules.ts

@@ -9,7 +9,7 @@ import { asNameAlias } from "../../utils/asNameAlias";
 export function getValidatedRules(
   this: ViewHandler,
   tableRules?: ParsedTableRule,
-  localParams?: LocalParams
+  localParams?: LocalParams,
 ): ValidatedTableRules {
   if (localParams?.clientReq?.socket && !tableRules) {
     throw "INTERNAL ERROR: Unexpected case -> localParams && !tableRules";
@@ -23,15 +23,15 @@ export function getValidatedRules(
         ({
           type: "column",
           name: fieldName,
-          getQuery: ({ tableAlias }) => asNameAlias(fieldName, tableAlias),
+          getQuery: ({ tableAliasRaw: tableAlias }) => asNameAlias(fieldName, tableAlias),
           selected: false,
-        }) as FieldSpec
+        }) as FieldSpec,
     )
     .concat(
       COMPUTED_FIELDS.map((c) => ({
         type: c.type,
         name: c.name,
-        getQuery: ({ tableAlias, allowedFields }) =>
+        getQuery: ({ tableAliasRaw: tableAlias, allowedFields }) =>
           c.getQuery({
             allowedFields,
             ctidField: undefined,
@@ -39,10 +39,10 @@ export function getValidatedRules(
 
             /* CTID not available in AFTER trigger */
             // ctidField: this.is_view? undefined : "ctid",
-            tableAlias,
+            tableAliasRaw: tableAlias,
           }),
         selected: false,
-      }))
+      })),
     );
 
   if (tableRules) {
@@ -50,7 +50,7 @@ export function getValidatedRules(
       throw "INTERNAL ERROR: Unexpected case -> Empty table rules for " + this.name;
     const throwFieldsErr = (
         command: "select" | "update" | "delete" | "insert",
-        fieldType = "fields"
+        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 }`;
       },
@@ -106,7 +106,7 @@ export function getValidatedRules(
         returningFields: parseFirstSpecifiedFieldFilter(
           tableRules.update.returningFields,
           tableRules.select?.fields,
-          tableRules.update.fields
+          tableRules.update.fields,
         ),
         filterFields: this.parseFieldFilter(tableRules.update.filterFields),
       };
@@ -121,7 +121,7 @@ export function getValidatedRules(
         returningFields: parseFirstSpecifiedFieldFilter(
           tableRules.insert.returningFields,
           tableRules.select?.fields,
-          tableRules.insert.fields
+          tableRules.insert.fields,
         ),
       };
     }
@@ -142,36 +142,35 @@ export function getValidatedRules(
     }
 
     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,
-      },
-    };
   }
+  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,
+    },
+  };
 }

package/lib/DboBuilder/ViewHandler/parseComplexFilter.ts

@@ -16,7 +16,7 @@ const allowedComparators = FILTER_OPERANDS; //[">", "<", "=", "<=", ">=", "<>",
 type Args = {
   filter: AnyObject;
   complexFilterKey: string;
-  tableAlias: string | undefined;
+  tableAliasRaw: string | undefined;
   allowed_colnames: string[];
   columns: TableSchemaColumn[];
 };
@@ -33,7 +33,7 @@ type Args = {
 export const parseComplexFilter = ({
   filter,
   complexFilterKey,
-  tableAlias,
+  tableAliasRaw,
   allowed_colnames,
   columns,
 }: Args) => {
@@ -50,7 +50,7 @@ export const parseComplexFilter = ({
       if (!allowed_colnames.includes(column)) {
         throw `Dissallowed or Invalid column ${column}. Allowed columns: ${allowed_colnames}`;
       }
-      return asNameAlias(column, tableAlias);
+      return asNameAlias(column, tableAliasRaw);
     }
     const { funcName, args } = parseFunctionObject(funcData);
     const funcDef = parseFunction({
@@ -61,7 +61,7 @@ export const parseComplexFilter = ({
     });
     return funcDef.getQuery({
       args,
-      tableAlias,
+      tableAliasRaw,
       allColumns: columns,
       allowedFields: allowed_colnames,
     });

package/lib/DboBuilder/ViewHandler/prepareSortItems.ts

@@ -6,7 +6,7 @@ import {
   isEmpty,
   isObject,
 } from "prostgles-types/dist";
-import type { SortItem } from "../DboBuilder";
+import type { PGIdentifier, SortItem } from "../DboBuilder";
 import type { NewQueryJoin, SelectItemValidated } from "../QueryBuilder/QueryBuilder";
 import { asNameAlias } from "../../utils/asNameAlias";
 
@@ -14,9 +14,9 @@ import { asNameAlias } from "../../utils/asNameAlias";
 export const prepareSortItems = (
   rawOrderBy: OrderBy | undefined,
   allowed_cols: string[],
-  tableAlias: string | undefined,
+  tableAlias: PGIdentifier | undefined,
   select: SelectItemValidated[],
-  joinQueries: NewQueryJoin[]
+  joinQueries: NewQueryJoin[],
 ): SortItem[] => {
   if (!rawOrderBy) return [];
 
@@ -48,7 +48,7 @@ export const prepareSortItems = (
     .filter(
       (s) =>
         s.type !== "joinedColumn" &&
-        (!s.fields.length || s.fields.every((f) => allowed_cols.includes(f)))
+        (!s.fields.length || s.fields.every((f) => allowed_cols.includes(f))),
     )
     .map((s) => s.alias);
 
@@ -59,15 +59,15 @@ export const prepareSortItems = (
         ...jq,
         selectItem,
         joinAlias,
-        key: `${joinAlias}.${selectItem.alias}`,
+        key: `${joinAlias.raw}.${selectItem.alias}`,
       };
-    })
+    }),
   );
   const bad_param = orderBy.find(
     ({ key }) =>
       !sortableNestedColumns.some((v) => v.key === key) &&
       !validatedAggAliases.includes(key) &&
-      !allowed_cols.includes(key)
+      !allowed_cols.includes(key),
   );
   if (bad_param) {
     throw "Invalid/disallowed orderBy fields or params: " + bad_param.key;
@@ -95,9 +95,9 @@ export const prepareSortItems = (
           joinAlias,
           selectItemAlias: selectItem.alias,
           isNumeric: selectItem.tsDataType === "number",
-          wrapperQuerySortItem: `${asc ? "MIN" : "MAX"}(${asNameAlias(selectItem.alias, joinAlias)}${comparableDataTypeCast}) as ${sortItemAlias}`,
+          wrapperQuerySortItem: `${asc ? "MIN" : "MAX"}(${asNameAlias(selectItem.alias, joinAlias.raw)}${comparableDataTypeCast}) as ${sortItemAlias}`,
         },
-        fieldQuery: `${asName(joinAlias)}.${sortItemAlias + (asc ? "" : " DESC")} ${nulls ? `NULLS ${nulls === "last" ? "LAST" : "FIRST"}` : ""}`,
+        fieldQuery: `${joinAlias.escaped}.${sortItemAlias + (asc ? "" : " DESC")} ${nulls ? `NULLS ${nulls === "last" ? "LAST" : "FIRST"}` : ""}`,
       };
     }
     /* Order by column index when possible to bypass name collision when ordering by a computed column. 
@@ -106,7 +106,9 @@ export const prepareSortItems = (
 
     const index = selectedAliases.indexOf(key) + 1;
     let colKey =
-      index > 0 && !nullEmpty ? index : [tableAlias, key].filter(isDefined).map(asName).join(".");
+      index > 0 && !nullEmpty ?
+        index
+      : [tableAlias?.raw, key].filter(isDefined).map(asName).join(".");
     if (nullEmpty) {
       colKey = `nullif(trim(${colKey}::text), '')`;
     }
@@ -150,7 +152,7 @@ const throwErr = (rawOrderBy: any) => {
 
 const parseOrderObj = (
   orderBy: any,
-  expectOne = false
+  expectOne = false,
 ): {
   key: string;
   asc: boolean;
@@ -171,7 +173,7 @@ const parseOrderObj = (
         nullEmpty: { enum: [false, true, null], optional: true },
       } as const,
       orderBy,
-      "orderBy"
+      "orderBy",
     );
     if (data) {
       const { key, asc = true, nulls, nullEmpty = false } = data;

package/lib/DboBuilder/ViewHandler/prepareWhere.ts

@@ -1,7 +1,7 @@
-import type { AnyObject, FieldFilter} from "prostgles-types/dist";
+import type { AnyObject, FieldFilter } from "prostgles-types/dist";
 import { getKeys, isDefined, isObject } from "prostgles-types/dist";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { ExistsFilterConfig, Filter, LocalParams } from "../DboBuilder";
+import type { ExistsFilterConfig, Filter, LocalParams, PGIdentifier } from "../DboBuilder";
 import { getCondition } from "../getCondition";
 import { type SelectItemValidated } from "../QueryBuilder/QueryBuilder";
 import type { ViewHandler } from "./ViewHandler";
@@ -12,7 +12,7 @@ export type PrepareWhereParams = {
   forcedFilter?: AnyObject;
   filterFields?: FieldFilter;
   addWhere?: boolean;
-  tableAlias?: string;
+  tableAlias?: PGIdentifier;
   localParams: LocalParams | undefined;
   tableRule: ParsedTableRule | undefined;
   isHaving?: boolean;
@@ -20,7 +20,7 @@ export type PrepareWhereParams = {
 
 export async function prepareWhere(
   this: ViewHandler,
-  params: PrepareWhereParams
+  params: PrepareWhereParams,
 ): Promise<{
   condition: string;
   where: string;
@@ -48,7 +48,7 @@ export async function prepareWhere(
   const parseFullFilter = async (
     f: any,
     parentFilter: any = null,
-    isForcedFilterBypass: boolean
+    isForcedFilterBypass: boolean,
   ): Promise<string> => {
     if (!f) throw "Invalid/missing group filter provided";
     if (!isObject(f)) throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(f);
@@ -71,7 +71,7 @@ export async function prepareWhere(
       const operand = $and ? " AND " : " OR ";
       const conditions = (
         await Promise.all(
-          group.map(async (gf) => await parseFullFilter(gf, group, isForcedFilterBypass))
+          group.map(async (gf) => await parseFullFilter(gf, group, isForcedFilterBypass)),
         )
       ).filter((c) => c);
 

package/lib/DboBuilder/getCondition.ts

@@ -1,7 +1,7 @@
 import { asName, pickKeys } from "prostgles-types";
 import { parseFilterItem } from "../Filtering";
 import type { ParsedTableRule } from "../PublishParser/PublishParser";
-import type { ExistsFilterConfig, LocalParams } from "./DboBuilder";
+import type { ExistsFilterConfig, LocalParams, PGIdentifier } from "./DboBuilder";
 import { pgp } from "./DboBuilder";
 import { FUNCTIONS } from "./QueryBuilder/Functions/Functions";
 import { type SelectItemValidated } from "./QueryBuilder/QueryBuilder";
@@ -24,7 +24,7 @@ export async function getCondition(
     filter: any;
     select: SelectItemValidated[] | undefined;
     allowed_colnames: string[];
-    tableAlias?: string;
+    tableAlias?: PGIdentifier;
     localParams?: LocalParams;
     tableRules?: ParsedTableRule;
     isHaving?: boolean;
@@ -63,7 +63,7 @@ export async function getCondition(
         args: funcArgs,
         allColumns: this.columns,
         allowedFields: allowed_colnames,
-        tableAlias,
+        tableAliasRaw: tableAlias?.raw,
       }),
     );
   });
@@ -74,11 +74,7 @@ export async function getCondition(
       await Promise.all(
         existsConfigs.map(
           async (existsConfig) =>
-            await getExistsCondition.bind(this)(
-              existsConfig,
-              tableAlias && asName(tableAlias),
-              localParams,
-            ),
+            await getExistsCondition.bind(this)(existsConfig, tableAlias?.escaped, localParams),
         ),
       )
     ).join(" AND ");
@@ -94,7 +90,7 @@ export async function getCondition(
       if (!p.select) throw new Error("Computed column filter requires p.select.fields");
       computedColConditions.push(
         compCol.getQuery({
-          tableAlias,
+          tableAliasRaw: tableAlias?.raw,
           allowedFields: p.select.fields,
           allColumns: this.columns,
 
@@ -147,7 +143,7 @@ export async function getCondition(
           fields: [f.name],
           getQuery: (tableAlias) =>
             f.getQuery({
-              tableAlias,
+              tableAliasRaw: tableAlias,
               allColumns: this.columns,
               allowedFields: allowed_colnames,
             }),
@@ -163,7 +159,7 @@ export async function getCondition(
     const complexFilterCondition = parseComplexFilter({
       filter,
       complexFilterKey,
-      tableAlias,
+      tableAliasRaw: tableAlias?.raw,
       allowed_colnames,
       columns: this.columns,
     });
@@ -223,7 +219,7 @@ export async function getCondition(
   const f = pickKeys(filter, filterKeys);
   const q = parseFilterItem({
     filter: f,
-    tableAlias,
+    tableAliasRaw: tableAlias?.raw,
     select: allowedSelect,
     allowedColumnNames:
       !tableRules ?

package/lib/DboBuilder/getSubscribeRelatedTables.ts

@@ -76,7 +76,7 @@ export async function getSubscribeRelatedTables(
      * Avoid nested exists error. Will affect performance
      */
     for (const j of newQuery.joins ?? []) {
-      await pushRelatedTable(j.table, j.joinPath);
+      await pushRelatedTable(j.table.raw, j.joinPath);
     }
     for (const e of newQuery.whereOpts.exists.filter((e) => e.isJoined)) {
       for (const [index, pathItem] of e.parsedPath.entries()) {