prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/parseUpdateRules.ts

@@ -1,6 +1,16 @@
-import { AnyObject, FieldFilter, isDefined, UpdateParams } from "prostgles-types";
+import {
+  AnyObject,
+  FieldFilter,
+  isDefined,
+  UpdateParams,
+} from "prostgles-types";
 import { Filter, LocalParams } from "./DboBuilder";
-import { TableRule, UpdateRule, ValidateRowBasic, ValidateUpdateRowBasic } from "../PublishParser/PublishParser";
+import {
+  TableRule,
+  UpdateRule,
+  ValidateRowBasic,
+  ValidateUpdateRowBasic,
+} from "../PublishParser/PublishParser";
 import { TableHandler } from "./TableHandler/TableHandler";
 import { prepareNewData } from "./TableHandler/DataValidator";
 
@@ -13,7 +23,7 @@ export async function parseUpdateRules(
   filter: Filter,
   params?: UpdateParams,
   tableRules?: TableRule,
-  localParams?: LocalParams
+  localParams?: LocalParams,
 ): Promise<{
   fields: string[];
   validateRow?: ValidateRowBasic;
@@ -39,25 +49,29 @@ export async function parseUpdateRules(
 
   if (tableRules) {
     if (!tableRules.update) throw "update rules missing for " + this.name;
-    ({ forcedFilter, forcedData, fields, filterFields, validate } = tableRules.update);
+    ({ forcedFilter, forcedData, fields, filterFields, validate } =
+      tableRules.update);
 
-    returningFields = tableRules.update.returningFields ?? tableRules?.select?.fields ?? "";
+    returningFields =
+      tableRules.update.returningFields ?? tableRules?.select?.fields ?? "";
 
     if (!returningFields && params?.returning) {
-      throw "You are not allowed to return any fields from the update"
+      throw "You are not allowed to return any fields from the update";
     }
 
     if (!fields) {
       throw ` Invalid update rule fo r ${this.name}. fields missing `;
     }
-    finalUpdateFilter = (await this.prepareWhere({ 
-      select: undefined,
-      filter, 
-      forcedFilter, 
-      filterFields, 
-      localParams, 
-      tableRule: tableRules 
-    })).filter;
+    finalUpdateFilter = (
+      await this.prepareWhere({
+        select: undefined,
+        filter,
+        forcedFilter,
+        filterFields,
+        localParams,
+        tableRule: tableRules,
+      })
+    ).filter;
     if (tableRules.update.dynamicFields?.length) {
       /**
        * dynamicFields.fields used to allow a custom list of fields for specific records
@@ -65,37 +79,48 @@ export async function parseUpdateRules(
        * updates must target records from a specific dynamicFields.filter or not match any dynamicFields.filter
        */
       if (testRule) {
-        for await (const [dfIndex, dfRule] of tableRules.update.dynamicFields.entries()) {
-
+        for await (const [
+          dfIndex,
+          dfRule,
+        ] of tableRules.update.dynamicFields.entries()) {
           /**
            * Validated filter and fields
            */
           const condition = await this.prepareWhere({
-            select: undefined, 
-            filterFields: this.column_names, 
-            filter: dfRule.filter, 
-            localParams, 
-            tableRule: tableRules 
+            select: undefined,
+            filterFields: this.column_names,
+            filter: dfRule.filter,
+            localParams,
+            tableRule: tableRules,
           });
           if (!condition.where) {
-            throw "dynamicFields.filter cannot be empty: " + JSON.stringify(dfRule);
+            throw (
+              "dynamicFields.filter cannot be empty: " + JSON.stringify(dfRule)
+            );
           }
-          await this.validateViewRules({ 
-            fields: dfRule.fields, 
-            filterFields, 
-            returningFields, 
-            forcedFilter, 
-            dynamicFields: tableRules.update.dynamicFields, 
-            rule: "update" 
+          await this.validateViewRules({
+            fields: dfRule.fields,
+            filterFields,
+            returningFields,
+            forcedFilter,
+            dynamicFields: tableRules.update.dynamicFields,
+            rule: "update",
           });
 
-
           await this.find(dfRule.filter, { limit: 0 });
 
           /** Ensure dynamicFields filters do not overlap */
-          for await (const [_dfIndex, _dfRule] of tableRules.update.dynamicFields.entries()) {
+          for await (const [
+            _dfIndex,
+            _dfRule,
+          ] of tableRules.update.dynamicFields.entries()) {
             if (dfIndex !== _dfIndex) {
-              if (await this.findOne({ $and: [dfRule.filter, _dfRule.filter] }, { select: "" })) {
+              if (
+                await this.findOne(
+                  { $and: [dfRule.filter, _dfRule.filter] },
+                  { select: "" },
+                )
+              ) {
                 throw `dynamicFields.filter cannot overlap each other. \n
                                 Overlapping dynamicFields rules:
                                     ${JSON.stringify(dfRule)} 
@@ -109,12 +134,17 @@ export async function parseUpdateRules(
       }
 
       /** Pick dynamicFields.fields if matching filter */
-      let matchedRule: Required<UpdateRule>["dynamicFields"][number] | undefined;
+      let matchedRule:
+        | Required<UpdateRule>["dynamicFields"][number]
+        | undefined;
       for await (const dfRule of tableRules.update.dynamicFields) {
-        const match = await this.findOne({ $and: ([finalUpdateFilter, dfRule.filter]  as AnyObject[]).filter(isDefined) });
+        const match = await this.findOne({
+          $and: ([finalUpdateFilter, dfRule.filter] as AnyObject[]).filter(
+            isDefined,
+          ),
+        });
 
         if (match) {
-
           /** Ensure it doesn't overlap with other dynamicFields.filter */
           if (matchedRule && !testRule) {
             throw "Your update is targeting multiple tableRules.update.dynamicFields. Restrict update filter to only target one rule";
@@ -128,37 +158,57 @@ export async function parseUpdateRules(
 
     /* Safely test publish rules */
     if (testRule) {
-      await this.validateViewRules({ fields, filterFields, returningFields, forcedFilter, dynamicFields: tableRules.update.dynamicFields, rule: "update" });
+      await this.validateViewRules({
+        fields,
+        filterFields,
+        returningFields,
+        forcedFilter,
+        dynamicFields: tableRules.update.dynamicFields,
+        rule: "update",
+      });
       if (forcedData) {
         try {
-          const { data, allowedCols } = await prepareNewData({ 
-            row: forcedData, 
-            forcedData: undefined, 
-            allowedFields: "*", 
-            tableRules, 
-            removeDisallowedFields: false, 
+          const { data, allowedCols } = await prepareNewData({
+            row: forcedData,
+            forcedData: undefined,
+            allowedFields: "*",
+            tableRules,
+            removeDisallowedFields: false,
             tableConfigurator: this.dboBuilder.prostgles.tableConfigurator,
             tableHandler: this,
           });
           let updateValidate: ValidateRowBasic | undefined;
-          if(validate){
-            if(!localParams) throw "localParams missing";
-            updateValidate = (args) => validate!({ update: args.row, filter: {}, dbx: this.getFinalDbo(localParams), localParams })
+          if (validate) {
+            if (!localParams) throw "localParams missing";
+            updateValidate = (args) =>
+              validate!({
+                update: args.row,
+                filter: {},
+                dbx: this.getFinalDbo(localParams),
+                localParams,
+              });
           }
-          const updateQ = (await this.dataValidator.parse({
-            command: "update",
-            rows: [data],
-            allowedCols,
-            dbTx: this.tx?.dbTX || this.dboBuilder.dbo,
-            validationOptions: { 
-              validate: updateValidate,
-              localParams,
-            }
-          })).getQuery();
+          const updateQ = (
+            await this.dataValidator.parse({
+              command: "update",
+              rows: [data],
+              allowedCols,
+              dbTx: this.tx?.dbTX || this.dboBuilder.dbo,
+              validationOptions: {
+                validate: updateValidate,
+                localParams,
+              },
+            })
+          ).getQuery();
           const query = updateQ + " WHERE FALSE ";
           await this.db.any("EXPLAIN " + query);
         } catch (e) {
-          throw " issue with forcedData: \nVALUE: " + JSON.stringify(forcedData, null, 2) + "\nERROR: " + e;
+          throw (
+            " issue with forcedData: \nVALUE: " +
+            JSON.stringify(forcedData, null, 2) +
+            "\nERROR: " +
+            e
+          );
         }
       }
 
@@ -170,9 +220,15 @@ export async function parseUpdateRules(
   const _fields = this.parseFieldFilter(fields);
 
   let validateRow: ValidateRowBasic | undefined;
-  if(validate){
-    if(!localParams) throw "localParams missing";
-    validateRow = ({ row }) => validate!({ update: row, filter: finalUpdateFilter, localParams, dbx: this.getFinalDbo(localParams) });
+  if (validate) {
+    if (!localParams) throw "localParams missing";
+    validateRow = ({ row }) =>
+      validate!({
+        update: row,
+        filter: finalUpdateFilter,
+        localParams,
+        dbx: this.getFinalDbo(localParams),
+      });
   }
 
   return {
@@ -183,5 +239,5 @@ export async function parseUpdateRules(
     forcedFilter,
     returningFields,
     filterFields,
-  }
-}
+  };
+}

package/lib/DboBuilder/prepareShortestJoinPaths.ts

@@ -8,34 +8,45 @@ type Result = {
   joinGraph?: Graph | undefined;
   joins: Join[];
   shortestJoinPaths: JoinPaths;
-}
-export async function prepareShortestJoinPaths(dboBuilder: DboBuilder): Promise<Result> {
-
+};
+export async function prepareShortestJoinPaths(
+  dboBuilder: DboBuilder,
+): Promise<Result> {
   if (dboBuilder.prostgles.opts.joins) {
-
     let joinConfig = await dboBuilder.prostgles.opts.joins;
     if (!dboBuilder.tablesOrViews) {
-      throw new Error("Could not create join config. this.tablesOrViews missing");
+      throw new Error(
+        "Could not create join config. this.tablesOrViews missing",
+      );
     }
 
     const inferredJoins = await getInferredJoins2(dboBuilder.tablesOrViews);
     if (joinConfig === "inferred") {
-      joinConfig = inferredJoins
+      joinConfig = inferredJoins;
       /* If joins are specified then include inferred joins except the explicit tables */
     } else if (Array.isArray(joinConfig)) {
-      const joinTables = joinConfig.map(j => j.tables).flat();
-      joinConfig = joinConfig.concat(inferredJoins.filter(j => !j.tables.find(t => joinTables.includes(t))))
+      const joinTables = joinConfig.map((j) => j.tables).flat();
+      joinConfig = joinConfig.concat(
+        inferredJoins.filter(
+          (j) => !j.tables.find((t) => joinTables.includes(t)),
+        ),
+      );
     } else if (joinConfig) {
-      throw new Error("Unexpected joins init param. Expecting 'inferred' OR joinConfig but got: " + JSON.stringify(joinConfig))
+      throw new Error(
+        "Unexpected joins init param. Expecting 'inferred' OR joinConfig but got: " +
+          JSON.stringify(joinConfig),
+      );
     }
     const joins = JSON.parse(JSON.stringify(joinConfig)) as Join[];
 
     // Validate joins
     try {
-      const tovNames = dboBuilder.tablesOrViews!.map(t => t.name);
+      const tovNames = dboBuilder.tablesOrViews!.map((t) => t.name);
 
       // 2 find incorrect tables
-      const missing = joins.flatMap(j => j.tables).find(t => !tovNames.includes(t));
+      const missing = joins
+        .flatMap((j) => j.tables)
+        .find((t) => !tovNames.includes(t));
       if (missing) {
         throw "Table not found: " + missing;
       }
@@ -44,34 +55,52 @@ export async function prepareShortestJoinPaths(dboBuilder: DboBuilder): Promise<
       joins.map(({ tables, on }) => {
         const t1 = tables[0],
           t2 = tables[1];
-        on.map(cond => {
-
+        on.map((cond) => {
           const f1s = Object.keys(cond),
             f2s = Object.values(cond);
-          [[t1, f1s], [t2, f2s]].map(v => {
+          [
+            [t1, f1s],
+            [t2, f2s],
+          ].map((v) => {
             const t = <string>v[0],
               f = <string[]>v[1];
 
-            const tov = dboBuilder.tablesOrViews!.find(_t => _t.name === t);
+            const tov = dboBuilder.tablesOrViews!.find((_t) => _t.name === t);
             if (!tov) throw "Table not found: " + t;
-            const m1 = f.filter(k => !tov!.columns.map(c => c.name).includes(k))
+            const m1 = f.filter(
+              (k) => !tov!.columns.map((c) => c.name).includes(k),
+            );
             if (m1 && m1.length) {
-              throw `Table ${t}(${tov.columns.map(c => c.name).join()}) has no fields named: ${m1.join()}`;
+              throw `Table ${t}(${tov.columns.map((c) => c.name).join()}) has no fields named: ${m1.join()}`;
             }
           });
-        })
+        });
       });
 
       // 4 find incorrect/missing join types
-      const expected_types = " \n\n-> Expecting: " + JOIN_TYPES.map(t => JSON.stringify(t)).join(` | `)
-      const mt = joins.find(j => !j.type);
-      if (mt) throw "Join type missing for: " + JSON.stringify(mt, null, 2) + expected_types;
-
-      const it = joins.find(j => !JOIN_TYPES.includes(j.type));
-      if (it) throw "Incorrect join type for: " + JSON.stringify(it, null, 2) + expected_types;
-
+      const expected_types =
+        " \n\n-> Expecting: " +
+        JOIN_TYPES.map((t) => JSON.stringify(t)).join(` | `);
+      const mt = joins.find((j) => !j.type);
+      if (mt)
+        throw (
+          "Join type missing for: " +
+          JSON.stringify(mt, null, 2) +
+          expected_types
+        );
+
+      const it = joins.find((j) => !JOIN_TYPES.includes(j.type));
+      if (it)
+        throw (
+          "Incorrect join type for: " +
+          JSON.stringify(it, null, 2) +
+          expected_types
+        );
     } catch (e) {
-      const errMsg = ((joinConfig as any) === "inferred"? "INFERRED " : "") + "JOINS VALIDATION ERROR \n-> " + e;
+      const errMsg =
+        ((joinConfig as any) === "inferred" ? "INFERRED " : "") +
+        "JOINS VALIDATION ERROR \n-> " +
+        e;
       throw errMsg;
     }
 
@@ -90,15 +119,14 @@ export async function prepareShortestJoinPaths(dboBuilder: DboBuilder): Promise<
       joinGraph![t2] ??= {};
       joinGraph![t2]![t1] = 1;
     });
-    const tables = Array.from(new Set(joins.flatMap(t => t.tables)));
+    const tables = Array.from(new Set(joins.flatMap((t) => t.tables)));
     const shortestJoinPaths: JoinPaths = [];
     tables.forEach((t1, i1) => {
       tables.forEach((t2, i2) => {
-
         /** Prevent recursion */
         if (
           t1 === t2 ||
-          shortestJoinPaths.some(jp => {
+          shortestJoinPaths.some((jp) => {
             if (arrayValuesMatch([jp.t1, jp.t2], [t1, t2])) {
               const spath = findShortestPath(joinGraph, t1, t2);
               if (spath && arrayValuesMatch(spath.path, jp.path)) {
@@ -113,20 +141,30 @@ export async function prepareShortestJoinPaths(dboBuilder: DboBuilder): Promise<
         const spath = findShortestPath(joinGraph, t1, t2);
         if (!(spath && spath.distance < Infinity)) return;
 
-        const existing1 = shortestJoinPaths.find(j => j.t1 === t1 && j.t2 === t2)
+        const existing1 = shortestJoinPaths.find(
+          (j) => j.t1 === t1 && j.t2 === t2,
+        );
         if (!existing1) {
           shortestJoinPaths.push({ t1, t2, path: spath.path.slice() });
         }
 
-        const existing2 = shortestJoinPaths.find(j => j.t2 === t1 && j.t1 === t2);
+        const existing2 = shortestJoinPaths.find(
+          (j) => j.t2 === t1 && j.t1 === t2,
+        );
         if (!existing2) {
-          shortestJoinPaths.push({ t1: t2, t2: t1, path: spath.path.slice().reverse() });
+          shortestJoinPaths.push({
+            t1: t2,
+            t2: t1,
+            path: spath.path.slice().reverse(),
+          });
         }
       });
     });
     return {
-      joins, shortestJoinPaths, joinGraph
-    }
+      joins,
+      shortestJoinPaths,
+      joinGraph,
+    };
   }
 
   return {
@@ -135,27 +173,40 @@ export async function prepareShortestJoinPaths(dboBuilder: DboBuilder): Promise<
   };
 }
 
-
 const arrayValuesMatch = <T>(arr1: T[], arr2: T[]): boolean => {
-  return arr1.slice().sort().join() === arr2.slice().sort().join()
-}
+  return arr1.slice().sort().join() === arr2.slice().sort().join();
+};
 
 async function getInferredJoins2(schema: TableSchema[]): Promise<Join[]> {
   const joins: Join[] = [];
-  const upsertJoin = (t1: string, t2: string, cols: { col1: string; col2: string }[], type: Join["type"]) => {
-    const existingIdx = joins.findIndex(j => arrayValuesMatch(j.tables.slice(0), [t1, t2]));
+  const upsertJoin = (
+    t1: string,
+    t2: string,
+    cols: { col1: string; col2: string }[],
+    type: Join["type"],
+  ) => {
+    const existingIdx = joins.findIndex((j) =>
+      arrayValuesMatch(j.tables.slice(0), [t1, t2]),
+    );
     const existing = joins[existingIdx];
     const normalCond = cols.reduce((a, v) => ({ ...a, [v.col1]: v.col2 }), {});
-    const revertedCond = cols.reduce((a, v) => ({ ...a, [v.col2]: v.col1 }), {});
+    const revertedCond = cols.reduce(
+      (a, v) => ({ ...a, [v.col2]: v.col1 }),
+      {},
+    );
     if (existing) {
-      const isLTR = existing.tables[0] === t1
+      const isLTR = existing.tables[0] === t1;
       const cond = isLTR ? normalCond : revertedCond;
 
       /** At some point we should add relationship type to EACH JOIN CONDITION GROUP */
       // const fixedType = isLTR? type : type.split("").reverse().join("") as Join["type"];
 
       /** Avoid duplicates */
-      if (!existing.on.some(_cond => JSON.stringify(_cond) === JSON.stringify(cond))) {
+      if (
+        !existing.on.some(
+          (_cond) => JSON.stringify(_cond) === JSON.stringify(cond),
+        )
+      ) {
         existing.on.push(cond);
         joins[existingIdx] = existing;
       }
@@ -163,24 +214,32 @@ async function getInferredJoins2(schema: TableSchema[]): Promise<Join[]> {
       joins.push({
         tables: [t1, t2],
         on: [normalCond],
-        type
-      })
+        type,
+      });
     }
-  }
-  schema.map(tov => {
-    tov.columns.map(col => {
+  };
+  schema.map((tov) => {
+    tov.columns.map((col) => {
       if (col.references) {
-        col.references.forEach(r => {
-          const joinCols = r.cols.map((c, i) => ({ col1: c, col2: r.fcols[i]! }));
+        col.references.forEach((r) => {
+          const joinCols = r.cols.map((c, i) => ({
+            col1: c,
+            col2: r.fcols[i]!,
+          }));
           let type: Join["type"] = "one-many";
-          const ftablePkeys = schema.find(_tov => _tov.name === r.ftable)?.columns.filter(fcol => fcol.is_pkey);
-          if (ftablePkeys?.length && ftablePkeys.every(fkey => r.fcols.includes(fkey.name))) {
+          const ftablePkeys = schema
+            .find((_tov) => _tov.name === r.ftable)
+            ?.columns.filter((fcol) => fcol.is_pkey);
+          if (
+            ftablePkeys?.length &&
+            ftablePkeys.every((fkey) => r.fcols.includes(fkey.name))
+          ) {
             type = "one-one";
           }
-          upsertJoin(tov.name, r.ftable, joinCols, type)
-        })
+          upsertJoin(tov.name, r.ftable, joinCols, type);
+        });
       }
-    })
-  })
+    });
+  });
   return joins;
-}
+}