prostgles-server 4.2.482 → 4.2.484

package/lib/Filtering/getFilterItemCondition.ts

@@ -0,0 +1,205 @@
+import {
+  GeomFilterKeys,
+  GeomFilter_Funcs,
+  TextFilterKeys,
+  TextFilter_FullTextSearchFilterKeys,
+  includes,
+  isDefined,
+  isObject,
+} from "prostgles-types";
+import { parseFilterRightValue } from "./parseFilterRightValue";
+import { FILTER_OPERAND_TO_SQL_OPERAND, FILTER_OPERANDS } from "./Filtering";
+import type { SelectItemValidated } from "../DboBuilder/QueryBuilder/QueryBuilder";
+import { pgp } from "../DboBuilder/DboBuilderTypes";
+
+export const getFilterItemCondition = ({
+  selItem,
+  leftQ,
+  rightF,
+}: {
+  leftQ: string;
+  selItem: SelectItemValidated;
+  rightF: unknown;
+}): string => {
+  const asValue = (v: any) => pgp.as.format("$1", [v]);
+
+  const parseRightVal = (val: any, expect?: "csv" | "array" | "json" | "jsonb") => {
+    try {
+      return parseFilterRightValue(val, { selectItem: selItem, expect });
+    } catch (e: any) {
+      throw new Error(e);
+    }
+  };
+
+  /* Matching sel item */
+  if (isObject(rightF)) {
+    const filterKeys = Object.keys(rightF);
+    let filterOperand = filterKeys[0] as (typeof FILTER_OPERANDS)[number];
+
+    /** JSON cannot be compared so we'll cast it to TEXT */
+    if (selItem.column_udt_type === "json" || includes(TextFilterKeys, filterOperand)) {
+      leftQ += "::TEXT ";
+    }
+
+    /** It's an object key which means it's an equality comparison against a json object */
+    if (selItem.column_udt_type?.startsWith("json") && !includes(FILTER_OPERANDS, filterOperand)) {
+      return leftQ + " = " + parseRightVal(rightF);
+    }
+
+    let filterValue = rightF[filterOperand] as string | null | number | Date | any[];
+    const ALLOWED_FUNCS = [...GeomFilter_Funcs, ...TextFilter_FullTextSearchFilterKeys] as const;
+    let funcName: undefined | (typeof ALLOWED_FUNCS)[number];
+    let funcArgs: undefined | any[];
+
+    if (
+      selItem.column_udt_type === "interval" &&
+      isObject(rightF) &&
+      Object.values(rightF).every((v) => Number.isFinite(v))
+    ) {
+      filterOperand = "=";
+      filterValue = Object.entries(rightF)
+        .map(([k, v]) => `${v}${k}`)
+        .join(" ");
+    } else if (
+      (filterKeys.length !== 1 || !isDefined(filterOperand)) &&
+      selItem.column_udt_type !== "jsonb"
+    ) {
+      throw new Error("Bad filter. Expecting one key only");
+    } else if (isObject(filterValue) && !(filterValue instanceof Date)) {
+      /**
+       * Filter notation
+       * geom && st_makeenvelope(funcArgs)
+       */
+      const filterValueKeys = Object.keys(filterValue);
+      funcName = filterValueKeys[0] as any;
+      if (includes(ALLOWED_FUNCS, funcName)) {
+        funcArgs = filterValue[funcName as any];
+      } else {
+        funcName = undefined;
+      }
+    }
+
+    /** st_makeenvelope */
+    if (
+      includes(GeomFilterKeys, filterOperand) &&
+      funcName &&
+      includes(GeomFilter_Funcs, funcName)
+    ) {
+      /**
+       * If leftQ is geography then:
+       * - err can happen: 'Antipodal (180 degrees long) edge detected!'
+       * - inacurrate results at large envelopes due to the curvature of the earth
+       * https://gis.stackexchange.com/questions/78816/maximum-size-on-the-bounding-box-with-st-makeenvelope-and-and-geography-colum
+       */
+      if (funcName.toLowerCase() === "st_makeenvelope") {
+        leftQ += "::geometry";
+      }
+
+      return `${leftQ} ${filterOperand} ${funcName}${parseRightVal(funcArgs, "csv")}`;
+    } else if (["=", "$eq"].includes(filterOperand) && !funcName) {
+      if (filterValue === null) return leftQ + " IS NULL ";
+      return leftQ + " = " + parseRightVal(filterValue);
+    } else if (["<>", "$ne"].includes(filterOperand)) {
+      if (filterValue === null) return leftQ + " IS NOT NULL ";
+      return leftQ + " <> " + parseRightVal(filterValue);
+    } else if ([">", "$gt"].includes(filterOperand)) {
+      return leftQ + " > " + parseRightVal(filterValue);
+    } else if (["<", "$lt"].includes(filterOperand)) {
+      return leftQ + " < " + parseRightVal(filterValue);
+    } else if ([">=", "$gte"].includes(filterOperand)) {
+      return leftQ + " >=  " + parseRightVal(filterValue);
+    } else if (["<=", "$lte"].includes(filterOperand)) {
+      return leftQ + " <= " + parseRightVal(filterValue);
+    } else if (["$in", "$nin"].includes(filterOperand)) {
+      const isIn = filterOperand === "$in";
+      if (filterValue !== null && !Array.isArray(filterValue)) {
+        throw new Error("In filter expects an array");
+      }
+      if (!filterValue?.length) {
+        return isIn ? " FALSE " : " TRUE ";
+      }
+
+      const nonNullFilterValues = filterValue.filter((v) => v !== null);
+      const conditions: string[] = [];
+      if (nonNullFilterValues.length) {
+        conditions.push(
+          leftQ + (isIn ? " IN " : " NOT IN ") + parseRightVal(nonNullFilterValues, "csv"),
+        );
+      }
+      if (filterValue.includes(null)) {
+        const comparator = isIn ? " IS NULL " : " IS NOT NULL ";
+        conditions.push(` ${leftQ} ${comparator} `);
+      }
+      const joinedConditions = conditions.join(isIn ? " OR " : " AND ");
+      return conditions.length > 1 ? `(${joinedConditions})` : joinedConditions;
+    } else if (["$between"].includes(filterOperand)) {
+      if (!Array.isArray(filterValue) || filterValue.length !== 2) {
+        throw new Error("Between filter expects an array of two values");
+      }
+      return leftQ + " BETWEEN " + asValue(filterValue[0]) + " AND " + asValue(filterValue[1]);
+    } else if (["$ilike"].includes(filterOperand)) {
+      return leftQ + " ILIKE " + asValue(filterValue);
+    } else if (["$like"].includes(filterOperand)) {
+      return leftQ + " LIKE " + asValue(filterValue);
+    } else if (["$nilike"].includes(filterOperand)) {
+      return leftQ + " NOT ILIKE " + asValue(filterValue);
+    } else if (["$nlike"].includes(filterOperand)) {
+      return leftQ + " NOT LIKE " + asValue(filterValue);
+    } else if (filterOperand === "$isDistinctFrom" || filterOperand === "$isNotDistinctFrom") {
+      const operator = FILTER_OPERAND_TO_SQL_OPERAND[filterOperand];
+      return leftQ + ` ${operator} ` + asValue(filterValue);
+
+      /* MAYBE TEXT OR MAYBE ARRAY */
+    } else if (
+      ["@>", "<@", "$contains", "$containedBy", "$overlaps", "&&", "@@"].includes(filterOperand)
+    ) {
+      const operand =
+        filterOperand === "@@" ? "@@"
+        : ["@>", "$contains"].includes(filterOperand) ? "@>"
+        : ["&&", "$overlaps"].includes(filterOperand) ? "&&"
+        : "<@";
+
+      if (operand === "<@" || operand === "@>") {
+        if (selItem.column_udt_type === "jsonb") {
+          const filterValueAsString =
+            typeof filterValue === "string" ? filterValue : JSON.stringify(filterValue);
+          return leftQ + operand + parseRightVal(filterValueAsString);
+        }
+      }
+
+      /* Array for sure */
+      if (Array.isArray(filterValue)) {
+        return leftQ + operand + parseRightVal(filterValue, "array");
+
+        /* FTSQuery */
+      } else if (
+        ["@@"].includes(filterOperand) &&
+        includes(TextFilter_FullTextSearchFilterKeys, funcName)
+      ) {
+        let lq = `to_tsvector(${leftQ}::text)`;
+        if (selItem.columnPGDataType === "tsvector") lq = leftQ!;
+
+        const res = `${lq} ${operand} ` + `${funcName}${parseRightVal(funcArgs, "csv")}`;
+
+        return res;
+      } else {
+        throw new Error("Unrecognised filter operand: " + filterOperand + " ");
+      }
+    } else {
+      throw new Error("Unrecognised filter operand: " + filterOperand + " ");
+    }
+  }
+  /* Is an equal filter */
+  if (rightF === null) {
+    return leftQ + " IS NULL ";
+  }
+
+  /**
+   * Ensure that when comparing an array to a json column, the array is cast to json
+   */
+  let valueStr = asValue(rightF);
+  if (selItem.column_udt_type?.startsWith("json") && Array.isArray(rightF)) {
+    valueStr = pgp.as.format(`$1::jsonb`, [JSON.stringify(rightF)]);
+  }
+  return `${leftQ} = ${valueStr}`;
+};

package/lib/Filtering/parseFilterRightValue.ts

@@ -0,0 +1,24 @@
+import { pgp } from "../DboBuilder/DboBuilderTypes";
+import { type SelectItemValidated } from "../DboBuilder/QueryBuilder/QueryBuilder";
+
+type ParseRightValOpts = {
+  expect?: "csv" | "array" | "json" | "jsonb";
+  selectItem: SelectItemValidated | undefined;
+};
+export const parseFilterRightValue = (val: any, { expect, selectItem }: ParseRightValOpts) => {
+  const asValue = (v: any) => pgp.as.format("$1", [v]);
+  const checkIfArr = () => {
+    if (!Array.isArray(val)) {
+      throw "This type of filter/column expects an Array of items";
+    }
+  };
+  if (expect === "csv" || expect?.startsWith("json")) {
+    checkIfArr();
+    return pgp.as.format(`($1:${expect})`, [val]);
+  } else if (expect === "array" || selectItem?.columnPGDataType === "ARRAY") {
+    checkIfArr();
+    return pgp.as.format(" ARRAY[$1:csv]", [val]);
+  }
+
+  return asValue(val);
+};

package/lib/PubSubManager/PubSubManager.ts

@@ -146,7 +146,17 @@ export type Subscription = Pick<
   triggers: AddTriggerParams[];
 };
 
-export type PubSubManagerTriggers = Map<string, { condition: string; hash: string }[]>;
+export type TableTriggerInfo = {
+  condition: string;
+  hash: string;
+  columnInfo: {
+    join_condition: string;
+    tracked_columns: Record<string, number>;
+    where_statement: string;
+  } | null;
+};
+
+export type PubSubManagerTriggers = Map<string, TableTriggerInfo[]>;
 
 /**
  * Used to facilitate table subscribe and sync

package/lib/PubSubManager/refreshTriggers.ts

@@ -1,4 +1,4 @@
-import type { PubSubManager } from "./PubSubManager";
+import type { PubSubManager, TableTriggerInfo } from "./PubSubManager";
 
 export async function refreshTriggers(this: PubSubManager) {
   const start = Date.now();
@@ -6,6 +6,7 @@ export async function refreshTriggers(this: PubSubManager) {
     table_name: string;
     condition: string;
     condition_hash: string;
+    columns_info: TableTriggerInfo["columnInfo"];
   }>(
     `
         SELECT *
@@ -23,7 +24,11 @@ export async function refreshTriggers(this: PubSubManager) {
     this._triggers.set(t.table_name, this._triggers.get(t.table_name) ?? []);
     const tableTriggers = this._triggers.get(t.table_name)!;
     if (!tableTriggers.map((t) => t.condition).includes(t.condition)) {
-      tableTriggers.push({ condition: t.condition, hash: t.condition_hash });
+      tableTriggers.push({
+        condition: t.condition,
+        hash: t.condition_hash,
+        columnInfo: t.columns_info,
+      });
     }
   });
 

package/package.json

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

package/dist/Filtering.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Filtering.d.ts","sourceRoot":"","sources":["../lib/Filtering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAiBlE,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAElF,eAAO,MAAM,eAAe,oSAMlB,CAAC;AAEX,eAAO,MAAM,6BAA6B,EAqBrC,MAAM,CAAC,CAAC,OAAO,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;AAEtD;;;GAGG;AACH,KAAK,mBAAmB,GAAG;IACzB,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC;IAC3C,MAAM,EAAE,mBAAmB,EAAE,GAAG,SAAS,CAAC;IAC1C,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,mBAAmB,KAAG,MAuW3D,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,MAAM,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;IAC5C,UAAU,EAAE,mBAAmB,GAAG,SAAS,CAAC;CAC7C,CAAC;AACF,eAAO,MAAM,qBAAqB,GAAI,KAAK,GAAG,EAAE,wBAAwB,iBAAiB,WAgBxF,CAAC"}