prostgles-server 4.2.626 → 4.2.628

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) {

package/lib/PubSubManager/addSub.ts

@@ -45,7 +45,7 @@ export async function addSub(
     throw "addSub: cannot have socket AND func";
   }
 
-  const channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.${JSON.stringify(selectParams)}.m.sub`;
+  const channel_name = `${this.socketChannelPrefix}.${table_name}.${JSON.stringify(filter)}.${JSON.stringify(selectParams)}.m.sub`;
   const mainTrigger = {
     table_name: table_name,
     condition: parseCondition(condition),

package/lib/StorageClient/fileVersionUtils.ts

@@ -1,4 +1,4 @@
-import type { TableHandler } from "prostgles-types";
+import type { TableHandler, TableHandlerForColumns } from "prostgles-types";
 import type { TableHandlers } from "../DboBuilder/DboBuilder";
 import type { FileTableConfig } from "../ProstglesTypes";
 import type {
@@ -24,14 +24,14 @@ export const isFileVersionTable = (
   Boolean(config?.versioning && getFileVersionTableName(config) === tableName);
 
 export const getFileTableHandler = (dbo: TableHandlers, config: FileTableConfig) => {
-  const handler = dbo[config.tableName] as TableHandler<FileTableRow> | undefined;
+  const handler = dbo[config.tableName] as TableHandlerForColumns<FileTableRow> | undefined;
   if (!handler) throw new Error(`File table not found: ${config.tableName}`);
   return handler;
 };
 
 export const getFileRevisionsTableHandler = (dbo: TableHandlers, config: FileTableConfig) => {
   const handler = dbo[getFileVersionTableName(config)] as
-    TableHandler<FileVersionTableRow, FileVersionTableSchema, "fileVersions"> | undefined;
+    TableHandler<FileVersionTableSchema, "fileVersions"> | undefined;
   if (!handler) throw new Error(`File table not found: ${config.tableName}`);
   return handler;
 };

package/lib/TableConfig/initTableConfig.ts

@@ -183,8 +183,6 @@ export const initTableConfig = async function (this: TableConfigurator) {
     });
     if (tableColumnDefinition?.isCreate) {
       queries.push(...(constraintDefs?.map((c) => c.alterQuery) ?? []));
-      await runQueries(queries);
-      await this.prostgles.rebuildDBO();
     } else if (tableColumnDefinition) {
       const fullSchema = await getFutureTableSchema({
         db: this.db,
@@ -219,10 +217,7 @@ export const initTableConfig = async function (this: TableConfigurator) {
       constraintDefs?.forEach((c) => {
         if (!c.name) return;
         const fc = futureCons.find((nc) => nc.name === c.name);
-        if (
-          fc &&
-          !currCons.some((cc) => cc.name === c.name && cc.definition === fc.definition)
-        ) {
+        if (fc && !currCons.some((cc) => cc.name === c.name && cc.definition === fc.definition)) {
           queries.push(`${ALTER_TABLE_Q} ADD CONSTRAINT ${asName(c.name)} ${c.content};`);
         }
       });

package/lib/index.ts

@@ -45,7 +45,11 @@ export type {
   InitResult,
   OnReadyParams,
 } from "./initProstgles";
-export type { ProstglesInitOptions } from "./ProstglesTypes";
+export type {
+  FileTableConfig,
+  ProstglesInitOptions,
+  TableConfigMigrations,
+} from "./ProstglesTypes";
 export type * from "./TableConfig/TableConfigTypes";
 export type * from "./Audit/AuditTypes";
 export type * from "./TableHooks/TableHooks";

package/lib/typeTests/DBOFullyTyped.spec.ts

@@ -56,7 +56,7 @@ void describe("DBOFullyTyped test", async () => {
       //@ts-expect-error
       r[0]?.bad_col;
 
-      const tr2 = {} as TableHandler<DBSchema2["tr2"]["columns"], DBSchema2>;
+      const tr2 = {} as TableHandler<DBSchema2, "tr2">;
       void tr2.find(
         {},
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.626",
+  "version": "4.2.628",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -57,7 +57,7 @@
     "pg": "^8.23.0",
     "pg-cursor": "^2.22.0",
     "pg-promise": "^12.7.1",
-    "prostgles-types": "^4.0.285"
+    "prostgles-types": "^4.0.290"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",