prostgles-server 4.2.187 → 4.2.189

package/lib/DboBuilder/QueryBuilder/QueryBuilder.ts

@@ -18,12 +18,7 @@ import { isPlainObject, postgresToTsType, SortItem } from "../DboBuilder";
 
 import { ParsedJoinPath } from "../ViewHandler/parseJoinPath";
 import { ViewHandler } from "../ViewHandler/ViewHandler";
-import {
-  COMPUTED_FIELDS,
-  FieldSpec,
-  FunctionSpec,
-  parseFunction,
-} from "./Functions";
+import { COMPUTED_FIELDS, FieldSpec, FunctionSpec, parseFunction } from "./Functions";
 
 export type SelectItem = {
   getFields: (args?: any[]) => string[] | "*";
@@ -81,9 +76,7 @@ export const asNameAlias = (field: string, tableAlias?: string) => {
   return result;
 };
 
-export const parseFunctionObject = (
-  funcData: any,
-): { funcName: string; args: any[] } => {
+export const parseFunctionObject = (funcData: any): { funcName: string; args: any[] } => {
   const makeErr = (msg: string) =>
     `Function not specified correctly. Expecting { $funcName: ["columnName" | <value>, ...args] } object but got: ${JSON.stringify(funcData)} \n ${msg}`;
   if (!isObject(funcData)) throw makeErr("");
@@ -127,7 +120,7 @@ export class SelectItemBuilder {
     this.functions = params.functions;
     this.columns = params.columns;
     this.allowedFieldsIncludingComputed = this.allowedFields.concat(
-      this.computedFields ? this.computedFields.map((cf) => cf.name) : [],
+      this.computedFields.map((cf) => cf.name)
     );
     if (!this.allowedFields.length) {
       if (!this.columns.length) {
@@ -138,7 +131,7 @@ export class SelectItemBuilder {
 
     /* Check for conflicting computed column names */
     const conflictingCol = this.allFields.find((fieldName) =>
-      this.computedFields.find((cf) => cf.name === fieldName),
+      this.computedFields.find((cf) => cf.name === fieldName)
     );
     if (conflictingCol) {
       throw (
@@ -157,15 +150,10 @@ export class SelectItemBuilder {
     ];
 
     /** Not selected items can be part of the orderBy fields */
-    const allowedFields = isSelected
-      ? allowedSelectedFields
-      : allowedNonSelectedFields;
+    const allowedFields = isSelected ? allowedSelectedFields : allowedNonSelectedFields;
     if (!allowedFields.includes(f)) {
       throw (
-        "Field " +
-        f +
-        " is invalid or dissallowed. \nAllowed fields: " +
-        allowedFields.join(", ")
+        "Field " + f + " is invalid or dissallowed. \nAllowed fields: " + allowedFields.join(", ")
       );
     }
     return f;
@@ -183,11 +171,7 @@ 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) => {
     const funcDef = parseFunction({
       func,
       args,
@@ -248,11 +232,7 @@ export class SelectItemBuilder {
 
   parseUserSelect = async (
     userSelect: Select,
-    joinParse?: (
-      key: string,
-      val: JoinSelect,
-      throwErr: (msg: string) => any,
-    ) => any,
+    joinParse?: (key: string, val: JoinSelect, throwErr: (msg: string) => any) => any
   ) => {
     /* [col1, col2, col3] */
     if (Array.isArray(userSelect)) {
@@ -286,12 +266,7 @@ export class SelectItemBuilder {
             const val: any = userSelect[key as keyof typeof userSelect],
               throwErr = (extraErr = "") => {
                 console.trace(extraErr);
-                throw (
-                  "Unexpected select -> " +
-                  JSON.stringify({ [key]: val }) +
-                  "\n" +
-                  extraErr
-                );
+                throw "Unexpected select -> " + JSON.stringify({ [key]: val }) + "\n" + extraErr;
               };
 
             /* Included fields */
@@ -320,7 +295,7 @@ export class SelectItemBuilder {
                     this.checkField(key, true);
                   } catch (err) {
                     throwErr(
-                      ` Shorthand function notation error: the specifield column ( ${key} ) is invalid or dissallowed. \n Use correct column name or full aliased function notation, e.g.: -> { alias: { $func_name: ["column_name"] } } `,
+                      ` Shorthand function notation error: the specifield column ( ${key} ) is invalid or dissallowed. \n Use correct column name or full aliased function notation, e.g.: -> { alias: { $func_name: ["column_name"] } } `
                     );
                   }
                   funcName = val;
@@ -341,7 +316,7 @@ export class SelectItemBuilder {
                 await joinParse(key, val as JoinSelect, throwErr);
               }
             } else throwErr();
-          }),
+          })
         );
       }
     } else throw "Unexpected select -> " + JSON.stringify(userSelect);

package/lib/DboBuilder/QueryBuilder/getNewQuery.ts

@@ -27,10 +27,7 @@ const JOIN_PARAM_KEYS = getKeys({
   offset: 1,
   orderBy: 1,
   select: 1,
-} satisfies Record<
-  keyof Omit<DetailedJoinSelect, (typeof JOIN_KEYS)[number]>,
-  1
->);
+} satisfies Record<keyof Omit<DetailedJoinSelect, (typeof JOIN_KEYS)[number]>, 1>);
 
 type ParsedJoin =
   | {
@@ -58,18 +55,15 @@ const parseJoinSelect = (joinParams: string | JoinSelect): ParsedJoin => {
       params: joinParams,
     };
   }
-  const [joinKey, ...otherKeys] = getKeys(joinParams).filter((k) =>
-    JOIN_KEYS.includes(k as any),
-  );
+  const [joinKey, ...otherKeys] = getKeys(joinParams).filter((k) => JOIN_KEYS.includes(k as any));
   if (otherKeys.length) {
     return {
-      error:
-        "Cannot specify more than one join type ( $innerJoin OR $leftJoin )",
+      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) => ![...JOIN_PARAM_KEYS, ...JOIN_KEYS].includes(k as any),
+      (k) => ![...JOIN_PARAM_KEYS, ...JOIN_KEYS].includes(k as any)
     );
     if (invalidParams.length) {
       throw "Invalid join params: " + invalidParams.join(", ");
@@ -100,7 +94,7 @@ export async function getNewQuery(
   selectParams: SelectParams & { alias?: string } = {},
   param3_unused = null,
   tableRules: TableRule | undefined,
-  localParams: LocalParams | undefined,
+  localParams: LocalParams | undefined
 ): Promise<NewQuery> {
   const { columns } = _this;
 
@@ -108,14 +102,12 @@ export async function getNewQuery(
     throw `INTERNAL ERROR: publish.${_this.name}.select.fields rule missing`;
   }
 
-  const allowedOrderByFields = !tableRules
-    ? _this.column_names.slice(0)
-    : _this.parseFieldFilter(
-        tableRules?.select?.orderByFields ?? tableRules?.select?.fields,
-      );
-  const allowedSelectFields = !tableRules
-    ? _this.column_names.slice(0)
-    : _this.parseFieldFilter(tableRules?.select?.fields);
+  const allowedOrderByFields =
+    !tableRules ?
+      _this.column_names.slice(0)
+    : _this.parseFieldFilter(tableRules.select?.orderByFields ?? tableRules.select?.fields);
+  const allowedSelectFields =
+    !tableRules ? _this.column_names.slice(0) : _this.parseFieldFilter(tableRules.select?.fields);
 
   const joinQueries: NewQueryJoin[] = [];
 
@@ -130,106 +122,96 @@ export async function getNewQuery(
       columns,
     });
 
-  await sBuilder.parseUserSelect(
-    userSelect,
-    async (fTable, _joinParams, throwErr) => {
-      const j_selectParams: SelectParams = {};
-      let j_filter: Filter = {},
-        j_isLeftJoin = true,
-        j_tableRules: TableRule | undefined;
-      const j_alias = fTable;
+  await sBuilder.parseUserSelect(userSelect, async (fTable, _joinParams, throwErr) => {
+    const j_selectParams: SelectParams = {};
+    let j_filter: Filter = {},
+      j_isLeftJoin = true,
+      j_tableRules: TableRule | undefined;
+    const j_alias = fTable;
 
-      const parsedJoin = parseJoinSelect(_joinParams);
+    const parsedJoin = parseJoinSelect(_joinParams);
 
-      if (!parsedJoin.type) {
-        throwErr(parsedJoin.error);
-        return;
-      }
-      const j_path = parseJoinPath({
-        rawPath: parsedJoin.type === "simple" ? fTable : parsedJoin.params.path,
-        rootTable: _this.name,
-        viewHandler: _this,
-        allowMultiOrJoin: true,
-        addShortestJoinIfMissing: true,
-      });
+    if (!parsedJoin.type) {
+      throwErr(parsedJoin.error);
+      return;
+    }
+    const j_path = parseJoinPath({
+      rawPath: parsedJoin.type === "simple" ? fTable : 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;
+    if (parsedJoin.params === "*") {
+      j_selectParams.select = "*";
+    } else if (parsedJoin.type === "detailed") {
+      const joinParams = parsedJoin.params;
 
-        j_isLeftJoin = !!joinParams.$leftJoin;
+      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;
-      }
+      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 jTable =
-        parsedJoin.type === "simple"
-          ? fTable
-          : typeof j_path === "string"
-            ? j_path
-            : j_path?.at(-1)?.table;
-      if (!jTable) {
-        throw "jTable missing";
-      }
-      const _thisJoinedTable: any = _this.dboBuilder.dbo[jTable];
-      if (!_thisJoinedTable) {
-        throw `Joined table ${JSON.stringify(jTable)} is disallowed or inexistent \nOr you've forgot to put the function arguments into an array`;
-      }
+    const jTable =
+      parsedJoin.type === "simple" ? fTable
+      : typeof j_path === "string" ? j_path
+      : j_path.at(-1)?.table;
+    if (!jTable) {
+      throw "jTable missing";
+    }
+    const _thisJoinedTable: any = _this.dboBuilder.dbo[jTable];
+    if (!_thisJoinedTable) {
+      throw `Joined table ${JSON.stringify(jTable)} is disallowed or inexistent \nOr you've forgot to put the function arguments into an array`;
+    }
 
-      let isLocal = true;
-      if (localParams && (localParams.socket || localParams.httpReq)) {
-        isLocal = false;
-        j_tableRules =
-          await _this.dboBuilder.publishParser?.getValidatedRequestRuleWusr({
-            tableName: jTable,
-            command: "find",
-            localParams,
-          });
-      }
+    let isLocal = true;
+    if (localParams && (localParams.socket || localParams.httpReq)) {
+      isLocal = false;
+      j_tableRules = await _this.dboBuilder.publishParser?.getValidatedRequestRuleWusr({
+        tableName: jTable,
+        command: "find",
+        localParams,
+      });
+    }
 
-      const isAllowedAccessToTable = isLocal || j_tableRules;
-      if (isAllowedAccessToTable) {
-        const joinQuery: NewQuery = await getNewQuery(
-          _thisJoinedTable,
-          j_filter,
-          { ...j_selectParams, alias: j_alias },
-          param3_unused,
-          j_tableRules,
-          localParams,
-        );
-        joinQuery.isLeftJoin = j_isLeftJoin;
-        joinQuery.tableAlias = j_alias;
-        joinQueries.push({
-          ...joinQuery,
-          joinPath: j_path,
-          joinAlias: joinQuery.tableAlias ?? joinQuery.table,
-        });
-      }
-    },
-  );
+    const isAllowedAccessToTable = isLocal || j_tableRules;
+    if (isAllowedAccessToTable) {
+      const joinQuery: NewQuery = await getNewQuery(
+        _thisJoinedTable,
+        j_filter,
+        { ...j_selectParams, alias: j_alias },
+        param3_unused,
+        j_tableRules,
+        localParams
+      );
+      joinQuery.isLeftJoin = j_isLeftJoin;
+      joinQuery.tableAlias = j_alias;
+      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);
-      }
-    },
-  );
+  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;
 
@@ -248,8 +230,9 @@ export async function getNewQuery(
     ...commonWhereParams,
     isHaving: false,
   });
-  const havingOpts = !isEmpty(selectParams.having)
-    ? await _this.prepareWhere({
+  const havingOpts =
+    !isEmpty(selectParams.having) ?
+      await _this.prepareWhere({
         ...omitKeys(commonWhereParams, ["forcedFilter"]),
         filter: selectParams.having,
         isHaving: true,
@@ -273,15 +256,12 @@ export async function getNewQuery(
       allowedOrderByFields,
       selectParams.alias,
       select,
-      joinQueries,
+      joinQueries
     ),
     offset: prepareOffsetQuery(selectParams.offset),
   };
 
-  if (
-    resQuery.select.some((s) => s.type === "aggregation") &&
-    resQuery.joins?.length
-  ) {
+  if (resQuery.select.some((s) => s.type === "aggregation") && resQuery.joins?.length) {
     throw new Error(`Root query aggregation AND nested joins not allowed`);
   }
 
@@ -298,32 +278,25 @@ const prepareOffsetQuery = (offset?: number) => {
 
 const prepareLimitQuery = (
   limit: number | null | undefined = null,
-  p: ValidatedTableRules,
+  p: ValidatedTableRules
 ): number | null => {
-  if (limit !== undefined && limit !== null && !Number.isInteger(limit)) {
+  if (limit !== null && !Number.isInteger(limit)) {
     throw "Unexpected LIMIT. Must be null or an integer";
   }
 
+  if (!p.select) {
+    throw "select missing";
+  }
+
   let _limit = limit;
   /* If no limit then set as the lesser of (100, maxLimit) */
-  if (
-    _limit !== null &&
-    !Number.isInteger(_limit) &&
-    p.select.maxLimit !== null
-  ) {
-    _limit = [100, p.select.maxLimit]
-      .filter(Number.isInteger)
-      .sort((a, b) => a - b)[0]!;
+  if (_limit !== null && !Number.isInteger(_limit) && p.select.maxLimit !== null) {
+    _limit = [100, p.select.maxLimit].filter(Number.isInteger).sort((a, b) => a - b)[0]!;
   } else {
     /* If a limit higher than maxLimit specified throw error */
-    if (
-      Number.isInteger(p.select.maxLimit) &&
-      _limit !== null &&
-      _limit > p.select.maxLimit!
-    ) {
+    if (Number.isInteger(p.select.maxLimit) && _limit !== null && _limit > p.select.maxLimit!) {
       throw (
-        `Unexpected LIMIT ${_limit}. Must be less than the published maxLimit: ` +
-        p.select.maxLimit
+        `Unexpected LIMIT ${_limit}. Must be less than the published maxLimit: ` + p.select.maxLimit
       );
     }
   }

package/lib/DboBuilder/QueryBuilder/getSelectQuery.ts

@@ -18,13 +18,11 @@ export function getSelectQuery(
   viewHandler: ViewHandler,
   q: NewQuery,
   depth = 0,
-  selectParamsGroupBy: boolean,
+  selectParamsGroupBy: boolean
 ): string {
   const rootSelect = q.select
     .filter((s) => s.selected)
-    .map((s) =>
-      [s.getQuery(ROOT_TABLE_ALIAS), " AS ", asName(s.alias)].join(""),
-    );
+    .map((s) => [s.getQuery(ROOT_TABLE_ALIAS), " AS ", asName(s.alias)].join(""));
 
   const parsedJoins =
     q.joins?.flatMap((q2) => {
@@ -40,21 +38,21 @@ export function getSelectQuery(
     }) ?? [];
 
   const selectItems = rootSelect.concat(
-    parsedJoins?.map((join) => {
+    parsedJoins.map((join) => {
       const { joinAlias } = join;
       return `COALESCE(${asName(joinAlias)}.${join.resultAlias}, '[]') as ${asName(joinAlias)}`;
-    }) ?? [],
+    })
   );
 
   /** 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);
 
-  let joinCtes = !parsedJoins.length
-    ? []
+  let joinCtes =
+    !parsedJoins.length ?
+      []
     : [
         ...parsedJoins.flatMap((j, i) => {
-          const needsComma =
-            parsedJoins.length > 1 && i < parsedJoins.length - 1;
+          const needsComma = parsedJoins.length > 1 && i < parsedJoins.length - 1;
           return j.cteLines.concat(needsComma ? [","] : []);
         }),
       ];
@@ -94,11 +92,8 @@ export function getSelectQuery(
   return indentLinesToString(query);
 }
 
-const indentLine = (
-  numberOfSpaces: number,
-  str: string,
-  indentStr = "    ",
-): string => new Array(numberOfSpaces).fill(indentStr).join("") + str;
+const indentLine = (numberOfSpaces: number, str: string, indentStr = "    "): string =>
+  new Array(numberOfSpaces).fill(indentStr).join("") + str;
 type IndentLinesOpts = {
   numberOfSpaces?: number;
   indentStr?: string;
@@ -106,11 +101,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);
 
@@ -126,7 +117,7 @@ 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}`;
@@ -134,9 +125,7 @@ export const getTableAliasAsName = (q: NewQuery) => asName(getTableAlias(q));
 
 export const getRootGroupBy = (q: NewQuery, selectParamsGroupBy?: boolean) => {
   const aggs = q.select.filter((s) => s.selected && s.type === "aggregation");
-  const nonAggs = q.select.filter(
-    (s) => s.selected && s.type !== "aggregation",
-  );
+  const nonAggs = q.select.filter((s) => s.selected && s.type !== "aggregation");
 
   if ((selectParamsGroupBy || aggs.length) && nonAggs.length) {
     /** Add ORDER BY items not included in root select */
@@ -149,9 +138,7 @@ export const getRootGroupBy = (q: NewQuery, selectParamsGroupBy?: boolean) => {
 
     return [
       `GROUP BY ${q.select
-        .map((s, i) =>
-          s.selected && s.type !== "aggregation" ? `${i + 1}` : undefined,
-        )
+        .map((s, i) => (s.selected && s.type !== "aggregation" ? `${i + 1}` : undefined))
         .concat(orderByItems)
         .filter(isDefined)
         .join(", ")} `,