prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/ViewHandler/getTableJoinQuery.ts

@@ -6,79 +6,113 @@ type getTableJoinsArgs = {
   type: "INNER" | "LEFT" | "EXISTS";
   finalWhere?: string;
   path: ParsedJoinPath[];
-}
-export const getTableJoinQuery = ({ path, type, rootTableAlias, finalWhere }: getTableJoinsArgs): { targetAlias: string; query: string } => {
-
+};
+export const getTableJoinQuery = ({
+  path,
+  type,
+  rootTableAlias,
+  finalWhere,
+}: getTableJoinsArgs): { targetAlias: string; query: string } => {
   const [firstPath] = path;
-  if(!firstPath){
+  if (!firstPath) {
     throw `Cannot create join query for empty path`;
   }
   const aliasSufix = "jd";
-  const getTableAlias = (table: string, pathIndex: number) => asName(`${aliasSufix}_${pathIndex}_${table}`);
-
-  const query = path.map(({ table, on }, i) => {
-    if(!on) throw "on missing";
-    const tableName = table;
-    const tableAlias = getTableAlias(table, i);
-    const prevTableAlias = i === 0? rootTableAlias : getTableAlias(path[i-1]!.table, i-1);
+  const getTableAlias = (table: string, pathIndex: number) =>
+    asName(`${aliasSufix}_${pathIndex}_${table}`);
 
-    const onCondition = getJoinOnCondition({ on, leftAlias: prevTableAlias, rightAlias: tableAlias });
+  const query = path
+    .map(({ table, on }, i) => {
+      if (!on) throw "on missing";
+      const tableName = table;
+      const tableAlias = getTableAlias(table, i);
+      const prevTableAlias =
+        i === 0 ? rootTableAlias : getTableAlias(path[i - 1]!.table, i - 1);
 
-    const isExists = type === "EXISTS"
-    const joinType = isExists? "INNER" : type;
-    const keyword = `${joinType} JOIN`;
-    const isLast = i === path.length - 1;
-    const isFirst = !i;
+      const onCondition = getJoinOnCondition({
+        on,
+        leftAlias: prevTableAlias,
+        rightAlias: tableAlias,
+      });
 
-    /**
-     * rootTable joins to first path
-     * first path joins to target table through inner joins
-     */
-    const whereJoinCondition = (isLast && isExists) ? 
-      `WHERE (${getJoinOnCondition({
-      on: firstPath.on, 
-      leftAlias: rootTableAlias, 
-      rightAlias: getTableAlias(firstPath.table, 0)
-    })})` : "";
+      const isExists = type === "EXISTS";
+      const joinType = isExists ? "INNER" : type;
+      const keyword = `${joinType} JOIN`;
+      const isLast = i === path.length - 1;
+      const isFirst = !i;
 
-    const tableSelect = (isExists && isLast)? [
-      `(`, 
-      ` SELECT *`,
-      ` FROM ${tableName}`,
-      (finalWhere? `  WHERE ${finalWhere}` : ""),
-      `)`
-    ].filter(v=>v).join("\n") : tableName;
-    if(isExists && isFirst){
-      return [
-        `SELECT 1`,
-        `FROM ${tableSelect} ${tableAlias}`,
-        whereJoinCondition
-      ].filter(v=>v).join("\n");
-    }
+      /**
+       * rootTable joins to first path
+       * first path joins to target table through inner joins
+       */
+      const whereJoinCondition =
+        isLast && isExists
+          ? `WHERE (${getJoinOnCondition({
+              on: firstPath.on,
+              leftAlias: rootTableAlias,
+              rightAlias: getTableAlias(firstPath.table, 0),
+            })})`
+          : "";
 
-    return [
-      `${keyword} ${tableSelect} ${tableAlias}`,
-      ` ON ${onCondition}`,
-      whereJoinCondition
-    ].filter(v=>v).join("\n");
+      const tableSelect =
+        isExists && isLast
+          ? [
+              `(`,
+              ` SELECT *`,
+              ` FROM ${tableName}`,
+              finalWhere ? `  WHERE ${finalWhere}` : "",
+              `)`,
+            ]
+              .filter((v) => v)
+              .join("\n")
+          : tableName;
+      if (isExists && isFirst) {
+        return [
+          `SELECT 1`,
+          `FROM ${tableSelect} ${tableAlias}`,
+          whereJoinCondition,
+        ]
+          .filter((v) => v)
+          .join("\n");
+      }
 
-  }).join("\n");
+      return [
+        `${keyword} ${tableSelect} ${tableAlias}`,
+        ` ON ${onCondition}`,
+        whereJoinCondition,
+      ]
+        .filter((v) => v)
+        .join("\n");
+    })
+    .join("\n");
 
   return {
     query,
-    targetAlias: getTableAlias(path.at(-1)!.table, path.length - 1)
-  }
-}
+    targetAlias: getTableAlias(path.at(-1)!.table, path.length - 1),
+  };
+};
 
 type GetJoinOnConditionArgs = {
   on: Record<string, string>[];
-  leftAlias: string; 
+  leftAlias: string;
   rightAlias: string;
   getLeftColName?: (col: string) => string;
   getRightColName?: (col: string) => string;
-}
-export const getJoinOnCondition = ({ on, leftAlias, rightAlias, getLeftColName = asName, getRightColName = asName }: GetJoinOnConditionArgs ) => {
-  return on.map(constraint => Object.entries(constraint).map(([leftCol, rightCol]) => {
-    return `${leftAlias}.${getLeftColName(leftCol)} = ${rightAlias}.${getRightColName(rightCol)}`;
-  }).join(" AND ")).join(" OR ")
-}
+};
+export const getJoinOnCondition = ({
+  on,
+  leftAlias,
+  rightAlias,
+  getLeftColName = asName,
+  getRightColName = asName,
+}: GetJoinOnConditionArgs) => {
+  return on
+    .map((constraint) =>
+      Object.entries(constraint)
+        .map(([leftCol, rightCol]) => {
+          return `${leftAlias}.${getLeftColName(leftCol)} = ${rightAlias}.${getRightColName(rightCol)}`;
+        })
+        .join(" AND "),
+    )
+    .join(" OR ");
+};

package/lib/DboBuilder/ViewHandler/parseComplexFilter.ts

@@ -1,5 +1,9 @@
 import { AnyObject, isObject } from "prostgles-types";
-import { FILTER_OPERANDS, FILTER_OPERAND_TO_SQL_OPERAND, parseFilterRightValue } from "../../Filtering";
+import {
+  FILTER_OPERANDS,
+  FILTER_OPERAND_TO_SQL_OPERAND,
+  parseFilterRightValue,
+} from "../../Filtering";
 import { FUNCTIONS, parseFunction } from "../QueryBuilder/Functions";
 import { asNameAlias, parseFunctionObject } from "../QueryBuilder/QueryBuilder";
 import { TableSchemaColumn } from "../DboBuilderTypes";
@@ -12,7 +16,7 @@ type Args = {
   tableAlias: string | undefined;
   allowed_colnames: string[];
   columns: TableSchemaColumn[];
-}
+};
 
 /* Parse complex filters
   { 
@@ -30,67 +34,85 @@ export const parseComplexFilter = ({
   allowed_colnames,
   columns,
 }: Args) => {
-
   /**
    * { $funcName: [arg1, arg2] }
    * { $column: "column_name" }
    */
   const getFuncQuery = (funcData: AnyObject): string => {
-    if(isObject(funcData) && "$column" in funcData){
-      const column = funcData["$column"]
-      if(typeof column !== "string"){
+    if (isObject(funcData) && "$column" in funcData) {
+      const column = funcData["$column"];
+      if (typeof column !== "string") {
         throw `expecting: \n  { $column: "column_name" } received:\n ${JSON.stringify(funcData)}`;
       }
-      if(!allowed_colnames.includes(column)){
+      if (!allowed_colnames.includes(column)) {
         throw `Dissallowed or Invalid column ${column}. Allowed columns: ${allowed_colnames}`;
       }
-      return asNameAlias(column, tableAlias)
+      return asNameAlias(column, tableAlias);
     }
     const { funcName, args } = parseFunctionObject(funcData);
-    const funcDef = parseFunction({ func: funcName, args, functions: FUNCTIONS, allowedFields: allowed_colnames });
-    return funcDef.getQuery({ args, tableAlias, allColumns: columns, allowedFields: allowed_colnames });
-  }
+    const funcDef = parseFunction({
+      func: funcName,
+      args,
+      functions: FUNCTIONS,
+      allowedFields: allowed_colnames,
+    });
+    return funcDef.getQuery({
+      args,
+      tableAlias,
+      allColumns: columns,
+      allowedFields: allowed_colnames,
+    });
+  };
 
   const complexFilter = filter[complexFilterKey];
   if (!Array.isArray(complexFilter)) {
-    throw `Invalid $filter. Must contain an array of at least element but got: ${JSON.stringify(complexFilter)} `
-  } 
+    throw `Invalid $filter. Must contain an array of at least element but got: ${JSON.stringify(complexFilter)} `;
+  }
   const [leftFilter, comparator, rightFilterOrValue] = complexFilter;
 
   const leftVal = getFuncQuery(leftFilter);
   let result = leftVal;
   if (comparator) {
-    if (typeof comparator !== "string" || !allowedComparators.includes(comparator as any)) {
+    if (
+      typeof comparator !== "string" ||
+      !allowedComparators.includes(comparator as any)
+    ) {
       throw `Invalid $filter. comparator ${JSON.stringify(comparator)} is not valid. Expecting one of: ${allowedComparators}`;
     }
     if (!rightFilterOrValue) {
       throw "Invalid $filter. Expecting a value or function after the comparator";
     }
-    const maybeValidComparator = comparator as keyof typeof FILTER_OPERAND_TO_SQL_OPERAND;
+    const maybeValidComparator =
+      comparator as keyof typeof FILTER_OPERAND_TO_SQL_OPERAND;
     const sqlOperand = FILTER_OPERAND_TO_SQL_OPERAND[maybeValidComparator];
-    if(!sqlOperand){
+    if (!sqlOperand) {
       throw `Invalid $filter. comparator ${comparator} is not valid. Expecting one of: ${allowedComparators}`;
     }
 
-    let rightVal = isObject(rightFilterOrValue) ? 
-      getFuncQuery(rightFilterOrValue) : 
-      parseFilterRightValue(rightFilterOrValue, {
-        selectItem: undefined, 
-        expect: ["$in", "$nin"].includes(comparator)? "csv" : undefined 
-      });
-    if(maybeValidComparator === "$between" || maybeValidComparator === "$notBetween"){
-      
-      if(!Array.isArray(rightVal) || rightVal.length !== 2){
+    let rightVal = isObject(rightFilterOrValue)
+      ? getFuncQuery(rightFilterOrValue)
+      : parseFilterRightValue(rightFilterOrValue, {
+          selectItem: undefined,
+          expect: ["$in", "$nin"].includes(comparator) ? "csv" : undefined,
+        });
+    if (
+      maybeValidComparator === "$between" ||
+      maybeValidComparator === "$notBetween"
+    ) {
+      if (!Array.isArray(rightVal) || rightVal.length !== 2) {
         throw "Between filter expects an array of two values";
       }
       rightVal = asValue(rightVal[0]) + " AND " + asValue(rightVal[1]);
     }
-    if (leftVal === rightVal){ 
-      throw "Invalid $filter. Cannot compare two identical function signatures: " + JSON.stringify(leftFilter);
+    if (leftVal === rightVal) {
+      throw (
+        "Invalid $filter. Cannot compare two identical function signatures: " +
+        JSON.stringify(leftFilter)
+      );
     }
-      
+
     result += ` ${sqlOperand} ${rightVal}`;
   }
 
   return result;
-}
+};

package/lib/DboBuilder/ViewHandler/parseFieldFilter.ts

@@ -1,33 +1,34 @@
 import { FieldFilter, getKeys } from "prostgles-types";
 import { isPlainObject } from "../DboBuilder";
 
-/** 
-* Filter string array
-* @param {FieldFilter} fieldParams - { col1: 0, col2: 0 } | { col1: true, col2: true } | "*" | ["key1", "key2"] | []
-* @param {boolean} allow_empty - allow empty select. defaults to true
-*/
+/**
+ * Filter string array
+ * @param {FieldFilter} fieldParams - { col1: 0, col2: 0 } | { col1: true, col2: true } | "*" | ["key1", "key2"] | []
+ * @param {boolean} allow_empty - allow empty select. defaults to true
+ */
 export const parseFieldFilter = <AllowedKeys extends string[]>(
-  fieldParams: FieldFilter<Record<AllowedKeys[number], any>> = "*", 
-  allow_empty = true, 
-  all_cols: AllowedKeys
+  fieldParams: FieldFilter<Record<AllowedKeys[number], any>> = "*",
+  allow_empty = true,
+  all_cols: AllowedKeys,
 ): AllowedKeys | [""] => {
-  
-  if (!all_cols) throw "all_cols missing"
-  const all_fields = all_cols;// || this.column_names.slice(0);
+  if (!all_cols) throw "all_cols missing";
+  const all_fields = all_cols; // || this.column_names.slice(0);
   let colNames: AllowedKeys = [] as any;
   const initialParams = JSON.stringify(fieldParams);
 
   if (fieldParams) {
-
     /* 
         "field1, field2, field4" | "*"
     */
     if (typeof fieldParams === "string") {
-      fieldParams = fieldParams.split(",").map(k => k.trim());
+      fieldParams = fieldParams.split(",").map((k) => k.trim());
     }
 
     /* string[] */
-    if (Array.isArray(fieldParams) && !fieldParams.find(f => typeof f !== "string")) {
+    if (
+      Array.isArray(fieldParams) &&
+      !fieldParams.find((f) => typeof f !== "string")
+    ) {
       /* 
           ["*"] 
       */
@@ -55,14 +56,15 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
           { field1: false, field2: false } = all fields except field1 and field2
       */
     } else if (isPlainObject(fieldParams)) {
-
       if (!getKeys(fieldParams).length) {
         return [] as unknown as typeof all_fields; //all_fields.slice(0) as typeof all_fields;
       }
 
-      const keys = getKeys(fieldParams as {
-        [key: string]: boolean | 0 | 1;
-      }) as AllowedKeys;
+      const keys = getKeys(
+        fieldParams as {
+          [key: string]: boolean | 0 | 1;
+        },
+      ) as AllowedKeys;
       if (keys[0] === "") {
         if (allow_empty) {
           return [""];
@@ -73,23 +75,27 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
 
       validate(keys);
 
-      keys.forEach(key => {
+      keys.forEach((key) => {
         const allowedVals = [true, false, 0, 1];
-        if (!allowedVals.includes((fieldParams as any)[key])) throw `Invalid field selection value for: { ${key}: ${(fieldParams as any)[key]} }. \n Allowed values: ${allowedVals.join(" OR ")}`
-      })
-
-      const allowed = keys.filter(key => (fieldParams as any)[key]),
-        disallowed = keys.filter(key => !(fieldParams as any)[key]);
+        if (!allowedVals.includes((fieldParams as any)[key]))
+          throw `Invalid field selection value for: { ${key}: ${(fieldParams as any)[key]} }. \n Allowed values: ${allowedVals.join(" OR ")}`;
+      });
 
+      const allowed = keys.filter((key) => (fieldParams as any)[key]),
+        disallowed = keys.filter((key) => !(fieldParams as any)[key]);
 
       if (disallowed && disallowed.length) {
-        return all_fields.filter(col => !disallowed.includes(col)) as typeof all_fields;
+        return all_fields.filter(
+          (col) => !disallowed.includes(col),
+        ) as typeof all_fields;
       } else {
         return [...allowed] as any;
       }
-
     } else {
-      throw " Unrecognised field filter.\nExpecting any of:   string | string[] | { [field]: boolean } \n Received ->  " + initialParams;
+      throw (
+        " Unrecognised field filter.\nExpecting any of:   string | string[] | { [field]: boolean } \n Received ->  " +
+        initialParams
+      );
     }
 
     validate(colNames);
@@ -97,9 +103,9 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
   return colNames as any;
 
   function validate(cols: AllowedKeys) {
-    const bad_keys = cols.filter(col => !all_fields.includes(col));
+    const bad_keys = cols.filter((col) => !all_fields.includes(col));
     if (bad_keys && bad_keys.length) {
       throw "\nUnrecognised or illegal fields: " + bad_keys.join(", ");
     }
   }
-}
+};