prostgles-server 4.2.612 → 4.2.613

package/lib/DboBuilder/DboBuilder.ts

@@ -11,7 +11,7 @@ import type { PublishParser } from "../PublishParser/PublishParser";
 import type { OnCommitCallback } from "../PublishParser/publishTypesAndUtils";
 import type { ServerFunctionDefinition } from "../PublishParser/defineServerFunction";
 import { getQueryErrorPositionInfo } from "../TableConfig/runSQLFile";
-import type { Graph } from "../shortestPath";
+import type { Graph } from "./joins/shortestPath";
 import { clone } from "../utils/utils";
 import type {
   DBHandlerServer,
@@ -31,7 +31,7 @@ import {
   getConstraints,
   getSerializedClientErrorFromPGError,
 } from "./dboBuilderUtils";
-import { prepareShortestJoinPaths } from "./prepareShortestJoinPaths";
+import { prepareShortestJoinPaths } from "./joins/prepareShortestJoinPaths";
 import { cacheDBTypes, runSQL } from "./runSql/runSQL";
 import { getDetailedFieldInfo, type getDbTypes } from "./runSql/runSqlUtils";
 import { getTablesForSchemaPostgresSQL } from "./schema/getTablesForSchemaPostgresSQL";
@@ -140,10 +140,7 @@ export class DboBuilder {
 
   onSchemaChange?: (event: { command: string; query: string }) => void;
 
-  private readonly onCommitCallbacksByTransaction = new WeakMap<
-    object,
-    OnCommitCallback[]
-  >();
+  private readonly onCommitCallbacksByTransaction = new WeakMap<object, OnCommitCallback[]>();
 
   registerOnCommitCallback = (transaction: object, callback: OnCommitCallback) => {
     const callbacks = this.onCommitCallbacksByTransaction.get(transaction);
@@ -250,9 +247,12 @@ export class DboBuilder {
       this.checkingCanSubscribe = false;
     }
     const start = Date.now();
-    const tablesOrViewsReq = await getTablesForSchemaPostgresSQL({ db: this.prostgles.dbForSchema! }, {
-      schemaFilter: this.prostgles.opts.schemaFilter,
-    });
+    const tablesOrViewsReq = await getTablesForSchemaPostgresSQL(
+      { db: this.prostgles.dbForSchema! },
+      {
+        schemaFilter: this.prostgles.opts.schemaFilter,
+      },
+    );
     await this.prostgles.opts.onLog?.({
       type: "debug",
       command: "DboBuilder.getTablesForSchemaPostgresSQL",
@@ -262,7 +262,10 @@ export class DboBuilder {
     const tablesOrViews = tablesOrViewsReq.result;
     this.tablesOrViews = tablesOrViews;
 
-    this.constraints = await getConstraints(this.prostgles.dbForSchema!, this.prostgles.opts.schemaFilter);
+    this.constraints = await getConstraints(
+      this.prostgles.dbForSchema!,
+      this.prostgles.opts.schemaFilter,
+    );
     await this.prepareShortestJoinPaths();
 
     this.dbo = {};

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -13,7 +13,7 @@ import type { TableEvent } from "../../Logging";
 import type { DB } from "../../Prostgles";
 import type { Join } from "../../ProstglesTypes";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { Graph } from "../../shortestPath";
+import type { Graph } from "../joins/shortestPath";
 import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
 import { getSerializedClientErrorFromPGError } from "../DboBuilder";
 import type { TableSchema } from "../DboBuilderTypes";

package/lib/DboBuilder/joins/getInferredJoins.ts

@@ -0,0 +1,59 @@
+import type { TableSchema } from "../DboBuilderTypes";
+import type { Join } from "../../ProstglesTypes";
+import { sortedArraysMatch } from "../../utils/utils";
+import { isEqual } from "prostgles-types";
+
+export const getInferredJoins = (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) => sortedArraysMatch(j.tables, [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((existingOnCondition) => isEqual(existingOnCondition, 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(({ name }) => 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;
+};

package/lib/DboBuilder/joins/prepareShortestJoinPaths.spec.ts

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { DboBuilder } from "../DboBuilder";
+import { prepareShortestJoinPaths } from "./prepareShortestJoinPaths";
+import type { Join } from "../../ProstglesTypes";
+
+void test("duplicate configured table pairs are rejected even during table configuration", () => {
+  const join: Join = {
+    tables: ["conditions", "members"],
+    on: [{ project_id: "project_id" }],
+    type: "many-many",
+  };
+  for (const preparingTableConfig of [false, true]) {
+    for (const override of [false, true]) {
+      for (const tables of [join.tables, [...join.tables].reverse() as Join["tables"]]) {
+        const builder = {
+          prostgles: {
+            preparingTableConfig,
+            opts: { joins: [join, { ...join, tables, override }] },
+          },
+          tablesOrViews: [],
+        } as unknown as DboBuilder;
+        assert.throws(
+          () => prepareShortestJoinPaths(builder),
+          /Duplicate configured join for table pair/,
+        );
+      }
+    }
+  }
+});
+
+void test("configured joins are deferred only during table configuration", () => {
+  const builder = {
+    prostgles: {
+      preparingTableConfig: true,
+      opts: {
+        joins: [
+          {
+            tables: ["conditions", "members"],
+            on: [{ project_id: "project_id" }],
+            type: "many-many",
+          },
+        ],
+      },
+    },
+    tablesOrViews: [],
+  } as unknown as DboBuilder;
+  assert.deepEqual(prepareShortestJoinPaths(builder).joins, []);
+  builder.prostgles.preparingTableConfig = false;
+  assert.throws(
+    () => prepareShortestJoinPaths(builder),
+    (error: unknown) => typeof error === "string" && error.includes("Table not found: conditions"),
+  );
+});
+
+void test("existing configured joins remain available during table configuration", () => {
+  const join = {
+    tables: ["conditions", "members"],
+    on: [{ project_id: "project_id" }],
+    type: "many-many",
+  };
+  const builder = {
+    prostgles: { preparingTableConfig: true, opts: { joins: [join] } },
+    tablesOrViews: ["conditions", "members"].map((name) => ({
+      name,
+      columns: [{ name: "project_id" }],
+    })),
+  } as unknown as DboBuilder;
+  assert.deepEqual(prepareShortestJoinPaths(builder).joins, [join]);
+  builder.prostgles.preparingTableConfig = false;
+  assert.deepEqual(prepareShortestJoinPaths(builder).joins, [join]);
+});

package/lib/DboBuilder/joins/prepareShortestJoinPaths.ts

@@ -0,0 +1,205 @@
+import { isEqual, reverseJoinOn } from "prostgles-types";
+import type { DboBuilder } from "../DboBuilder";
+import type { Join } from "../../ProstglesTypes";
+import { JOIN_TYPES } from "../../ProstglesTypes";
+import type { Graph } from "./shortestPath";
+import { findShortestPath } from "./shortestPath";
+import type { JoinPaths } from "../ViewHandler/ViewHandler";
+import { getInferredJoins } from "./getInferredJoins";
+import { sortedArraysMatch } from "../../utils/utils";
+
+type Result = {
+  joinGraph?: Graph | undefined;
+  joins: Join[];
+  shortestJoinPaths: JoinPaths;
+};
+
+export const prepareShortestJoinPaths = (dboBuilder: DboBuilder): Result => {
+  if (!dboBuilder.prostgles.opts.joins) {
+    return {
+      joins: [],
+      shortestJoinPaths: [],
+    };
+  }
+
+  let joinConfig = dboBuilder.prostgles.opts.joins;
+  if (Array.isArray(joinConfig)) {
+    joinConfig.forEach((join, index, configured) => {
+      const duplicate = configured
+        .slice(0, index)
+        .some((existing) => isEqual(existing.tables.toSorted(), join.tables.toSorted()));
+      if (duplicate) {
+        throw new Error(
+          `Duplicate configured join for table pair ${JSON.stringify(join.tables)}. Combine conditions in a single Join.on.`,
+        );
+      }
+    });
+  }
+  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 = getInferredJoins(dboBuilder.tablesOrViews);
+  if (joinConfig === "inferred") {
+    joinConfig = inferredJoins;
+  } else if (Array.isArray(joinConfig)) {
+    joinConfig = mergeJoins(inferredJoins, joinConfig);
+    // 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 (sortedArraysMatch([jp.t1, jp.t2], [t1, t2])) {
+            const shortestPath = findShortestPath(joinGraph, t1, t2);
+            if (sortedArraysMatch(shortestPath.path, jp.path)) {
+              return true;
+            }
+          }
+        })
+      ) {
+        return;
+      }
+
+      const calculatedPath = findShortestPath(joinGraph, t1, t2);
+      if (!(calculatedPath.distance < Infinity)) return;
+
+      const existing1 = shortestJoinPaths.find((j) => j.t1 === t1 && j.t2 === t2);
+      if (!existing1) {
+        shortestJoinPaths.push({ t1, t2, path: calculatedPath.path.slice() });
+      }
+
+      const existing2 = shortestJoinPaths.find((j) => j.t2 === t1 && j.t1 === t2);
+      if (!existing2) {
+        shortestJoinPaths.push({
+          t1: t2,
+          t2: t1,
+          path: calculatedPath.path.slice().reverse(),
+        });
+      }
+    });
+  });
+  return {
+    joins,
+    shortestJoinPaths,
+    joinGraph,
+  };
+};
+
+const mergeJoins = (inferred: Join[], configured: Join[]): Join[] => {
+  const joins = [...inferred];
+  configured.forEach((join) => {
+    const index = joins.findIndex((existing) =>
+      isEqual(existing.tables.toSorted(), join.tables.toSorted()),
+    );
+    const existing = joins[index];
+    const previousOn =
+      !existing || join.override ? []
+      : existing.tables[0] === join.tables[0] ? existing.on
+      : reverseJoinOn(existing.on);
+    const on = [...previousOn, ...join.on].filter(
+      (condition, index, conditions) =>
+        conditions.findIndex((candidate) => isEqual(candidate, condition)) === index,
+    );
+    const merged = { ...join, on };
+    if (existing) {
+      joins[index] = merged;
+    } else {
+      joins.push(merged);
+    }
+  });
+  return joins;
+};

package/lib/{shortestPath.ts → DboBuilder/joins/shortestPath.ts}

@@ -2,17 +2,6 @@
 /* eslint-disable */
 import { AnyObject } from "prostgles-types";
 
-const shortestDistanceNode = (distances: Graph, visited: Graph) => {
-  let shortest = null;
-
-  for (const node in distances) {
-    const currentIsShortest = shortest === null || distances[node] < distances[shortest];
-    if (currentIsShortest && !visited.includes(node)) {
-      shortest = node;
-    }
-  }
-  return shortest;
-};
 export type Graph = {
   [key: string]: { [key: string]: number };
 };
@@ -20,7 +9,7 @@ export type Graph = {
 export const findShortestPath = (
   graph: Graph,
   startNode: string,
-  endNode: string
+  endNode: string,
 ): { distance: number; path: string[] } => {
   // establish object for recording distances from the start node
   let distances: AnyObject = {};
@@ -87,7 +76,19 @@ export const findShortestPath = (
   return results;
 };
 
-/* Usage: 
+const shortestDistanceNode = (distances: Graph, visited: Graph) => {
+  let shortest = null;
+
+  for (const node in distances) {
+    const currentIsShortest = shortest === null || distances[node] < distances[shortest];
+    if (currentIsShortest && !visited.includes(node)) {
+      shortest = node;
+    }
+  }
+  return shortest;
+};
+
+/* Example: 
 
 const graph = {
 	start: { A: 5, B: 2 },

package/lib/ProstglesTypes.ts

@@ -94,6 +94,8 @@ export type Join = {
   tables: [string, string];
   on: { [key: string]: string }[]; // Allow multi references to table
   type: (typeof JOIN_TYPES)[number];
+  /** Replace inferred joins for this table pair. Defaults to false. */
+  override?: boolean;
 };
 type Joins = Join[] | "inferred";
 
@@ -203,9 +205,8 @@ export type ProstglesInitOptions<
   testRulesOnConnect?: boolean;
 
   /**
-   * Allows defining table relationships that can then be used in filters and data inserts:
-   *  - `inferred` - uses the foreign keys to infer the joins
-   *  - `Join[]` - specifies the joins manually
+   * Allows defining custom table relationships that can then be used in filters and data inserts.
+   * By default FKs are used to infer the joins.
    */
   joins?: Joins;
 

package/lib/utils/utils.ts

@@ -1,3 +1,5 @@
+import { isEqual } from "prostgles-types";
+
 export { get } from "prostgles-types";
 export const clone = <T extends any[] | Record<string, any>>(obj: T): T => {
   if (typeof structuredClone !== "undefined") {
@@ -27,3 +29,7 @@ const canBeUsedAsIsInTypescript = (str: string): boolean => {
 };
 
 export const isArray = <T>(data: T): data is Extract<T, readonly unknown[]> => Array.isArray(data);
+
+export const sortedArraysMatch = (a: string[], b: string[]): boolean => {
+  return isEqual(a.toSorted(), b.toSorted());
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.612",
+  "version": "4.2.613",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/tsconfig.json

@@ -3,7 +3,7 @@
   "compilerOptions": {
     "target": "es2022",
     "lib": [
-      "es2022"
+      "ES2023"
     ],
     "strict": true,
     "module": "node16",

package/dist/DboBuilder/prepareShortestJoinPaths.d.ts

@@ -1,12 +0,0 @@
-import type { DboBuilder } from "../DboBuilder/DboBuilder";
-import type { Join } from "../ProstglesTypes";
-import type { Graph } from "../shortestPath";
-import type { JoinPaths } from "./ViewHandler/ViewHandler";
-type Result = {
-    joinGraph?: Graph | undefined;
-    joins: Join[];
-    shortestJoinPaths: JoinPaths;
-};
-export declare function prepareShortestJoinPaths(dboBuilder: DboBuilder): Promise<Result>;
-export {};
-//# sourceMappingURL=prepareShortestJoinPaths.d.ts.map

package/dist/DboBuilder/prepareShortestJoinPaths.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepareShortestJoinPaths.d.ts","sourceRoot":"","sources":["../../lib/DboBuilder/prepareShortestJoinPaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C,OAAO,KAAK,EAAE,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAG5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAE3D,KAAK,MAAM,GAAG;IACZ,SAAS,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,iBAAiB,EAAE,SAAS,CAAC;CAC9B,CAAC;AACF,wBAAsB,wBAAwB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAwJtF"}