prostgles-server 4.2.626 → 4.2.627

package/lib/DboBuilder/QueryBuilder/QueryBuilder.ts

@@ -4,13 +4,15 @@
  *--------------------------------------------------------------------------------------------*/
 
 import type {
+  AnyObject,
   ColumnInfo,
+  OrderBy,
   PG_COLUMN_UDT_DATA_TYPE,
   Select,
   ValidatedColumnInfo,
 } from "prostgles-types";
-import { getKeys, isEmpty, isObject, postgresToTsType } from "prostgles-types";
-import type { PGIdentifier, SortItem } from "../DboBuilder";
+import { getKeys, includes, isEmpty, isObject, postgresToTsType } from "prostgles-types";
+import type { ExistsFilterConfig, PGIdentifier, SortItem } from "../DboBuilder";
 
 import type { Awaitable } from "../../PublishParser/publishTypesAndUtils";
 import { asNameAlias } from "../../utils/asNameAlias";
@@ -30,6 +32,8 @@ export type SelectItem = {
   tsDataType?: ValidatedColumnInfo["tsDataType"];
   alias: string;
   selected: boolean;
+  dependencyFields?: string[];
+  dependencyExists?: ExistsFilterConfig[];
 } & (
   | {
       type: "column";
@@ -87,6 +91,36 @@ export const parseFunctionObject = (funcData: unknown): { funcName: string; args
   return { funcName, args };
 };
 
+type AggregateOptions = {
+  $filter?: AnyObject;
+  $orderBy?: OrderBy;
+};
+
+type ParsedAggregateOptions = {
+  filter?: string;
+  orderBy?: string;
+  dependencyFields: string[];
+  dependencyExists: ExistsFilterConfig[];
+};
+
+const aggregateOptionKeys = ["$filter", "$orderBy"] as const;
+const parseSelectFunctionObject = (funcData: Record<string, unknown>) => {
+  const functionData = Object.fromEntries(
+    Object.entries(funcData).filter(([key]) => !includes(aggregateOptionKeys, key)),
+  );
+  return {
+    ...parseFunctionObject(functionData),
+    aggregateOptions: {
+      ...(funcData.$filter !== undefined && {
+        $filter: funcData.$filter as AnyObject,
+      }),
+      ...(funcData.$orderBy !== undefined && {
+        $orderBy: funcData.$orderBy as OrderBy,
+      }),
+    } satisfies AggregateOptions,
+  };
+};
+
 export class SelectItemBuilder {
   select: SelectItemValidated[] = [];
   private allFields: string[];
@@ -97,6 +131,7 @@ export class SelectItemBuilder {
   private functions: FunctionSpec[];
   private allowedFieldsIncludingComputed: string[];
   private columns: ColumnInfo[];
+  private parseAggregateOptions?: (options: AggregateOptions) => Promise<ParsedAggregateOptions>;
 
   constructor(params: {
     allowedFields: string[];
@@ -106,6 +141,7 @@ export class SelectItemBuilder {
     allFields: string[];
     isView: boolean;
     columns: ColumnInfo[];
+    parseAggregateOptions?: (options: AggregateOptions) => Promise<ParsedAggregateOptions>;
   }) {
     this.allFields = params.allFields;
     this.allowedFields = params.allowedFields;
@@ -113,6 +149,7 @@ export class SelectItemBuilder {
     this.computedFields = params.computedFields;
     this.functions = params.functions;
     this.columns = params.columns;
+    this.parseAggregateOptions = params.parseAggregateOptions;
     this.allowedFieldsIncludingComputed = this.allowedFields.concat(
       this.computedFields.map((cf) => cf.name),
     );
@@ -164,7 +201,12 @@ export class SelectItemBuilder {
     this.select.push({ ...item, fields });
   };
 
-  private addFunction = (func: FunctionSpec | string, args: any[], alias: string) => {
+  private addFunction = (
+    func: FunctionSpec | string,
+    args: any[],
+    alias: string,
+    aggregateOptions: AggregateOptions = {},
+  ): void | Promise<void> => {
     const funcDef = parseFunction({
       func,
       args,
@@ -172,6 +214,27 @@ export class SelectItemBuilder {
       allowedFields: this.allowedFieldsIncludingComputed,
     });
 
+    if (Object.keys(aggregateOptions).length) {
+      if (funcDef.type !== "aggregation") {
+        throw `Aggregate options $filter and $orderBy are only allowed on aggregate functions`;
+      }
+      if (!this.parseAggregateOptions) {
+        throw "Aggregate options are not supported in this query";
+      }
+      return this.parseAggregateOptions(aggregateOptions).then((parsedOptions) => {
+        this.addFunctionItem(funcDef, args, alias, parsedOptions);
+      });
+    }
+
+    this.addFunctionItem(funcDef, args, alias);
+  };
+
+  private addFunctionItem = (
+    funcDef: FunctionSpec,
+    args: any[],
+    alias: string,
+    aggregateOptions?: ParsedAggregateOptions,
+  ) => {
     const fieldFilter = funcDef.getFields(args);
     this.addItem({
       type: funcDef.type,
@@ -184,11 +247,15 @@ export class SelectItemBuilder {
           args,
           tableAliasRaw: tableAlias,
           ctidField: undefined,
+          aggregateFilter: aggregateOptions?.filter,
+          aggregateOrderBy: aggregateOptions?.orderBy,
 
           /* CTID not available in AFTER trigger */
           // ctidField: this.isView? undefined : "ctid"
         }),
       selected: true,
+      dependencyFields: aggregateOptions?.dependencyFields,
+      dependencyExists: aggregateOptions?.dependencyExists,
     });
   };
 
@@ -204,7 +271,7 @@ export class SelectItemBuilder {
           singleColArg: false,
           getFields: (_args: any[]) => [],
         };
-        this.addFunction(cf, [], compCol.name);
+        void this.addFunction(cf, [], compCol.name);
         return;
       }
     }
@@ -271,14 +338,16 @@ export class SelectItemBuilder {
     } else {
       await Promise.all(
         selectKeys.map(async (key) => {
-          const val: unknown = userSelect[key as keyof typeof userSelect];
+          const userSelectValue: unknown = userSelect[key as keyof typeof userSelect];
           const throwErr: (message: string) => never = (message) => {
             console.trace(message);
-            throw "Unexpected select -> " + JSON.stringify({ [key]: val }) + "\n" + message;
+            throw (
+              "Unexpected select -> " + JSON.stringify({ [key]: userSelectValue }) + "\n" + message
+            );
           };
 
           /* Included fields */
-          if ([1, true].includes(val as number | boolean)) {
+          if (userSelectValue === 1 || userSelectValue === true) {
             if (key === "*") {
               this.allowedFields.map((key) => this.addColumn(key, true));
             } else {
@@ -286,18 +355,26 @@ export class SelectItemBuilder {
             }
 
             /* Aggregations and functions */
-          } else if (typeof val === "string" || isObject(val)) {
+          } else if (typeof userSelectValue === "string" || isObject(userSelectValue)) {
+            const functionEntries =
+              isObject(userSelectValue) ?
+                Object.entries(userSelectValue).filter(
+                  ([key]) => !includes(aggregateOptionKeys, key),
+                )
+              : [];
             /* Function shorthand notation
                 { id: "$max" } === { id: { $max: ["id"] } } === SELECT MAX(id) AS id 
               */
             if (
-              (typeof val === "string" && val !== "*") ||
-              (isObject(val) &&
-                Object.keys(val).length === 1 &&
-                Array.isArray(Object.values(val)[0]))
+              (typeof userSelectValue === "string" && userSelectValue !== "*") ||
+              (isObject(userSelectValue) &&
+                functionEntries.length === 1 &&
+                Array.isArray(functionEntries[0]![1]))
             ) {
-              let funcName: string | undefined, args: any[] | undefined;
-              if (typeof val === "string") {
+              let funcName: string | undefined,
+                args: any[] | undefined,
+                aggregateOptions: AggregateOptions = {};
+              if (typeof userSelectValue === "string") {
                 /* Shorthand notation -> it is expected that the key is the column name used as the only argument */
                 try {
                   this.checkField(key, true);
@@ -306,22 +383,22 @@ export class SelectItemBuilder {
                     ` Shorthand function notation error: the specified column ( ${key} ) is invalid or disallowed. \n Use correct column name or full aliased function notation, e.g.: -> { alias: { $func_name: ["column_name"] } } `,
                   );
                 }
-                funcName = val;
+                funcName = userSelectValue;
                 args = [key];
 
                 /** Function full notation { $funcName: ["colName", ...args] } */
               } else {
-                ({ funcName, args } = parseFunctionObject(val));
+                ({ funcName, args, aggregateOptions } = parseSelectFunctionObject(userSelectValue));
               }
 
-              this.addFunction(funcName, args, key);
+              await this.addFunction(funcName, args, key, aggregateOptions);
 
               /* Join */
             } else {
               if (!joinParse) {
                 throw "Joins disallowed";
               }
-              const joinSelect = val;
+              const joinSelect = userSelectValue;
 
               const parsedJoin = parseJoinSelect(joinSelect);
 

package/lib/DboBuilder/QueryBuilder/getNewQuery.ts

@@ -1,7 +1,13 @@
 import type { SelectParams } from "prostgles-types";
-import { asName, isEmpty, omitKeys } from "prostgles-types";
+import { asName, isEmpty, isObject, omitKeys } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { Filter, LocalParams, PGIdentifier, ValidatedTableRules } from "../DboBuilder";
+import {
+  prepareOrderByQuery,
+  type Filter,
+  type LocalParams,
+  type PGIdentifier,
+  type ValidatedTableRules,
+} from "../DboBuilder";
 import type { ViewHandler } from "../ViewHandler/ViewHandler";
 import { parseJoinPath } from "../ViewHandler/parseJoinPath";
 import { prepareSortItems } from "../ViewHandler/prepareSortItems";
@@ -21,22 +27,31 @@ export const getNewQuery = async (
 ): Promise<NewQuery> => {
   const { columns } = viewHandler;
 
-  if (localParams?.isRemoteRequest && !tableRules?.select?.fields) {
+  const selectRule = tableRules?.select;
+  if (tableRules && !selectRule?.fields) {
     throw `INTERNAL ERROR: publish.${viewHandler.name}.select.fields rule missing`;
   }
 
+  /** Only missing tableRules means this is an unrestricted local query */
   const allowedOrderByFields =
-    !tableRules ?
+    !selectRule ?
       viewHandler.column_names.slice(0)
-    : viewHandler.parseFieldFilter(tableRules.select?.orderByFields ?? tableRules.select?.fields);
+    : viewHandler.parseFieldFilter(selectRule.orderByFields);
   const allowedSelectFields =
-    !tableRules ?
+    !selectRule ?
       viewHandler.column_names.slice(0)
-    : viewHandler.parseFieldFilter(tableRules.select?.fields);
+    : viewHandler.parseFieldFilter(selectRule.fields);
+  const allowedFilterFields =
+    !selectRule ?
+      viewHandler.column_names.slice(0)
+    : viewHandler.parseFieldFilter(selectRule.filterFields);
 
   const joinQueries: NewQueryJoin[] = [];
 
   const { select: userSelect = "*" } = selectParams;
+  const aggregateTableAlias =
+    selectParams.joinExpressionAlias ??
+    ({ raw: ROOT_TABLE_ALIAS, escaped: ROOT_TABLE_ALIAS } satisfies PGIdentifier);
 
   const selectItemBuilder = new SelectItemBuilder({
     allowedFields: allowedSelectFields,
@@ -46,6 +61,39 @@ export const getNewQuery = async (
     functions: FUNCTIONS,
     allFields: viewHandler.column_names.slice(0),
     columns,
+    parseAggregateOptions: async ({ $filter, $orderBy }) => {
+      if ($filter !== undefined && !isObject($filter)) {
+        throw `Invalid aggregate $filter. Expecting an object`;
+      }
+      const filterInfo =
+        $filter === undefined ? undefined : (
+          await prepareWhere(viewHandler, {
+            filter: $filter,
+            select: undefined,
+            filterFields: allowedFilterFields,
+            tableAlias: aggregateTableAlias,
+            localParams,
+            addWhere: false,
+            tableRule: tableRules,
+          })
+        );
+      const orderByItems = prepareSortItems(
+        $orderBy,
+        allowedOrderByFields,
+        aggregateTableAlias,
+        [],
+        [],
+      );
+      return {
+        filter: filterInfo?.condition,
+        orderBy: prepareOrderByQuery(orderByItems, aggregateTableAlias.raw)[0],
+        dependencyFields: [
+          ...(filterInfo?.columnsUsed ?? []),
+          ...orderByItems.map(({ key }) => key),
+        ],
+        dependencyExists: filterInfo?.exists ?? [],
+      };
+    },
   });
 
   await selectItemBuilder.parseUserSelectWithJoins(
@@ -151,9 +199,9 @@ export const getNewQuery = async (
         ...omitKeys(commonWhereParams, ["forcedFilter", "selectParams"]),
         filter: selectParams.having,
         tableAlias:
-          selectParams.joinExpressionAlias ? source.alias : (
-            { raw: ROOT_TABLE_ALIAS, escaped: ROOT_TABLE_ALIAS }
-          ),
+          selectParams.joinExpressionAlias ?
+            source.alias
+          : { raw: ROOT_TABLE_ALIAS, escaped: ROOT_TABLE_ALIAS },
         isHaving: true,
       })
     );

package/lib/DboBuilder/QueryBuilder/parseJoinSelect.ts

@@ -5,18 +5,7 @@ import type {
   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>);
+import { getKeys, includes, JOIN_KEYS, JOIN_PARAMS } from "prostgles-types";
 
 export type ParsedJoin =
   | {
@@ -47,7 +36,7 @@ export const parseJoinSelect = (joinParams: JoinSelect): ParsedJoin | string =>
   } 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),
+      (k) => !includes([...JOIN_PARAMS, ...JOIN_KEYS], k),
     );
     if (invalidParams.length) {
       throw "Invalid join params: " + invalidParams.join(", ");

package/lib/DboBuilder/TableHandler/onDeleteFromFileTable.ts

@@ -36,32 +36,33 @@ export const onDeleteFromFileTable = async (
 
   const fileIds =
     config.versioning ?
-      ((await getFileTableHandler(dbx, config).find(filterOpts.filter, {
+      await getFileTableHandler(dbx, config).find(filterOpts.filter, {
         select: { id: 1 },
         limit: null,
-      })) as { id: string }[])
+      })
     : [];
   const versionFiles =
     fileIds.length ?
-      ((await getFileRevisionsTableHandler(dbx, config).find(
+      await getFileRevisionsTableHandler(dbx, config).find(
         { file_id: { $in: fileIds.map(({ id }) => id) } },
         { select: { storage_key: 1 }, limit: null },
-      )) as { storage_key: string }[])
+      )
     : [];
 
-  const files = await t.any<Record<string, unknown> & { _prostgles_storage_key: string }>(
+  const KEY = "_prostgles_storage_key" as const;
+  const files = await t.any<Record<string, unknown> & { [KEY]: string }>(
     `DELETE FROM ${asName(tableName)} ${filterOpts.where}
      ${returningQuery ? `${returningQuery},` : "RETURNING"}
-     COALESCE(storage_key, id) AS _prostgles_storage_key`,
+     COALESCE(storage_key, id) AS ${KEY}`,
   );
   const storageKeys = new Set([
     ...versionFiles.map(({ storage_key }) => storage_key),
-    ...files.map(({ _prostgles_storage_key }) => _prostgles_storage_key),
+    ...files.map((row) => row[KEY]),
   ]);
   for (const storageKey of storageKeys) {
     onCommit(({ db }) => deleteUnreferencedFile(db, config, storageKey));
   }
-  const result = files.map(({ _prostgles_storage_key, ...row }) => row);
+  const result = files.map(({ [KEY]: _, ...row }) => row);
   if (!returningQuery) return undefined;
   return (isOneOrNone ? result[0] : result) as AnyObject[] | undefined;
 };

package/lib/DboBuilder/ViewHandler/find.ts

@@ -11,6 +11,7 @@ import {
 import { getNewQuery } from "../QueryBuilder/getNewQuery";
 import { getSelectQuery } from "../QueryBuilder/getSelectQuery";
 import { getReturnTypeQuery } from "./getReturnTypeQuery";
+import { validateSelectParams } from "./validateSelectParams";
 import type { ViewHandler } from "./ViewHandler";
 
 export type Param3 = {
@@ -30,44 +31,13 @@ export const find = async function (
 
   const command = limit === 1 && returnType === "row" ? "findOne" : "find";
   try {
-    const allowedReturnTypes = Object.keys({
-      row: 1,
-      statement: 1,
-      value: 1,
-      values: 1,
-      "statement-no-rls": 1,
-      "statement-where": 1,
-    } satisfies Record<Required<SelectParams>["returnType"], 1>);
+    validateSelectParams(selectParams);
 
     const { returnType } = selectParams || {};
-    if (returnType && !allowedReturnTypes.includes(returnType)) {
-      throw `returnType (${returnType}) can only be ${allowedReturnTypes.join(" OR ")}`;
-    }
 
     const { testRule = false } = localParams || {};
 
     if (testRule) return [];
-    if (selectParams) {
-      const validParamNames = Object.keys({
-        select: 1,
-        orderBy: 1,
-        offset: 1,
-        limit: 1,
-        returnType: 1,
-        groupBy: 1,
-        having: 1,
-        abortSignal: 1,
-      } satisfies Record<keyof SelectParams, 1>);
-
-      const invalidParams = Object.keys(selectParams).filter((k) => !validParamNames.includes(k));
-      if (invalidParams.length)
-        throw (
-          "Invalid params: " +
-          invalidParams.join(", ") +
-          " \n Expecting: " +
-          validParamNames.join(", ")
-        );
-    }
 
     /* Validate publish */
     if (tableRules) {

package/lib/DboBuilder/ViewHandler/parseComplexFilter.ts

@@ -34,6 +34,8 @@ export const parseComplexFilter = ({
   allowed_colnames,
   columns,
 }: Args) => {
+  const columnsUsed: string[] = [];
+
   /**
    * { $funcName: [arg1, arg2] }
    * { $column: "column_name" }
@@ -45,8 +47,9 @@ export const parseComplexFilter = ({
         throw `expecting: \n  { $column: "column_name" } received:\n ${JSON.stringify(funcData)}`;
       }
       if (!allowed_colnames.includes(column)) {
-        throw `Dissallowed or Invalid column ${column}. Allowed columns: ${allowed_colnames}`;
+        throw `Disallowed or Invalid column ${column}. Allowed columns: ${allowed_colnames}`;
       }
+      columnsUsed.push(column);
       return asNameAlias(column, tableAliasRaw);
     }
     const { funcName, args } = parseFunctionObject(funcData);
@@ -56,6 +59,8 @@ export const parseComplexFilter = ({
       functions: FUNCTIONS,
       allowedFields: allowed_colnames,
     });
+    const fields = funcDef.getFields(args);
+    columnsUsed.push(...(fields === "*" ? allowed_colnames : fields));
     return funcDef.getQuery({
       args,
       tableAliasRaw,
@@ -108,5 +113,8 @@ export const parseComplexFilter = ({
     result += ` ${sqlOperand} ${rightVal}`;
   }
 
-  return result;
+  return {
+    condition: result,
+    columnsUsed: Array.from(new Set(columnsUsed)),
+  };
 };

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -77,9 +77,16 @@ async function subscribe(
       newQuery,
     });
 
-    const [firstField, ...otherFields] = newQuery.select
-      .filter((s) => s.selected)
-      .flatMap((c) => c.fields);
+    const [firstField, ...otherFields] = Array.from(
+      new Set([
+        ...newQuery.select
+          .filter((s) => s.selected)
+          .flatMap((item) => [...item.fields, ...(item.dependencyFields ?? [])]),
+        ...newQuery.orderByItems
+          .map(({ key }) => key)
+          .filter((key) => this.column_names.includes(key)),
+      ]),
+    );
 
     const commonSubOpts = {
       table_info: this.tableOrViewInfo,

package/lib/DboBuilder/ViewHandler/validateSelectParams.ts

@@ -0,0 +1,51 @@
+import { getJSONBObjectSchemaValidationError, getKeys, type SelectParams } from "prostgles-types";
+
+export const validateSelectParams = (
+  selectParams: any,
+): selectParams is SelectParams | undefined => {
+  if (selectParams === undefined) {
+    return true;
+  }
+  const allowedReturnTypes = getKeys({
+    row: 1,
+    statement: 1,
+    value: 1,
+    values: 1,
+    "statement-no-rls": 1,
+    "statement-where": 1,
+  } satisfies Record<Required<SelectParams>["returnType"], 1>);
+
+  const selectParamsValidation = getJSONBObjectSchemaValidationError(
+    {
+      select: {
+        oneOf: [{ enum: ["*", ""] as const }, { record: { values: "any" } }, "string[]"],
+        optional: true,
+      },
+      orderBy: {
+        oneOf: [
+          { record: { values: "any" } },
+          { arrayOf: { record: { values: "any" } } },
+          "string[]",
+          "string",
+        ],
+        optional: true,
+      },
+      offset: { type: "integer", optional: true },
+      limit: { type: "integer", nullable: true, optional: true },
+      returnType: {
+        enum: allowedReturnTypes,
+        optional: true,
+      },
+      groupBy: { type: "boolean", optional: true },
+      having: { record: { values: "any" }, optional: true },
+      abortSignal: { type: "any", optional: true },
+    },
+    selectParams,
+    "selectParams",
+  );
+  if (selectParamsValidation.error !== undefined) {
+    throw `selectParams validation error: ${JSON.stringify(selectParamsValidation.error)}`;
+  }
+  selectParamsValidation.data satisfies SelectParams;
+  return true;
+};

package/lib/DboBuilder/getCondition.ts

@@ -44,6 +44,11 @@ export async function getCondition(
   const filter = { ...rawFilter };
 
   const existsConfigs = getExistsFilters(filter, this);
+  const dependencyColumns = existsConfigs.flatMap((existsConfig) =>
+    existsConfig.isJoined ?
+      (existsConfig.parsedPath[0]?.on.flatMap((columnPair) => Object.keys(columnPair)) ?? [])
+    : [],
+  );
 
   const functionConditions: string[] = [];
   const funcFilter = FILTER_FUNCS.filter((f) => f.name in filter);
@@ -59,6 +64,7 @@ export async function getCondition(
     if (disallowedCols.length) {
       throw `Invalid/disallowed columns found in function filter: ${disallowedCols}`;
     }
+    dependencyColumns.push(...fields);
     functionConditions.push(
       f.getQuery({
         args: funcArgs,
@@ -89,6 +95,7 @@ export async function getCondition(
     const compCol = computedFields.find((cf) => cf.name === key);
     if (compCol) {
       if (!p.select) throw new Error("Computed column filter requires p.select.fields");
+      dependencyColumns.push(...p.select.fields);
       computedColConditions.push(
         compCol.getQuery({
           tableAliasRaw: tableAlias?.raw,
@@ -157,14 +164,15 @@ export async function getCondition(
   const complexFilters: string[] = [];
   const complexFilterKey = "$filter";
   if (complexFilterKey in filter) {
-    const complexFilterCondition = parseComplexFilter({
+    const complexFilter = parseComplexFilter({
       filter,
       complexFilterKey,
       tableAliasRaw: tableAlias?.raw,
       allowed_colnames,
       columns: this.columns,
     });
-    complexFilters.push(complexFilterCondition);
+    complexFilters.push(complexFilter.condition);
+    dependencyColumns.push(...complexFilter.columnsUsed);
   }
 
   /* Parse join filters
@@ -238,7 +246,7 @@ export async function getCondition(
 
   /*  sorted to ensure duplicate subscription channels are not created due to different condition order */
   return {
-    columnsUsed: q?.columnsUsed ?? [],
+    columnsUsed: Array.from(new Set([...(q?.columnsUsed ?? []), ...dependencyColumns])),
     exists: existsConfigs,
     condition: templates.sort().join(" AND \n"),
   };

package/lib/DboBuilder/getSubscribeRelatedTables.ts

@@ -1,5 +1,5 @@
 import type { AnyObject, ParsedJoinPath, SubscribeParams } from "prostgles-types";
-import { asName, isDefined, isEmpty, reverseParsedPath } from "prostgles-types";
+import { asName, isEmpty, reverseParsedPath } from "prostgles-types";
 import type { ParsedTableRule } from "../PublishParser/PublishParser";
 import type { ViewSubscriptionOptions } from "../PubSubManager/PubSubManager";
 import type { Filter, LocalParams } from "./DboBuilder";
@@ -36,6 +36,9 @@ export async function getSubscribeRelatedTables(
       relatedTables: [],
     };
 
+    const dependencyExists = newQuery.select
+      .filter((item) => item.selected)
+      .flatMap((item) => item.dependencyExists ?? []);
     const nonExistsFilter = newQuery.whereOpts.exists.length ? {} : filter;
     const pushRelatedTable = async (
       relatedTableName: string,
@@ -112,11 +115,15 @@ export async function getSubscribeRelatedTables(
       await pushRelatedTable(
         j.table.raw,
         j.joinPath,
-        j.select.map((s) => (s.selected ? s.columnName : undefined)).filter(isDefined),
+        j.select
+          .filter((item) => item.selected)
+          .flatMap((item) => [...item.fields, ...(item.dependencyFields ?? [])]),
         {},
       );
     }
-    for (const existsFilter of newQuery.whereOpts.exists.filter((e) => e.isJoined)) {
+    for (const existsFilter of [...newQuery.whereOpts.exists, ...dependencyExists].filter(
+      (existsFilter) => existsFilter.isJoined,
+    )) {
       for (const [index, pathItem] of existsFilter.parsedPath.entries()) {
         const isLast = index === existsFilter.parsedPath.length - 1;
         await pushRelatedTable(

package/lib/PubSubManager/PubSubManager.ts

@@ -200,7 +200,7 @@ export class PubSubManager {
 
   subs: Subscription[] = [];
   syncs: SyncParams[] = [];
-  readonly socketChannelPreffix = CHANNELS._preffix;
+  readonly socketChannelPrefix = CHANNELS._preffix;
   postgresNotifListenManager?: PostgresNotifListenManager;
 
   private constructor(dboBuilder: DboBuilder) {