prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/QueryBuilder/getSelectQuery.ts

@@ -1,19 +1,18 @@
-
 import { prepareOrderByQuery } from "../DboBuilder";
 import { isDefined, asName } from "prostgles-types";
 import { NewQuery } from "./QueryBuilder";
 import { ViewHandler } from "../ViewHandler/ViewHandler";
-import { getJoinQuery } from "./getJoinQuery"; 
+import { getJoinQuery } from "./getJoinQuery";
 
 /**
  * Used to prevent single row nested results in case of OR join conditions
  */
 export const ROOT_TABLE_ROW_NUM_ID = "prostgles_root_table_row_id" as const;
-export const ROOT_TABLE_ALIAS = 'prostgles_root_table_alias' as const;
+export const ROOT_TABLE_ALIAS = "prostgles_root_table_alias" as const;
 
 /**
  * Creating the text query from the NewQuery spec
- * No validation/authorisation at this point 
+ * No validation/authorisation at this point
  * */
 export function getSelectQuery(
   viewHandler: ViewHandler,
@@ -21,106 +20,125 @@ export function getSelectQuery(
   depth = 0,
   selectParamsGroupBy: boolean,
 ): string {
-
-  const rootSelect = q.select.filter(s => s.selected).map(s => [s.getQuery(ROOT_TABLE_ALIAS), " AS ", asName(s.alias)].join(""));
-
-  const parsedJoins = q.joins?.flatMap(q2 => {
-    const parsed = getJoinQuery(
-      viewHandler, 
-      { 
-        q1: { ...q, tableAlias: ROOT_TABLE_ALIAS }, 
-        q2: { ...q2 }, 
-        selectParamsGroupBy 
-      }
+  const rootSelect = q.select
+    .filter((s) => s.selected)
+    .map((s) =>
+      [s.getQuery(ROOT_TABLE_ALIAS), " AS ", asName(s.alias)].join(""),
     );
-    return {
-      ...q2,
-      ...parsed
-    }
-  }) ?? [];
+
+  const parsedJoins =
+    q.joins?.flatMap((q2) => {
+      const parsed = getJoinQuery(viewHandler, {
+        q1: { ...q, tableAlias: ROOT_TABLE_ALIAS },
+        q2: { ...q2 },
+        selectParamsGroupBy,
+      });
+      return {
+        ...q2,
+        ...parsed,
+      };
+    }) ?? [];
 
   const selectItems = rootSelect.concat(
-    parsedJoins?.map(join => {
+    parsedJoins?.map((join) => {
       const { joinAlias } = join;
-      return `COALESCE(${asName(joinAlias)}.${join.resultAlias}, '[]') as ${asName(joinAlias)}`
-    }) ?? []);
+      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? [] : [
-    ...parsedJoins.flatMap((j, i) => {
-      const needsComma = parsedJoins.length > 1 && i < parsedJoins.length -1;
-      return j.cteLines.concat(needsComma? [","] : []);
-    })
-  ];
-
-  
-  if(hasOrJoins){
-    const pkey = viewHandler.columns.find(c => c.is_pkey);
+  const hasOrJoins = parsedJoins.some((j) => j.isOrJoin);
+
+  let joinCtes = !parsedJoins.length
+    ? []
+    : [
+        ...parsedJoins.flatMap((j, i) => {
+          const needsComma =
+            parsedJoins.length > 1 && i < parsedJoins.length - 1;
+          return j.cteLines.concat(needsComma ? [","] : []);
+        }),
+      ];
+
+  if (hasOrJoins) {
+    const pkey = viewHandler.columns.find((c) => c.is_pkey);
     joinCtes = [
       `${q.table} AS (`,
-      `  SELECT *, ${pkey? asName(pkey.name): "ROW_NUMBER() OVER()"} as ${ROOT_TABLE_ROW_NUM_ID}`,
+      `  SELECT *, ${pkey ? asName(pkey.name) : "ROW_NUMBER() OVER()"} as ${ROOT_TABLE_ROW_NUM_ID}`,
       `  FROM ${q.table}`,
       `),`,
-      ...joinCtes
-    ]
+      ...joinCtes,
+    ];
   }
 
-  if(joinCtes.length){
-    joinCtes.unshift(`WITH `)
+  if (joinCtes.length) {
+    joinCtes.unshift(`WITH `);
   }
 
   const query = [
     ...joinCtes,
-    `SELECT`
-    ,...indentLines(selectItems, { appendCommas: true })
-    , `FROM ( `
-    , `  SELECT *`
-    , `  FROM ${q.table}`
-    , ...(q.where? [`  ${q.where}`] : [])
-    , `) ${ROOT_TABLE_ALIAS}`
-    , ...parsedJoins.flatMap(j => j.joinLines)
-    , ...getRootGroupBy(q, selectParamsGroupBy)
-    , ...prepareOrderByQuery(q.orderByItems)
-    , ...(q.having ? [`HAVING ${q.having} `] : [])
-    , ...(depth || q.limit === null ? [] : [`LIMIT ${q.limit || 0}`])
-    , ...(q.offset? [`OFFSET ${q.offset || 0}`] : [])
+    `SELECT`,
+    ...indentLines(selectItems, { appendCommas: true }),
+    `FROM ( `,
+    `  SELECT *`,
+    `  FROM ${q.table}`,
+    ...(q.where ? [`  ${q.where}`] : []),
+    `) ${ROOT_TABLE_ALIAS}`,
+    ...parsedJoins.flatMap((j) => j.joinLines),
+    ...getRootGroupBy(q, selectParamsGroupBy),
+    ...prepareOrderByQuery(q.orderByItems),
+    ...(q.having ? [`HAVING ${q.having} `] : []),
+    ...(depth || q.limit === null ? [] : [`LIMIT ${q.limit || 0}`]),
+    ...(q.offset ? [`OFFSET ${q.offset || 0}`] : []),
   ];
 
   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;
   appendCommas?: boolean;
-}
-export const indentLines = (strArr: (string | undefined | null)[],  { numberOfSpaces = 2, indentStr = " ", appendCommas = false }: IndentLinesOpts = {}): string[] => {
-  const nonEmptyLines = strArr
-    .filter(v => v);
+};
+export const indentLines = (
+  strArr: (string | undefined | null)[],
+  {
+    numberOfSpaces = 2,
+    indentStr = " ",
+    appendCommas = false,
+  }: IndentLinesOpts = {},
+): string[] => {
+  const nonEmptyLines = strArr.filter((v) => v);
 
   return nonEmptyLines.map((str, idx) => {
-      const res = indentLine(numberOfSpaces, str as string, indentStr);
-      if(appendCommas && idx < nonEmptyLines.length - 1){
-        return `${res},`;
-      }
-      return res;
-    });
-}
-const indentLinesToString = (strArr: (string | undefined | null)[], numberOfSpaces = 0, separator = " \n ", indentStr = " ") => indentLines(strArr, { numberOfSpaces, indentStr }).join(separator);
-const getTableAlias = (q: NewQuery) => !q.tableAlias ? q.table : `${q.tableAlias || ""}_${q.table}`;
+    const res = indentLine(numberOfSpaces, str as string, indentStr);
+    if (appendCommas && idx < nonEmptyLines.length - 1) {
+      return `${res},`;
+    }
+    return res;
+  });
+};
+const indentLinesToString = (
+  strArr: (string | undefined | null)[],
+  numberOfSpaces = 0,
+  separator = " \n ",
+  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 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 aggs = 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 */
     const orderByItems: string[] = [];
     // q.orderByItems.forEach(sortItem => {
@@ -129,8 +147,16 @@ export const getRootGroupBy = (q: NewQuery, selectParamsGroupBy?: boolean) => {
     //   }
     // });
 
-    return [`GROUP BY ${q.select.map((s, i)=> s.selected && s.type !== "aggregation"? `${i+1}` : undefined).concat(orderByItems).filter(isDefined).join(", ")} `]
+    return [
+      `GROUP BY ${q.select
+        .map((s, i) =>
+          s.selected && s.type !== "aggregation" ? `${i + 1}` : undefined,
+        )
+        .concat(orderByItems)
+        .filter(isDefined)
+        .join(", ")} `,
+    ];
   }
 
-  return []
-}
+  return [];
+};

package/lib/DboBuilder/QueryBuilder/prepareHaving.ts

@@ -8,10 +8,15 @@ type Args = {
   select: SelectItemValidated[];
   tableAlias: string | undefined;
   filterFieldNames: string[];
-}
-export const prepareHaving = ({ having, select, tableAlias, filterFieldNames }: Args) => {
-  if(!having || isEmpty(having)) return "";
-  
+};
+export const prepareHaving = ({
+  having,
+  select,
+  tableAlias,
+  filterFieldNames,
+}: Args) => {
+  if (!having || isEmpty(having)) return "";
+
   const havingStr = parseFilterItem({
     filter: having,
     select,
@@ -19,4 +24,4 @@ export const prepareHaving = ({ having, select, tableAlias, filterFieldNames }:
     allowedColumnNames: filterFieldNames,
   });
   return havingStr;
-}
+};