prostgles-server 4.2.626 → 4.2.628

package/lib/DboBuilder/QueryBuilder/Functions/Functions.ts

@@ -4,7 +4,7 @@ import { asName, includes, isObject, TextFilter_FullTextSearchFilterKeys } from
 import { asNameAlias } from "../../../utils/asNameAlias";
 import { HASHING_FUNCTIONS } from "./HASHING_FUNCTIONS";
 import { TEXT_FUNCTIONS } from "./TEXT_FUNCTIONS";
-import { asFunction } from "./utils";
+import { asFunction, getAggregateQuery } from "./utils";
 const pgp = pgPromise();
 
 type GetQueryArgs = {
@@ -13,13 +13,15 @@ type GetQueryArgs = {
   args: any[];
   tableAliasRaw?: string;
   ctidField?: string;
+  aggregateFilter?: string;
+  aggregateOrderBy?: string;
 };
 
 export type FieldSpec = {
   name: string;
   type: "column" | "computed";
   /**
-   * allowedFields passed for multicol functions (e.g.: $rowhash)
+   * allowedFields passed for multicolumn functions (e.g.: $rowhash)
    */
   getQuery: (params: Omit<GetQueryArgs, "args">) => string;
 };
@@ -454,12 +456,18 @@ PostGIS_Funcs = PostGIS_Funcs.concat(
       singleColArg: true,
       numArgs: 1,
       getFields: (args: any[]) => [args[0]],
-      getQuery: ({ args, tableAliasRaw: tableAlias }) => {
-        const escTabelName = asNameAlias(args[0], tableAlias) + "::geometry";
+      getQuery: ({ args, tableAliasRaw: tableAlias, aggregateFilter, aggregateOrderBy }) => {
+        const escapeTableName = asNameAlias(args[0], tableAlias) + "::geometry";
         if (fname.includes("Extent")) {
-          return `${fname}(${escTabelName})`;
+          return getAggregateQuery(fname, escapeTableName, aggregateFilter, aggregateOrderBy);
         }
-        return `${fname.endsWith("_Agg") ? fname.slice(0, -4) : fname}(ST_Collect(${escTabelName}))`;
+        const collectedGeometry = getAggregateQuery(
+          "ST_Collect",
+          escapeTableName,
+          aggregateFilter,
+          aggregateOrderBy,
+        );
+        return `${fname.endsWith("_Agg") ? fname.slice(0, -4) : fname}(${collectedGeometry})`;
       },
     };
     return res;
@@ -753,13 +761,23 @@ export const FUNCTIONS: FunctionSpec[] = [
         type: "aggregation",
         numArgs: 1,
         singleColArg: true,
-        getFields: (args: any[]) => [args[0]],
-        getQuery: ({ args, tableAliasRaw: tableAlias }) => {
+        minCols: aggName === "count" ? 0 : undefined,
+        getFields: (args: any[]) => (aggName === "count" && !args.length ? [] : [args[0]]),
+        getQuery: ({ args, tableAliasRaw: tableAlias, aggregateFilter, aggregateOrderBy }) => {
           let extraArgs = "";
           if (args.length > 1) {
             extraArgs = pgp.as.format(", $1:csv", args.slice(1));
           }
-          return aggName + "(" + asNameAlias(args[0], tableAlias) + `${extraArgs})`;
+          const firstArg =
+            args.length ? asNameAlias(args[0], tableAlias)
+            : aggregateOrderBy ? "1"
+            : "*";
+          return getAggregateQuery(
+            aggName,
+            `${firstArg}${extraArgs}`,
+            aggregateFilter,
+            aggregateOrderBy,
+          );
         },
       }),
   ),
@@ -784,8 +802,13 @@ export const FUNCTIONS: FunctionSpec[] = [
     singleColArg: true,
     numArgs: 0,
     getFields: (args: any[]) => [],
-    getQuery: ({ allowedFields, args, tableAliasRaw: tableAlias }) => {
-      return "COUNT(*)";
+    getQuery: ({ aggregateFilter, aggregateOrderBy }) => {
+      return getAggregateQuery(
+        "COUNT",
+        aggregateOrderBy ? "1" : "*",
+        aggregateFilter,
+        aggregateOrderBy,
+      );
     },
   }),
   asFunction({
@@ -794,9 +817,11 @@ export const FUNCTIONS: FunctionSpec[] = [
     numArgs: 1,
     singleColArg: true,
     getFields: (args: any[]) => [args[0]],
-    getQuery: ({ allowedFields, args, tableAliasRaw: tableAlias }) => {
+    getQuery: ({ args, tableAliasRaw: tableAlias, aggregateFilter, aggregateOrderBy }) => {
       const col = asNameAlias(args[0], tableAlias);
-      return `round( ( ( MAX(${col}) - MIN(${col}) )::float/MIN(${col}) ) * 100, 2)`;
+      const max = getAggregateQuery("MAX", col, aggregateFilter, aggregateOrderBy);
+      const min = getAggregateQuery("MIN", col, aggregateFilter, aggregateOrderBy);
+      return `round( ( ( ${max} - ${min} )::float/${min} ) * 100, 2)`;
     },
   }),
 ];

package/lib/DboBuilder/QueryBuilder/Functions/HASHING_FUNCTIONS.ts

@@ -1,6 +1,7 @@
 import pgPromise from "pg-promise";
 import { asNameAlias } from "../../../utils/asNameAlias";
 import type { FunctionSpec } from "./Functions";
+import { getAggregateQuery } from "./utils";
 
 const pgp = pgPromise();
 
@@ -33,15 +34,16 @@ export const HASHING_FUNCTIONS: FunctionSpec[] = [
     singleColArg: false,
     numArgs: MAX_COL_NUM,
     getFields: (args: any[]) => args,
-    getQuery: ({ args, tableAliasRaw: tableAlias }) => {
-      const q = pgp.as.format(
-        "md5(string_agg(" +
-          args
-            .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + "::text, '' )")
-            .join(" || ") +
-          ", ','))",
+    getQuery: ({ args, tableAliasRaw: tableAlias, aggregateFilter, aggregateOrderBy }) => {
+      const stringAgg = getAggregateQuery(
+        "string_agg",
+        args
+          .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + "::text, '' )")
+          .join(" || ") + ", ','",
+        aggregateFilter,
+        aggregateOrderBy,
       );
-      return q;
+      return pgp.as.format(`md5(${stringAgg})`);
     },
   },
 
@@ -70,15 +72,16 @@ export const HASHING_FUNCTIONS: FunctionSpec[] = [
     singleColArg: false,
     numArgs: MAX_COL_NUM,
     getFields: (args: any[]) => args,
-    getQuery: ({ args, tableAliasRaw: tableAlias }) => {
-      const q = pgp.as.format(
-        "encode(sha256(string_agg(" +
-          args
-            .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + ", '' )")
-            .join(" || ") +
-          ", ',')::text::bytea), 'hex')",
+    getQuery: ({ args, tableAliasRaw: tableAlias, aggregateFilter, aggregateOrderBy }) => {
+      const stringAgg = getAggregateQuery(
+        "string_agg",
+        args
+          .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + ", '' )")
+          .join(" || ") + ", ','",
+        aggregateFilter,
+        aggregateOrderBy,
       );
-      return q;
+      return pgp.as.format(`encode(sha256(${stringAgg}::text::bytea), 'hex')`);
     },
   },
   {
@@ -106,15 +109,16 @@ export const HASHING_FUNCTIONS: FunctionSpec[] = [
     singleColArg: false,
     numArgs: MAX_COL_NUM,
     getFields: (args: any[]) => args,
-    getQuery: ({ args, tableAliasRaw: tableAlias }) => {
-      const q = pgp.as.format(
-        "encode(sha512(string_agg(" +
-          args
-            .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + ", '' )")
-            .join(" || ") +
-          ", ',')::text::bytea), 'hex')",
+    getQuery: ({ args, tableAliasRaw: tableAlias, aggregateFilter, aggregateOrderBy }) => {
+      const stringAgg = getAggregateQuery(
+        "string_agg",
+        args
+          .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + ", '' )")
+          .join(" || ") + ", ','",
+        aggregateFilter,
+        aggregateOrderBy,
       );
-      return q;
+      return pgp.as.format(`encode(sha512(${stringAgg}::text::bytea), 'hex')`);
     },
   },
 ];

package/lib/DboBuilder/QueryBuilder/Functions/utils.ts

@@ -1,3 +1,13 @@
 import type { FunctionSpec } from "./Functions";
 
 export const asFunction = (def: FunctionSpec) => def;
+
+export const getAggregateQuery = (
+  name: string,
+  args: string,
+  aggregateFilter?: string,
+  aggregateOrderBy?: string,
+) =>
+  `${name}(${args}${aggregateOrderBy ? ` ${aggregateOrderBy}` : ""})${
+    aggregateFilter ? ` FILTER (WHERE ${aggregateFilter})` : ""
+  }`;

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