prostgles-server 4.2.611 → 4.2.613

package/lib/DboBuilder/prepareShortestJoinPaths.ts

@@ -1,225 +0,0 @@
-import type { DboBuilder } from "../DboBuilder/DboBuilder";
-import type { Join } from "../ProstglesTypes";
-import { JOIN_TYPES } from "../ProstglesTypes";
-import type { Graph} from "../shortestPath";
-import { findShortestPath } from "../shortestPath";
-import type { TableSchema } from "./DboBuilderTypes";
-import type { JoinPaths } from "./ViewHandler/ViewHandler";
-
-type Result = {
-  joinGraph?: Graph | undefined;
-  joins: Join[];
-  shortestJoinPaths: JoinPaths;
-};
-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");
-    }
-
-    // The initial DBO is needed by tableConfig before its tables/columns exist.
-    // Defer only joins that cannot be resolved yet; the final rebuild validates all.
-    if (Array.isArray(joinConfig) && dboBuilder.prostgles.preparingTableConfig) {
-      const tables = dboBuilder.tablesOrViews;
-      joinConfig = joinConfig.filter((join) => join.tables.every((name, index) => {
-        const table = tables.find((candidate) => candidate.name === name);
-        return table && join.on.every((on) =>
-          (index === 0 ? Object.keys(on) : Object.values(on)).every((column) =>
-            table.columns.some((candidate) => candidate.name === column)
-          )
-        );
-      }));
-    }
-    const inferredJoins = await getInferredJoins2(dboBuilder.tablesOrViews);
-    if (joinConfig === "inferred") {
-      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)))
-      );
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    } else if (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);
-
-      // 2 find incorrect tables
-      const missing = joins.flatMap((j) => j.tables).find((t) => !tovNames.includes(t));
-      if (missing) {
-        throw "Table not found: " + missing;
-      }
-
-      // 3 find incorrect fields
-      joins.map(({ tables, on }) => {
-        const t1 = tables[0],
-          t2 = tables[1];
-        on.map((cond) => {
-          const f1s = Object.keys(cond),
-            f2s = Object.values(cond);
-          [
-            [t1, f1s],
-            [t2, f2s],
-          ].map((v) => {
-            const t = <string>v[0],
-              f = <string[]>v[1];
-
-            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));
-            if (m1.length) {
-              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(` | `);
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      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: any) {
-      const errMsg =
-        ((joinConfig as any) === "inferred" ? "INFERRED " : "") +
-        "JOINS VALIDATION ERROR \n-> " +
-        e;
-      throw errMsg;
-    }
-
-    // Make joins graph
-    const joinGraph: Graph = {};
-    joins.forEach(({ tables }) => {
-      const _t = tables.slice().sort(),
-        t1 = _t[0]!,
-        t2 = _t[1]!;
-
-      if (t1 === t2) return;
-
-      joinGraph[t1] ??= {};
-      joinGraph[t1][t2] = 1;
-
-      joinGraph[t2] ??= {};
-      joinGraph[t2][t1] = 1;
-    });
-    const tables = Array.from(new Set(joins.flatMap((t) => t.tables)));
-    const shortestJoinPaths: JoinPaths = [];
-    tables.forEach((t1) => {
-      tables.forEach((t2) => {
-        /** Prevent recursion */
-        if (
-          t1 === t2 ||
-          shortestJoinPaths.some((jp) => {
-            if (arrayValuesMatch([jp.t1, jp.t2], [t1, t2])) {
-              const spath = findShortestPath(joinGraph, t1, t2);
-              if (arrayValuesMatch(spath.path, jp.path)) {
-                return true;
-              }
-            }
-          })
-        ) {
-          return;
-        }
-
-        const spath = findShortestPath(joinGraph, t1, t2);
-        if (!(spath.distance < Infinity)) return;
-
-        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);
-        if (!existing2) {
-          shortestJoinPaths.push({
-            t1: t2,
-            t2: t1,
-            path: spath.path.slice().reverse(),
-          });
-        }
-      });
-    });
-    return {
-      joins,
-      shortestJoinPaths,
-      joinGraph,
-    };
-  }
-
-  return {
-    joins: [],
-    shortestJoinPaths: [],
-  };
-}
-
-const arrayValuesMatch = <T>(arr1: T[], arr2: T[]): boolean => {
-  return arr1.slice().sort().join() === arr2.slice().sort().join();
-};
-
-function getInferredJoins2(schema: TableSchema[]): 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 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 }), {});
-    if (existing) {
-      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))) {
-        existing.on.push(cond);
-        joins[existingIdx] = existing;
-      }
-    } else {
-      joins.push({
-        tables: [t1, t2],
-        on: [normalCond],
-        type,
-      });
-    }
-  };
-  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]!,
-          }));
-          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))) {
-            type = "one-one";
-          }
-          upsertJoin(tov.name, r.ftable, joinCols, type);
-        });
-      }
-    });
-  });
-  return joins;
-}