prostgles-server 4.2.234 → 4.2.236

package/lib/PubSubManager/addTrigger.ts

@@ -0,0 +1,94 @@
+import { tryCatchV2 } from "prostgles-types";
+import { asValue, PubSubManager, ViewSubscriptionOptions } from "./PubSubManager";
+import * as crypto from "crypto";
+import { PRGLIOSocket } from "../DboBuilder/DboBuilderTypes";
+
+export async function addTrigger(
+  this: PubSubManager,
+  params: { table_name: string; condition: string },
+  viewOptions: ViewSubscriptionOptions | undefined,
+  socket: PRGLIOSocket | undefined
+) {
+  const addedTrigger = await tryCatchV2(async () => {
+    const { table_name } = { ...params };
+    let { condition } = { ...params };
+    if (!table_name) throw "MISSING table_name";
+
+    if (!condition || !condition.trim().length) {
+      condition = "TRUE";
+    }
+
+    if (this.dbo[table_name]?.tableOrViewInfo?.isHyperTable) {
+      throw "Triggers do not work on timescaledb hypertables due to bug:\nhttps://github.com/timescale/timescaledb/issues/1084";
+    }
+
+    const trgVals = {
+      tbl: asValue(table_name),
+      cond: asValue(condition),
+      condHash: asValue(crypto.createHash("md5").update(condition).digest("hex")),
+    };
+
+    await this.db.tx((t) =>
+      t.any(`
+      BEGIN WORK;
+      /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+      /* why is this lock level needed? */
+      --LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
+
+      /** app_triggers is not refreshed when tables are dropped */
+      DELETE FROM prostgles.app_triggers at
+      WHERE app_id = ${asValue(this.appId)} 
+      AND NOT EXISTS (
+        SELECT 1  
+        FROM pg_catalog.pg_trigger t
+        WHERE tgname like format('prostgles_triggers_%s_', at.table_name) || '%'
+        AND tgenabled = 'O'
+      );
+
+      INSERT INTO prostgles.app_triggers (
+        table_name, 
+        condition, 
+        condition_hash, 
+        app_id, 
+        related_view_name, 
+        related_view_def
+      ) 
+      VALUES (
+        ${trgVals.tbl}, 
+        ${trgVals.cond},
+        ${trgVals.condHash},
+        ${asValue(this.appId)}, 
+        ${asValue(viewOptions?.viewName ?? null)}, 
+        ${asValue(viewOptions?.definition ?? null)}
+      )
+      ON CONFLICT DO NOTHING;
+
+      COMMIT WORK;
+    `)
+    );
+
+    /** This might be redundant due to trigger on app_triggers */
+    await this.refreshTriggers();
+
+    return trgVals;
+  });
+
+  await this._log({
+    type: "syncOrSub",
+    command: "addTrigger",
+    condition: addedTrigger.data?.cond ?? params.condition,
+    duration: addedTrigger.duration,
+    socketId: socket?.id,
+    state: !addedTrigger.data?.tbl ? "fail" : "ok",
+    error: addedTrigger.error,
+    sid: socket && this.dboBuilder.prostgles.authHandler?.getSIDNoError({ socket }),
+    tableName: addedTrigger.data?.tbl ?? params.table_name,
+    connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map((s) => s.id),
+    localParams: socket && { clientReq: { socket } },
+    triggers: this._triggers,
+  });
+
+  if (addedTrigger.error) throw addedTrigger.error;
+
+  return addedTrigger;
+}

package/lib/PubSubManager/deleteOrphanedTriggers.ts

@@ -0,0 +1,31 @@
+import { PubSubManager } from "./PubSubManager";
+
+export async function deleteOrphanedTriggers(this: PubSubManager, tableName: string) {
+  const activeConditions = (this._triggers?.[tableName] ?? []).map((t) => t.hash);
+  this.db
+    .any(
+      `
+        /* Delete removed subscriptions */
+        /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+        DELETE FROM prostgles.app_triggers at
+        WHERE EXISTS (
+          SELECT 1
+          FROM prostgles.v_triggers t
+          WHERE t.table_name = $1 
+         --AND t.c_id IN ($2:csv) 
+          AND t.app_id = $3
+          AND at.app_id = t.app_id
+          AND at.table_name = t.table_name
+          --AND at.condition = t.condition
+          AND at.condition_hash NOT IN ($2:csv) 
+        ) 
+        `,
+      [tableName, activeConditions, this.appId]
+    )
+    .then(() => {
+      return this.refreshTriggers();
+    })
+    .catch((e) => {
+      console.error("Error deleting orphaned triggers", e);
+    });
+}

package/lib/PubSubManager/initialiseEventTriggers.ts

@@ -0,0 +1,156 @@
+import * as pgp from "pg-promise";
+import { PubSubManager } from "./PubSubManager";
+import { getIsSuperUser } from "../Prostgles";
+import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
+import { DELETE_DISCONNECTED_APPS_QUERY } from "./orphanTriggerCheck";
+import { DB_OBJ_NAMES } from "./getPubSubManagerInitQuery";
+
+const asValue = (v: any) => pgp.as.format("$1", [v]);
+
+export async function initialiseEventTriggers(this: PubSubManager) {
+  const { watchSchema } = this.dboBuilder.prostgles.opts;
+  if (watchSchema && !(await getIsSuperUser(this.db))) {
+    console.warn(
+      "prostgles watchSchema requires superuser db user. Will not watch using event triggers"
+    );
+  }
+
+  try {
+    /** We use these names because they include schema where necessary */
+    const allTableNames = Object.keys(this.dbo).filter((k) => this.dbo[k]?.tableOrViewInfo);
+    const tableFilterQuery =
+      allTableNames.length ?
+        `OR table_name NOT IN (${allTableNames.map((tblName) => asValue(tblName)).join(", ")})`
+      : "";
+    const query = pgp.as.format(
+      `
+        BEGIN;--  ISOLATION LEVEL SERIALIZABLE;
+        
+        /**                                 
+         * ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
+         *  Drop stale triggers
+         * */
+        DO
+        $do$
+          DECLARE trg RECORD;
+            q   TEXT;
+            ev_trg_needed BOOLEAN := FALSE;
+            ev_trg_exists BOOLEAN := FALSE;
+            is_super_user BOOLEAN := FALSE;
+        BEGIN
+
+            /**
+             *  Delete disconnected app records, this will delete related triggers
+             * */
+            ${DELETE_DISCONNECTED_APPS_QUERY};
+
+            DELETE FROM prostgles.app_triggers
+            WHERE app_id NOT IN (SELECT id FROM prostgles.apps)
+            ${tableFilterQuery}
+            ;
+            
+            /** IS THIS STILL NEEDED? Delete existing triggers without locking 
+            */
+              LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
+              EXECUTE format(
+                $q$
+
+                  CREATE TEMP TABLE %1$I AS --ON COMMIT DROP AS
+                  SELECT * FROM prostgles.app_triggers;
+
+                  DELETE FROM prostgles.app_triggers;
+
+                  INSERT INTO prostgles.app_triggers
+                  SELECT * FROM %1$I;
+
+                  DROP TABLE IF EXISTS %1$I;
+                $q$, 
+                ${asValue("triggers_" + this.appId)}
+              );
+            
+            ${SCHEMA_WATCH_EVENT_TRIGGER_QUERY}
+            
+        END
+        $do$; 
+
+
+        COMMIT;
+      `,
+      { EVENT_TRIGGER_TAGS }
+    );
+
+    await this.db
+      .tx((t) => t.any(query))
+      .catch((e: any) => {
+        console.error("prepareTriggers failed: ", e);
+        throw e;
+      });
+
+    return true;
+  } catch (e) {
+    console.error("prepareTriggers failed: ", e);
+    throw e;
+  }
+}
+
+const SCHEMA_WATCH_EVENT_TRIGGER_QUERY = `
+
+  is_super_user := EXISTS (select 1 from pg_user where usename = CURRENT_USER AND usesuper IS TRUE);
+
+  /* DROP the old buggy schema watch trigger */
+  IF EXISTS (
+    SELECT 1 FROM pg_catalog.pg_event_trigger
+    WHERE evtname = 'prostgles_schema_watch_trigger'
+  ) AND is_super_user IS TRUE 
+  THEN
+    DROP EVENT TRIGGER IF EXISTS prostgles_schema_watch_trigger;
+  END IF;
+
+  ev_trg_needed := EXISTS (
+    SELECT 1 FROM prostgles.apps 
+    WHERE watching_schema_tag_names IS NOT NULL
+  );
+  ev_trg_exists := EXISTS (
+    SELECT 1 FROM pg_catalog.pg_event_trigger
+    WHERE evtname = ${asValue(DB_OBJ_NAMES.schema_watch_trigger)}
+  );
+
+  /* DROP stale event trigger */
+  IF 
+    is_super_user IS TRUE 
+    AND ev_trg_needed IS FALSE 
+    AND ev_trg_exists IS TRUE 
+  THEN
+
+      SELECT format(
+        $$ 
+          DROP EVENT TRIGGER IF EXISTS %I ; 
+          DROP EVENT TRIGGER IF EXISTS %I ; 
+        $$
+        , ${asValue(DB_OBJ_NAMES.schema_watch_trigger)}
+        , ${asValue(DB_OBJ_NAMES.schema_watch_trigger_drop)}
+      )
+      INTO q;
+      EXECUTE q;
+
+  /* CREATE event trigger */
+  ELSIF 
+      is_super_user IS TRUE 
+      AND ev_trg_needed IS TRUE 
+      AND ev_trg_exists IS FALSE 
+  THEN
+
+      DROP EVENT TRIGGER IF EXISTS ${DB_OBJ_NAMES.schema_watch_trigger};
+      CREATE EVENT TRIGGER ${DB_OBJ_NAMES.schema_watch_trigger} 
+      ON ddl_command_end
+      WHEN TAG IN (\${EVENT_TRIGGER_TAGS:csv})
+      EXECUTE PROCEDURE ${DB_OBJ_NAMES.schema_watch_func}();
+
+      DROP EVENT TRIGGER IF EXISTS ${DB_OBJ_NAMES.schema_watch_trigger_drop};
+      CREATE EVENT TRIGGER ${DB_OBJ_NAMES.schema_watch_trigger_drop} 
+      ON sql_drop
+      --WHEN TAG IN (\${EVENT_TRIGGER_TAGS:csv})
+      EXECUTE PROCEDURE ${DB_OBJ_NAMES.schema_watch_func}();
+
+  END IF;
+`;

package/lib/PubSubManager/notifListener.ts

@@ -72,11 +72,11 @@ export async function notifListener(this: PubSubManager, data: { payload: string
     throw "table_name undef";
   }
 
-  const tableTriggerConditions = this._triggers?.[table_name]?.map((condition, idx) => ({
+  const tableTriggerConditions = this._triggers?.[table_name]?.map((cond, idx) => ({
     idx,
-    condition,
-    subs: this.getTriggerSubs(table_name, condition),
-    syncs: this.getSyncs(table_name, condition),
+    ...cond,
+    subs: this.getTriggerSubs(table_name, cond.condition),
+    syncs: this.getSyncs(table_name, cond.condition),
   }));
   let state: "error" | "no-triggers" | "ok" | "invalid_condition_ids" = "ok";
 
@@ -109,31 +109,7 @@ export async function notifListener(this: PubSubManager, data: { payload: string
       return !tc || (tc.subs.length === 0 && tc.syncs.length === 0);
     });
     if (orphanedTableConditions.length) {
-      this.db
-        .any(
-          `
-          /* Delete removed subscriptions */
-          /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
-          DELETE FROM prostgles.app_triggers at
-          WHERE EXISTS (
-            SELECT 1
-            FROM prostgles.v_triggers t
-            WHERE t.table_name = $1 
-            AND t.c_id IN ($2:csv) 
-            AND t.app_id = $3
-            AND at.app_id = t.app_id
-            AND at.table_name = t.table_name
-            AND at.condition = t.condition
-          ) 
-          `,
-          [table_name, orphanedTableConditions, this.appId]
-        )
-        .then(() => {
-          return this.refreshTriggers();
-        })
-        .catch((e) => {
-          console.error("Error deleting orphaned triggers", e);
-        });
+      void this.deleteOrphanedTriggers.bind(this)(table_name);
     }
 
     firedTableConditions.map(({ subs, syncs }) => {

package/lib/PubSubManager/refreshTriggers.ts

@@ -0,0 +1,38 @@
+import type { PubSubManager } from "./PubSubManager";
+
+export async function refreshTriggers(this: PubSubManager) {
+  const start = Date.now();
+  const triggers: {
+    table_name: string;
+    condition: string;
+    condition_hash: string;
+  }[] = await this.db.any(
+    `
+        SELECT *
+        FROM prostgles.v_triggers
+        WHERE app_id = $1
+        ORDER BY table_name, condition
+      `,
+    [this.dboBuilder.prostgles.appId]
+  );
+
+  const oldTriggers = { ...this._triggers };
+
+  this._triggers = {};
+  triggers.map((t) => {
+    this._triggers ??= {};
+    this._triggers[t.table_name] ??= [];
+    if (!this._triggers[t.table_name]?.map((t) => t.condition).includes(t.condition)) {
+      this._triggers[t.table_name]?.push({ condition: t.condition, hash: t.condition_hash });
+    }
+  });
+
+  await this._log({
+    type: "syncOrSub",
+    command: "refreshTriggers",
+    duration: Date.now() - start,
+    connectedSocketIds: this.connectedSocketIds,
+    triggers: this._triggers,
+    oldTriggers,
+  });
+}

package/package.json

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