prostgles-server 4.2.187 → 4.2.189

package/lib/DboBuilder/ViewHandler/find.ts

@@ -21,13 +21,11 @@ export const find = async function (
   selectParams?: SelectParams,
   _?: undefined,
   tableRules?: TableRule,
-  localParams?: LocalParams,
+  localParams?: LocalParams
 ): Promise<any[]> {
   const start = Date.now();
   const command =
-    selectParams?.limit === 1 && selectParams?.returnType === "row"
-      ? "findOne"
-      : "find";
+    selectParams?.limit === 1 && selectParams.returnType === "row" ? "findOne" : "find";
   try {
     filter = filter || {};
     const allowedReturnTypes = Object.keys({
@@ -59,9 +57,9 @@ export const find = async function (
       } satisfies Record<keyof SelectParams, 1>);
 
       const invalidParams = Object.keys(selectParams).filter(
-        (k) => !validParamNames.includes(k as any),
+        (k) => !validParamNames.includes(k as any)
       );
-      if (invalidParams && invalidParams.length)
+      if (invalidParams.length)
         throw (
           "Invalid params: " +
           invalidParams.join(", ") +
@@ -88,53 +86,53 @@ export const find = async function (
       }
       if (maxLimit && !Number.isInteger(maxLimit)) {
         throw (
-          ` invalid publish.${this.name}.select.maxLimit -> expecting integer but got ` +
-          maxLimit
+          ` invalid publish.${this.name}.select.maxLimit -> expecting integer but got ` + maxLimit
         );
       }
     }
 
     const _selectParams = selectParams ?? {};
     const selectParamsLimitCheck =
-      localParams?.bypassLimit && !Number.isFinite(_selectParams.limit)
-        ? { ..._selectParams, limit: null }
-        : { limit: 1000, ..._selectParams };
+      localParams?.bypassLimit && !Number.isFinite(_selectParams.limit) ?
+        { ..._selectParams, limit: null }
+      : { limit: 1000, ..._selectParams };
     const newQuery = await getNewQuery(
       this,
       filter,
       selectParamsLimitCheck,
       _,
       tableRules,
-      localParams,
+      localParams
     );
 
     const queryWithoutRLS = getSelectQuery(
       this,
       newQuery,
       undefined,
-      !!selectParamsLimitCheck?.groupBy,
+      !!selectParamsLimitCheck.groupBy
     );
 
     const queryWithRLS = withUserRLS(localParams, queryWithoutRLS);
-    if (testRule) {
-      try {
-        await this.db.any(withUserRLS(localParams, "EXPLAIN " + queryWithRLS));
-        return [];
-      } catch (e) {
-        console.error(e);
-        throw `Internal error: publish config is not valid for publish.${this.name}.select `;
-      }
-    }
+    // THIS HANGS TESTS
+    // if (testRule) {
+    //   try {
+    //     await this.db.any(withUserRLS(localParams, "EXPLAIN " + queryWithRLS));
+    //     return [];
+    //   } catch (e) {
+    //     console.error(e);
+    //     throw `Internal error: publish config is not valid for publish.${this.name}.select `;
+    //   }
+    // }
 
     /** Used for subscribe  */
     if (localParams?.returnNewQuery) return newQuery as unknown as any;
     if (localParams?.returnQuery) {
-      if (localParams?.returnQuery === "where-condition") {
+      if (localParams.returnQuery === "where-condition") {
         return newQuery.whereOpts.condition as any;
       }
-      return (localParams?.returnQuery === "noRLS"
-        ? queryWithoutRLS
-        : queryWithRLS) as unknown as any[];
+      return (localParams.returnQuery === "noRLS" ?
+        queryWithoutRLS
+      : queryWithRLS) as unknown as any[];
     }
 
     const result = await runQueryReturnType({
@@ -187,11 +185,7 @@ export const runQueryReturnType = async ({
   returnType,
 }: RunQueryReturnTypeArgs) => {
   const query = queryWithRLS;
-  const sqlTypes = [
-    "statement",
-    "statement-no-rls",
-    "statement-where",
-  ] as const;
+  const sqlTypes = ["statement", "statement-no-rls", "statement-where"] as const;
   if (!returnType || returnType === "values") {
     return handler.dbHandler
       .any(query)
@@ -206,7 +200,7 @@ export const runQueryReturnType = async ({
           type: "tableMethod",
           localParams,
           view: handler,
-        }),
+        })
       );
   } else if (sqlTypes.some((v) => v === returnType)) {
     if (!(await canRunSQL(handler.dboBuilder.prostgles, localParams))) {
@@ -216,8 +210,7 @@ export const runQueryReturnType = async ({
       return queryWithoutRLS as any;
     }
     if (returnType === "statement-where") {
-      if (!newQuery)
-        throw `returnType ${returnType} not possible for this command type`;
+      if (!newQuery) throw `returnType ${returnType} not possible for this command type`;
       return newQuery.whereOpts.condition as any;
     }
     return query as unknown as any[];
@@ -232,7 +225,7 @@ export const runQueryReturnType = async ({
           type: "tableMethod",
           localParams,
           view: handler,
-        }),
+        })
       );
   }
 };

package/lib/DboBuilder/ViewHandler/getExistsCondition.ts

@@ -1,10 +1,4 @@
-import {
-  AnyObject,
-  EXISTS_KEY,
-  EXISTS_KEYS,
-  FieldFilter,
-  asName,
-} from "prostgles-types";
+import { AnyObject, EXISTS_KEY, EXISTS_KEYS, FieldFilter, asName } from "prostgles-types";
 import { LocalParams, ExistsFilterConfig } from "../DboBuilder";
 import { ViewHandler } from "./ViewHandler";
 import { TableRule } from "../../PublishParser/PublishParser";
@@ -14,22 +8,15 @@ import { getTableJoinQuery } from "./getTableJoinQuery";
 export async function getExistsCondition(
   this: ViewHandler,
   eConfig: ExistsFilterConfig,
-  localParams: LocalParams | undefined,
+  localParams: LocalParams | undefined
 ): Promise<string> {
   const thisTable = this.name;
-  const isNotExists = ["$notExists", "$notExistsJoined"].includes(
-    eConfig.existType,
-  );
+  const isNotExists = ["$notExists", "$notExistsJoined"].includes(eConfig.existType);
 
   const { targetTableFilter } = eConfig;
 
   /* Nested $exists is not allowed */
-  if (
-    targetTableFilter &&
-    Object.keys(targetTableFilter).find((fk) =>
-      EXISTS_KEYS.includes(fk as EXISTS_KEY),
-    )
-  ) {
+  if (Object.keys(targetTableFilter).find((fk) => EXISTS_KEYS.includes(fk as EXISTS_KEY))) {
     throw {
       stack: ["prepareExistCondition()"],
       message: "Nested exists dissallowed",
@@ -42,25 +29,16 @@ export async function getExistsCondition(
     tableAlias;
 
   /* Check if allowed to view data - forcedFilters will bypass this check through isForcedFilterBypass */
-  if (
-    localParams?.isRemoteRequest &&
-    !localParams?.socket &&
-    !localParams?.httpReq
-  ) {
+  if (localParams?.isRemoteRequest && !localParams.socket && !localParams.httpReq) {
     throw "Unexpected: localParams isRemoteRequest and missing socket/httpReq: ";
   }
-  const targetTable = eConfig.isJoined
-    ? eConfig.parsedPath.at(-1)!.table
-    : eConfig.targetTable;
-  if (
-    (localParams?.socket || localParams?.httpReq) &&
-    this.dboBuilder.publishParser
-  ) {
+  const targetTable = eConfig.isJoined ? eConfig.parsedPath.at(-1)!.table : eConfig.targetTable;
+  if ((localParams?.socket || localParams?.httpReq) && this.dboBuilder.publishParser) {
     t2Rules = (await this.dboBuilder.publishParser.getValidatedRequestRuleWusr({
       tableName: targetTable,
       command: "find",
       localParams,
-    })) as TableRule;
+    })) as TableRule | undefined;
 
     if (!t2Rules || !t2Rules.select) throw "Dissallowed";
     ({ forcedFilter, filterFields } = t2Rules.select);

package/lib/DboBuilder/ViewHandler/getInfo.ts

@@ -23,7 +23,7 @@ export async function getInfo(
     throw "Not allowed";
   }
 
-  const fileTableName = this.dboBuilder.prostgles?.opts?.fileTable?.tableName;
+  const fileTableName = this.dboBuilder.prostgles.opts.fileTable?.tableName;
 
   await this._log({
     command: "getInfo",
@@ -37,7 +37,7 @@ export async function getInfo(
   return {
     oid: this.tableOrViewInfo.oid,
     comment: this.tableOrViewInfo.comment,
-    info: this.dboBuilder.prostgles?.tableConfigurator?.getTableInfo({
+    info: this.dboBuilder.prostgles.tableConfigurator?.getTableInfo({
       tableName: this.name,
       lang,
     }),

package/lib/DboBuilder/ViewHandler/getTableJoinQuery.ts

@@ -23,11 +23,9 @@ export const getTableJoinQuery = ({
 
   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 prevTableAlias = i === 0 ? rootTableAlias : getTableAlias(path[i - 1]!.table, i - 1);
 
       const onCondition = getJoinOnCondition({
         on,
@@ -46,41 +44,27 @@ export const getTableJoinQuery = ({
        * 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),
-            })})`
-          : "";
+        isLast && isExists ?
+          `WHERE (${getJoinOnCondition({
+            on: firstPath.on,
+            leftAlias: rootTableAlias,
+            rightAlias: getTableAlias(firstPath.table, 0),
+          })})`
+        : "";
 
       const tableSelect =
-        isExists && isLast
-          ? [
-              `(`,
-              ` SELECT *`,
-              ` FROM ${tableName}`,
-              finalWhere ? `  WHERE ${finalWhere}` : "",
-              `)`,
-            ]
-              .filter((v) => v)
-              .join("\n")
-          : tableName;
+        isExists && isLast ?
+          [`(`, ` SELECT *`, ` FROM ${tableName}`, finalWhere ? `  WHERE ${finalWhere}` : "", `)`]
+            .filter((v) => v)
+            .join("\n")
+        : tableName;
       if (isExists && isFirst) {
-        return [
-          `SELECT 1`,
-          `FROM ${tableSelect} ${tableAlias}`,
-          whereJoinCondition,
-        ]
+        return [`SELECT 1`, `FROM ${tableSelect} ${tableAlias}`, whereJoinCondition]
           .filter((v) => v)
           .join("\n");
       }
 
-      return [
-        `${keyword} ${tableSelect} ${tableAlias}`,
-        ` ON ${onCondition}`,
-        whereJoinCondition,
-      ]
+      return [`${keyword} ${tableSelect} ${tableAlias}`, ` ON ${onCondition}`, whereJoinCondition]
         .filter((v) => v)
         .join("\n");
     })
@@ -112,7 +96,7 @@ export const getJoinOnCondition = ({
         .map(([leftCol, rightCol]) => {
           return `${leftAlias}.${getLeftColName(leftCol)} = ${rightAlias}.${getRightColName(rightCol)}`;
         })
-        .join(" AND "),
+        .join(" AND ")
     )
     .join(" OR ");
 };

package/lib/DboBuilder/ViewHandler/parseFieldFilter.ts

@@ -9,10 +9,8 @@ import { isPlainObject } from "../DboBuilder";
 export const parseFieldFilter = <AllowedKeys extends string[]>(
   fieldParams: FieldFilter<Record<AllowedKeys[number], any>> = "*",
   allow_empty = true,
-  all_cols: AllowedKeys,
+  all_cols: AllowedKeys
 ): AllowedKeys | [""] => {
-  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);
 
@@ -25,15 +23,12 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
     }
 
     /* string[] */
-    if (
-      Array.isArray(fieldParams) &&
-      !fieldParams.find((f) => typeof f !== "string")
-    ) {
+    if (Array.isArray(fieldParams) && !fieldParams.find((f) => typeof f !== "string")) {
       /* 
           ["*"] 
       */
       if (fieldParams[0] === "*") {
-        return all_fields.slice(0) as typeof all_fields;
+        return all_cols.slice(0) as typeof all_cols;
 
         /* 
             [""] 
@@ -57,13 +52,13 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
       */
     } else if (isPlainObject(fieldParams)) {
       if (!getKeys(fieldParams).length) {
-        return [] as unknown as typeof all_fields; //all_fields.slice(0) as typeof all_fields;
+        return [] as unknown as typeof all_cols; //all_fields.slice(0) as typeof all_fields;
       }
 
       const keys = getKeys(
         fieldParams as {
           [key: string]: boolean | 0 | 1;
-        },
+        }
       ) as AllowedKeys;
       if (keys[0] === "") {
         if (allow_empty) {
@@ -84,10 +79,8 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
       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;
+      if (disallowed.length) {
+        return all_cols.filter((col) => !disallowed.includes(col)) as typeof all_cols;
       } else {
         return [...allowed] as any;
       }
@@ -103,8 +96,8 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
   return colNames as any;
 
   function validate(cols: AllowedKeys) {
-    const bad_keys = cols.filter((col) => !all_fields.includes(col));
-    if (bad_keys && bad_keys.length) {
+    const bad_keys = cols.filter((col) => !all_cols.includes(col));
+    if (bad_keys.length) {
       throw "\nUnrecognised or illegal fields: " + bad_keys.join(", ");
     }
   }

package/lib/DboBuilder/ViewHandler/parseJoinPath.ts

@@ -61,9 +61,7 @@ export const parseJoinPath = ({
     }
   });
 
-  const missingPath = result.find(
-    (r) => !r.on.length || r.on.some((v) => !Object.keys(v).length),
-  );
+  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}`;
   }
@@ -86,7 +84,7 @@ function getJoins(
   viewHandler: ViewHandler,
   source: string,
   path: JoinPath[],
-  { allowMultiOrJoin = true, getShortestJoin }: Opts = {},
+  { allowMultiOrJoin = true, getShortestJoin }: Opts = {}
 ): JoinInfo {
   const [lastItem] = path;
   if (!lastItem) {
@@ -102,13 +100,11 @@ function getJoins(
 
   /* 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),
+      c.references?.some(({ ftable }) => ftable === viewHandler.name)
     );
     if (!fcols.length) {
       throw `There is no self-join foreign key relationship for table ${JSON.stringify(target)}`;
@@ -116,9 +112,7 @@ function getJoins(
     let allOnJoins: [string, string][][] = [];
     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);
       });
     });
@@ -126,7 +120,7 @@ function getJoins(
       ...allOnJoins,
       /** Reverse as well */
       ...allOnJoins.map((constraint) =>
-        constraint.map(([left, right]) => [right, left] as [string, string]),
+        constraint.map(([left, right]) => [right, left] as [string, string])
       ),
     ];
     return {
@@ -137,7 +131,7 @@ function getJoins(
           table: target,
           on: getValidOn(
             lastItem.on,
-            allOnJoins.map((v) => Object.fromEntries(v)),
+            allOnJoins.map((v) => Object.fromEntries(v))
           ),
         },
       ],
@@ -146,28 +140,27 @@ function getJoins(
   }
 
   /* 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
+  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;
+    : (
+      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;
@@ -183,11 +176,9 @@ function getJoins(
     const prevTable = arr[i - 1]!;
     const t1 = i === 0 ? source : prevTable.table;
 
-    viewHandler.joins ??= viewHandler.dboBuilder.joins;
-
     /* Get join options */
     const join = viewHandler.joins.find(
-      (j) => j.tables.includes(t1) && j.tables.includes(tablePath.table),
+      (j) => j.tables.includes(t1) && j.tables.includes(tablePath.table)
     );
     if (!join) {
       throw `Joining ${t1} <-> ${tablePath} dissallowed or missing`;
@@ -226,10 +217,7 @@ function getJoins(
   };
 }
 
-const getValidOn = (
-  requested: JoinPath["on"],
-  possible: ParsedJoinPath["on"],
-) => {
+const getValidOn = (requested: JoinPath["on"], possible: ParsedJoinPath["on"]) => {
   if (!requested) {
     return possible.map((v) => Object.entries(v));
   }
@@ -238,7 +226,7 @@ const getValidOn = (
   }
   const isValid = requested.every((requestedConstraint) => {
     return possible.some((possibleConstraint) =>
-      conditionsMatch(possibleConstraint, requestedConstraint),
+      conditionsMatch(possibleConstraint, requestedConstraint)
     );
   });
 
@@ -249,14 +237,8 @@ const getValidOn = (
   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]);
 };