prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/ViewHandler/parseJoinPath.ts

@@ -7,76 +7,93 @@ type parseJoinPathArgs = {
   viewHandler: ViewHandler;
   allowMultiOrJoin?: boolean;
   addShortestJoinIfMissing?: boolean;
-}
+};
 export type ParsedJoinPath = { table: string; on: Record<string, string>[] };
 
 /**
  * Return a valid join path
  */
-export const parseJoinPath = ({ rawPath, rootTable, viewHandler, allowMultiOrJoin = false, addShortestJoinIfMissing }: parseJoinPathArgs): ParsedJoinPath[] => {
+export const parseJoinPath = ({
+  rawPath,
+  rootTable,
+  viewHandler,
+  allowMultiOrJoin = false,
+  addShortestJoinIfMissing,
+}: parseJoinPathArgs): ParsedJoinPath[] => {
   const result: ParsedJoinPath[] = [];
-  let cleanPath = typeof rawPath === "string"? [{ table: rawPath }] : rawPath;
-  if(addShortestJoinIfMissing && cleanPath[0] !== "**"){
-    cleanPath = ["**", ...cleanPath]
+  let cleanPath = typeof rawPath === "string" ? [{ table: rawPath }] : rawPath;
+  if (addShortestJoinIfMissing && cleanPath[0] !== "**") {
+    cleanPath = ["**", ...cleanPath];
   }
   cleanPath.forEach((item, i) => {
     const prevTable = result.at(-1)?.table ?? rootTable;
-    if(!prevTable) throw `prevTable missing`;
+    if (!prevTable) throw `prevTable missing`;
 
     const pushJoinPath = (targetPath: JoinPath) => {
       const getShortestJoin = i === 1 && cleanPath[0] === "**";
-      const joinInfo = getJoins(viewHandler, prevTable, [targetPath], { allowMultiOrJoin, getShortestJoin });
-      
-      joinInfo.paths.forEach(path => {
+      const joinInfo = getJoins(viewHandler, prevTable, [targetPath], {
+        allowMultiOrJoin,
+        getShortestJoin,
+      });
 
+      joinInfo.paths.forEach((path) => {
         /** Check if join tables are valid */
         if (!viewHandler.dboBuilder.dbo[path.table]) {
-          throw { stack: ["prepareExistCondition()"], message: `Invalid or dissallowed table in join path: ${path.table}` };
+          throw {
+            stack: ["prepareExistCondition()"],
+            message: `Invalid or dissallowed table in join path: ${path.table}`,
+          };
         }
         result.push({
           table: path.table,
-          on: path.on.map(constraint => Object.fromEntries(constraint))
+          on: path.on.map((constraint) => Object.fromEntries(constraint)),
         });
-      })
-    }
+      });
+    };
 
     /** Shortest join */
-    if(item === "**"){
-
-    } else if(typeof item === "string"){
+    if (item === "**") {
+    } else if (typeof item === "string") {
       const table = item;
-      pushJoinPath({ table })
+      pushJoinPath({ table });
     } else {
       pushJoinPath(item);
     }
   });
 
-  const missingPath = result.find(r => !r.on.length || r.on.some(v => !Object.keys(v).length));
-  if(missingPath){
-    throw `Missing join on condition for: ${missingPath.table}`
+  const missingPath = result.find(
+    (r) => !r.on.length || r.on.some((v) => !Object.keys(v).length),
+  );
+  if (missingPath) {
+    throw `Missing join on condition for: ${missingPath.table}`;
   }
 
   return result;
-}
+};
 
 import { JoinInfo } from "../DboBuilder";
 
 type Opts = {
   allowMultiOrJoin?: boolean;
   getShortestJoin?: boolean;
-}
+};
 
 /**
  * Returns all tables and fields required to join from source table to target table
  * Respecting the path.on condition
  */
-function getJoins(viewHandler: ViewHandler, source: string, path: JoinPath[], { allowMultiOrJoin = true, getShortestJoin }: Opts = {}): JoinInfo {
+function getJoins(
+  viewHandler: ViewHandler,
+  source: string,
+  path: JoinPath[],
+  { allowMultiOrJoin = true, getShortestJoin }: Opts = {},
+): JoinInfo {
   const [lastItem] = path;
-  if(!lastItem){
+  if (!lastItem) {
     throw `Empty path`;
   }
-  if(getShortestJoin && path.length !== 1){
-    throw `getShortestJoin requires exactly 1 path item`
+  if (getShortestJoin && path.length !== 1) {
+    throw `getShortestJoin requires exactly 1 path item`;
   }
   const target = lastItem.table;
   if (!viewHandler.joinPaths) {
@@ -85,52 +102,77 @@ function getJoins(viewHandler: ViewHandler, source: string, path: JoinPath[], {
 
   /* Self join */
   if (source === target) {
-    const tableHandler = viewHandler.dboBuilder.tablesOrViews?.find(t => t.name === source);
+    const tableHandler = viewHandler.dboBuilder.tablesOrViews?.find(
+      (t) => t.name === source,
+    );
     if (!tableHandler) throw `Table not found for joining ${source}`;
 
-    const fcols = tableHandler.columns.filter(c => c.references?.some(({ ftable }) => ftable === viewHandler.name));
-    if(!fcols.length){
-      throw `There is no self-join foreign key relationship for table ${JSON.stringify(target)}`
+    const fcols = tableHandler.columns.filter((c) =>
+      c.references?.some(({ ftable }) => ftable === viewHandler.name),
+    );
+    if (!fcols.length) {
+      throw `There is no self-join foreign key relationship for table ${JSON.stringify(target)}`;
     }
     let allOnJoins: [string, string][][] = [];
-    fcols.forEach(fc => {
+    fcols.forEach((fc) => {
       fc.references!.forEach(({ fcols, cols }) => {
-        const fieldArr = fcols.map((fcol, i) => [fcol,  cols[i]!] as [string, string]);
+        const fieldArr = fcols.map(
+          (fcol, i) => [fcol, cols[i]!] as [string, string],
+        );
         allOnJoins.push(fieldArr);
-      })
+      });
     });
     allOnJoins = [
       ...allOnJoins,
       /** Reverse as well */
-      ...allOnJoins.map(constraint => (constraint).map(([left, right]) => [right, left] as [string, string]))
-    ]
+      ...allOnJoins.map((constraint) =>
+        constraint.map(([left, right]) => [right, left] as [string, string]),
+      ),
+    ];
     return {
-      paths: [{
-        source,
-        target,
-        table: target,
-        on: getValidOn(lastItem.on, allOnJoins.map(v => Object.fromEntries(v)))
-      }],
-      expectOne: false
-    }
+      paths: [
+        {
+          source,
+          target,
+          table: target,
+          on: getValidOn(
+            lastItem.on,
+            allOnJoins.map((v) => Object.fromEntries(v)),
+          ),
+        },
+      ],
+      expectOne: false,
+    };
   }
 
   /* Find the join path between tables */
-  const tableConfigJoinInfo = viewHandler.dboBuilder?.prostgles?.tableConfigurator?.getJoinInfo(source, target);
+  const tableConfigJoinInfo =
+    viewHandler.dboBuilder?.prostgles?.tableConfigurator?.getJoinInfo(
+      source,
+      target,
+    );
   if (tableConfigJoinInfo) return tableConfigJoinInfo;
 
-  const actualPath = getShortestJoin? 
-    viewHandler.joinPaths.find(j => {
-      return j.t1 === source && j.t2 === target
-    })?.path.map(table => ({ table, on: undefined })).slice(1) : 
-    viewHandler.joinPaths.find(j => {
-      return j.path.join() === [{ table: source }, ...path].map(p => p.table).join()
-    })? path : undefined;
+  const actualPath = getShortestJoin
+    ? viewHandler.joinPaths
+        .find((j) => {
+          return j.t1 === source && j.t2 === target;
+        })
+        ?.path.map((table) => ({ table, on: undefined }))
+        .slice(1)
+    : viewHandler.joinPaths.find((j) => {
+          return (
+            j.path.join() ===
+            [{ table: source }, ...path].map((p) => p.table).join()
+          );
+        })
+      ? path
+      : undefined;
 
-  if(getShortestJoin && actualPath?.length && lastItem.on?.length){
-    actualPath[actualPath.length-1]!.on = lastItem.on;
+  if (getShortestJoin && actualPath?.length && lastItem.on?.length) {
+    actualPath[actualPath.length - 1]!.on = lastItem.on;
   }
-  
+
   if (!actualPath) {
     throw `Joining ${source} <-...-> ${target} dissallowed or missing`;
   }
@@ -144,19 +186,21 @@ function getJoins(viewHandler: ViewHandler, source: string, path: JoinPath[], {
     viewHandler.joins ??= viewHandler.dboBuilder.joins;
 
     /* Get join options */
-    const join = viewHandler.joins.find(j => j.tables.includes(t1) && j.tables.includes(tablePath.table));
+    const join = viewHandler.joins.find(
+      (j) => j.tables.includes(t1) && j.tables.includes(tablePath.table),
+    );
     if (!join) {
       throw `Joining ${t1} <-> ${tablePath} dissallowed or missing`;
     }
     const isLtr = join.tables[0] === t1;
-    const joinOn = isLtr? join.on : reverseJoinOn(join.on);
+    const joinOn = isLtr ? join.on : reverseJoinOn(join.on);
 
     const on = getValidOn(tablePath.on, joinOn);
     paths.push({
       source,
       target,
       table: tablePath.table,
-      on
+      on,
     });
   });
   const expectOne = false;
@@ -172,37 +216,47 @@ function getJoins(viewHandler: ViewHandler, source: string, path: JoinPath[], {
   // }
   // })
 
-  const isMultiOrJoin = paths.find(p => p.on.length > 1);
-  if(!allowMultiOrJoin && isMultiOrJoin){
-    throw `Table ${JSON.stringify(source)} can join to ${JSON.stringify(target)} through multiple constraints. Must chose one of ${JSON.stringify(isMultiOrJoin.on)}`
+  const isMultiOrJoin = paths.find((p) => p.on.length > 1);
+  if (!allowMultiOrJoin && isMultiOrJoin) {
+    throw `Table ${JSON.stringify(source)} can join to ${JSON.stringify(target)} through multiple constraints. Must chose one of ${JSON.stringify(isMultiOrJoin.on)}`;
   }
   return {
     paths,
-    expectOne
+    expectOne,
   };
 }
 
-const getValidOn = (requested: JoinPath["on"], possible: ParsedJoinPath["on"]) => {
-
-  if(!requested){
-    return possible.map(v => Object.entries(v));
+const getValidOn = (
+  requested: JoinPath["on"],
+  possible: ParsedJoinPath["on"],
+) => {
+  if (!requested) {
+    return possible.map((v) => Object.entries(v));
   }
-  if(!requested.length){
-    throw `Invalid requested "tablePath.on". Cannot be empty`
+  if (!requested.length) {
+    throw `Invalid requested "tablePath.on". Cannot be empty`;
   }
-  const isValid = requested.every(requestedConstraint => {
-    return possible.some(possibleConstraint => conditionsMatch(possibleConstraint, requestedConstraint));
+  const isValid = requested.every((requestedConstraint) => {
+    return possible.some((possibleConstraint) =>
+      conditionsMatch(possibleConstraint, requestedConstraint),
+    );
   });
 
-  if(!isValid){
-    throw `Invalid path specified for join: ${JSON.stringify(requested)}. Allowed paths: ${JSON.stringify(possible)}`
+  if (!isValid) {
+    throw `Invalid path specified for join: ${JSON.stringify(requested)}. Allowed paths: ${JSON.stringify(possible)}`;
   }
 
-  return requested.map(v => Object.entries(v));
-}
+  return requested.map((v) => Object.entries(v));
+};
 
-const conditionsMatch = (c1: Record<string, string>, c2: Record<string, string>) => {
+const conditionsMatch = (
+  c1: Record<string, string>,
+  c2: Record<string, string>,
+) => {
   const keys1 = Object.keys(c1);
   const keys2 = Object.keys(c2);
-  return keys1.sort().join() === keys2.sort().join() && keys1.every(key => c1[key] === c2[key]);
-}
+  return (
+    keys1.sort().join() === keys2.sort().join() &&
+    keys1.every((key) => c1[key] === c2[key])
+  );
+};

package/lib/DboBuilder/ViewHandler/prepareSortItems.ts

@@ -1,6 +1,16 @@
-import { OrderBy, asName, isDefined, isEmpty, isObject } from "prostgles-types/dist";
+import {
+  OrderBy,
+  asName,
+  isDefined,
+  isEmpty,
+  isObject,
+} from "prostgles-types/dist";
 import { SortItem } from "../DboBuilder";
-import { NewQueryJoin, SelectItemValidated, asNameAlias } from "../QueryBuilder/QueryBuilder";
+import {
+  NewQueryJoin,
+  SelectItemValidated,
+  asNameAlias,
+} from "../QueryBuilder/QueryBuilder";
 
 /* This relates only to SELECT */
 export const prepareSortItems = (
@@ -10,127 +20,160 @@ export const prepareSortItems = (
   select: SelectItemValidated[],
   joinQueries: NewQueryJoin[],
 ): SortItem[] => {
-
   if (!rawOrderBy) return [];
 
-  let orderBy: { key: string, asc: boolean, nulls?: "first" | "last", nullEmpty?: boolean }[] = [];
+  let orderBy: {
+    key: string;
+    asc: boolean;
+    nulls?: "first" | "last";
+    nullEmpty?: boolean;
+  }[] = [];
   if (isObject(rawOrderBy)) {
     orderBy = parseOrderObj(rawOrderBy);
   } else if (typeof rawOrderBy === "string") {
     /* string */
     orderBy = [{ key: rawOrderBy, asc: true }];
   } else if (Array.isArray(rawOrderBy)) {
-
     /* Order by is formed of a list of ascending field names */
-    const _orderBy = (rawOrderBy as any[]);
-    if (_orderBy && !_orderBy.find(v => typeof v !== "string")) {
+    const _orderBy = rawOrderBy as any[];
+    if (_orderBy && !_orderBy.find((v) => typeof v !== "string")) {
       /* [string] */
-      orderBy = _orderBy.map(key => ({ key, asc: true }));
-    } else if (_orderBy.find(v => isObject(v) && !isEmpty(v))) {
-      orderBy = _orderBy.map(v => parseOrderObj(v, true)[0]!);
+      orderBy = _orderBy.map((key) => ({ key, asc: true }));
+    } else if (_orderBy.find((v) => isObject(v) && !isEmpty(v))) {
+      orderBy = _orderBy.map((v) => parseOrderObj(v, true)[0]!);
     } else return throwErr(rawOrderBy);
   } else return throwErr(rawOrderBy);
 
   if (!orderBy || !orderBy.length) return [];
 
-  const validatedAggAliases = select.filter(s =>
-    s.type !== "joinedColumn" &&
-    (!s.fields.length || s.fields.every(f => allowed_cols.includes(f)))
-  ).map(s => s.alias)
-
-  const sortableNestedColumns = joinQueries.flatMap(jq => jq.select.map(selectItem => {
-    const joinAlias = jq.tableAlias ?? jq.table;
-    return {
-      ...jq,
-      selectItem,
-      joinAlias,
-      key: `${joinAlias}.${selectItem.alias}`
-    }
-  }));
-  const bad_param = orderBy.find(({ key }) =>
-    !sortableNestedColumns.some(v => v.key === key) &&
-    !validatedAggAliases.includes(key) &&
-    !allowed_cols.includes(key)
+  const validatedAggAliases = select
+    .filter(
+      (s) =>
+        s.type !== "joinedColumn" &&
+        (!s.fields.length || s.fields.every((f) => allowed_cols.includes(f))),
+    )
+    .map((s) => s.alias);
+
+  const sortableNestedColumns = joinQueries.flatMap((jq) =>
+    jq.select.map((selectItem) => {
+      const joinAlias = jq.tableAlias ?? jq.table;
+      return {
+        ...jq,
+        selectItem,
+        joinAlias,
+        key: `${joinAlias}.${selectItem.alias}`,
+      };
+    }),
+  );
+  const bad_param = orderBy.find(
+    ({ key }) =>
+      !sortableNestedColumns.some((v) => v.key === key) &&
+      !validatedAggAliases.includes(key) &&
+      !allowed_cols.includes(key),
   );
   if (bad_param) {
     throw "Invalid/disallowed orderBy fields or params: " + bad_param.key;
   }
 
-  const selectedAliases = select.filter(s => s.selected).map(s => s.alias);
-  
-  const result: SortItem[] = orderBy.map(({ key, asc, nulls, nullEmpty = false }) => {
-
-    const nestedField = sortableNestedColumns.find(f => f.key === key);
-    if (nestedField) {
-      const { table, selectItem, joinAlias } = nestedField;
-      
-      const comparableDataTypeCast = ["uuid", "xml"].includes(selectItem.column_udt_type ?? "")? "::TEXT" : "";
-      const sortItemAlias = asName(`prostgles_nested_sort_${selectItem.alias}`)
-      
-      return {
-        key,
-        type: "query",
-        asc,
-        nulls,
-        nullEmpty,
-        nested: {
-          table,
-          joinAlias,
-          selectItemAlias: selectItem.alias,
-          isNumeric: selectItem.tsDataType === "number",
-          wrapperQuerySortItem: `${asc? "MIN" : "MAX"}(${asNameAlias(selectItem.alias, joinAlias)}${comparableDataTypeCast}) as ${sortItemAlias}`,
-        },
-        fieldQuery: `${asName(joinAlias)}.${sortItemAlias + (asc? "" : " DESC")} ${nulls? `NULLS ${nulls === "last"? "LAST" : "FIRST" }` : ""}`,
+  const selectedAliases = select.filter((s) => s.selected).map((s) => s.alias);
+
+  const result: SortItem[] = orderBy.map(
+    ({ key, asc, nulls, nullEmpty = false }) => {
+      const nestedField = sortableNestedColumns.find((f) => f.key === key);
+      if (nestedField) {
+        const { table, selectItem, joinAlias } = nestedField;
+
+        const comparableDataTypeCast = ["uuid", "xml"].includes(
+          selectItem.column_udt_type ?? "",
+        )
+          ? "::TEXT"
+          : "";
+        const sortItemAlias = asName(
+          `prostgles_nested_sort_${selectItem.alias}`,
+        );
+
+        return {
+          key,
+          type: "query",
+          asc,
+          nulls,
+          nullEmpty,
+          nested: {
+            table,
+            joinAlias,
+            selectItemAlias: selectItem.alias,
+            isNumeric: selectItem.tsDataType === "number",
+            wrapperQuerySortItem: `${asc ? "MIN" : "MAX"}(${asNameAlias(selectItem.alias, joinAlias)}${comparableDataTypeCast}) as ${sortItemAlias}`,
+          },
+          fieldQuery: `${asName(joinAlias)}.${sortItemAlias + (asc ? "" : " DESC")} ${nulls ? `NULLS ${nulls === "last" ? "LAST" : "FIRST"}` : ""}`,
+        };
       }
-    }
-    /* Order by column index when possible to bypass name collision when ordering by a computed column. 
+      /* Order by column index when possible to bypass name collision when ordering by a computed column. 
         (Postgres will sort by existing columns wheundefined possible) 
     */
-   
-    const index = selectedAliases.indexOf(key) + 1;
-    let colKey = (index > 0 && !nullEmpty) ? index : [tableAlias, key].filter(isDefined).map(asName).join(".");
-    if (nullEmpty) {
-      colKey = `nullif(trim(${colKey}::text), '')`
-    }
 
-    if (typeof colKey === "number") {
+      const index = selectedAliases.indexOf(key) + 1;
+      let colKey =
+        index > 0 && !nullEmpty
+          ? index
+          : [tableAlias, key].filter(isDefined).map(asName).join(".");
+      if (nullEmpty) {
+        colKey = `nullif(trim(${colKey}::text), '')`;
+      }
+
+      if (typeof colKey === "number") {
+        return {
+          key,
+          type: "position",
+          asc,
+          nulls,
+          nullEmpty,
+          fieldPosition: colKey,
+        };
+      }
+
       return {
         key,
-        type: "position",
-        asc,
+        type: "query",
+        fieldQuery: colKey,
         nulls,
         nullEmpty,
-        fieldPosition: colKey
-      }
-    }
-
-    return {
-      key,
-      type: "query",
-      fieldQuery: colKey,
-      nulls,
-      nullEmpty,
-      asc,
-    }
-  });
+        asc,
+      };
+    },
+  );
 
   return result;
-}
+};
 
 const throwErr = (rawOrderBy: any) => {
-  throw "\nInvalid orderBy option -> " + JSON.stringify(rawOrderBy) +
-  "Expecting: \
+  throw (
+    "\nInvalid orderBy option -> " +
+    JSON.stringify(rawOrderBy) +
+    "Expecting: \
         { key2: false, \"nested.key2\": false, key1: true } \
         { key1: 1, key2: -1 } \
         [{ key1: true }, { key2: false }] \
         [{ key: 'colName', asc: true, nulls: 'first', nullEmpty: true }]"
+  );
 };
 
-const parseOrderObj = (orderBy: any, expectOne = false): { key: string, asc: boolean, nulls?: "first" | "last", nullEmpty?: boolean }[] => {
+const parseOrderObj = (
+  orderBy: any,
+  expectOne = false,
+): {
+  key: string;
+  asc: boolean;
+  nulls?: "first" | "last";
+  nullEmpty?: boolean;
+}[] => {
   if (!isObject(orderBy)) return throwErr(orderBy);
 
   const keys = Object.keys(orderBy);
-  if (keys.length && keys.find(k => ["key", "asc", "nulls", "nullEmpty"].includes(k))) {
+  if (
+    keys.length &&
+    keys.find((k) => ["key", "asc", "nulls", "nullEmpty"].includes(k))
+  ) {
     const { key, asc, nulls, nullEmpty = false } = orderBy;
     if (
       !["string"].includes(typeof key) ||
@@ -139,25 +182,30 @@ const parseOrderObj = (orderBy: any, expectOne = false): { key: string, asc: boo
       !["boolean"].includes(typeof nullEmpty)
     ) {
       throw `Invalid orderBy option (${JSON.stringify(orderBy, null, 2)}) \n 
-                      Expecting { key: string, asc?: boolean, nulls?: 'first' | 'last' | null | undefined, nullEmpty?: boolean } `
+                      Expecting { key: string, asc?: boolean, nulls?: 'first' | 'last' | null | undefined, nullEmpty?: boolean } `;
     }
     return [{ key, asc, nulls, nullEmpty }];
   }
 
   if (expectOne && keys.length > 1) {
-    throw "\nInvalid orderBy " + JSON.stringify(orderBy) +
-    "\nEach orderBy array element cannot have more than one key";
+    throw (
+      "\nInvalid orderBy " +
+      JSON.stringify(orderBy) +
+      "\nEach orderBy array element cannot have more than one key"
+    );
   }
   /* { key2: true, key1: false } */
-  if (!Object.values(orderBy).find(v => ![true, false].includes(<any>v))) {
-    return keys.map(key => ({ key, asc: Boolean(orderBy[key]) }))
+  if (!Object.values(orderBy).find((v) => ![true, false].includes(<any>v))) {
+    return keys.map((key) => ({ key, asc: Boolean(orderBy[key]) }));
 
     /* { key2: -1, key1: 1 } */
-  } else if (!Object.values(orderBy).find(v => ![-1, 1].includes(<any>v))) {
-    return keys.map(key => ({ key, asc: orderBy[key] === 1 }))
+  } else if (!Object.values(orderBy).find((v) => ![-1, 1].includes(<any>v))) {
+    return keys.map((key) => ({ key, asc: orderBy[key] === 1 }));
 
     /* { key2: "asc", key1: "desc" } */
-  } else if (!Object.values(orderBy).find(v => !["asc", "desc"].includes(<any>v))) {
-    return keys.map(key => ({ key, asc: orderBy[key] === "asc" }))
+  } else if (
+    !Object.values(orderBy).find((v) => !["asc", "desc"].includes(<any>v))
+  ) {
+    return keys.map((key) => ({ key, asc: orderBy[key] === "asc" }));
   } else return throwErr(orderBy);
-};
+};