prostgles-server 4.2.440 → 4.2.441

package/lib/PubSubManager/addSub.ts

@@ -1,7 +1,12 @@
 import type { SubscriptionChannels } from "prostgles-types";
 import type { VoidFunction } from "../SchemaWatch/SchemaWatch";
 import { tout } from "./init/initPubSubManager";
-import type { BasicCallback, PubSubManager, Subscription, SubscriptionParams } from "./PubSubManager";
+import type {
+  BasicCallback,
+  PubSubManager,
+  Subscription,
+  SubscriptionParams,
+} from "./PubSubManager";
 import { parseCondition } from "./PubSubManagerUtils";
 import type { AddTriggerParams } from "./addTrigger";
 
@@ -17,11 +22,11 @@ type AddSubResult = SubscriptionChannels & {
 /* The distinct list of {table_name, condition} must have a corresponding trigger in the database */
 export async function addSub(
   this: PubSubManager,
-  subscriptionParams: Omit<AddSubscriptionParams, "channel_name" | "parentSubParams">
+  subscriptionParams: Omit<AddSubscriptionParams, "channel_name" | "parentSubParams">,
 ): Promise<AddSubResult> {
   const {
     socket,
-    localFuncs,
+    onData,
     table_rules,
     filter = {},
     selectParams = {},
@@ -33,10 +38,10 @@ export async function addSub(
   } = subscriptionParams;
   const table_name = table_info.name;
 
-  if (!socket && !localFuncs) {
+  if (!socket && !onData) {
     throw "socket AND func missing";
   }
-  if (socket && localFuncs) {
+  if (socket && onData) {
     throw "addSub: cannot have socket AND func";
   }
 
@@ -50,7 +55,7 @@ export async function addSub(
   const newSub: Subscription = {
     channel_name,
     filter,
-    localFuncs,
+    onData,
     selectParams: selectParams,
     lastPushed: 0,
     socket,
@@ -74,7 +79,7 @@ export async function addSub(
   const [matchingSub] = this.getClientSubs(newSub);
   if (matchingSub) {
     console.error(
-      `Trying to add a duplicate ${localFuncs ? "local" : "socket"} sub for: ${channel_name}`
+      `Trying to add a duplicate ${onData ? "local" : "socket"} sub for: ${channel_name}`,
     );
     return result;
   }
@@ -104,7 +109,7 @@ export async function addSub(
     void this.pushSubData(newSub);
   };
 
-  if (localFuncs) {
+  if (onData) {
     /**
      * Must ensure sub will start sending data after all triggers are set up.
      * Socket clients are not affected as they need to confirm they are ready to receive data

package/lib/PubSubManager/init/getDataWatchFunctionQuery.ts

@@ -8,7 +8,7 @@ import { asValue, DELIMITER, NOTIF_CHANNEL, NOTIF_TYPE } from "../PubSubManagerU
  */
 export const udtNamesWithoutEqualityComparison = ["json", "xml"];
 export const getDataWatchFunctionQuery = (debugMode: boolean | undefined) => {
-  return `
+  const dataWatchFunctionQuery = `
   
         CREATE OR REPLACE FUNCTION ${DB_OBJ_NAMES.data_watch_func}() RETURNS TRIGGER 
         AS $$
@@ -161,6 +161,25 @@ export const getDataWatchFunctionQuery = (debugMode: boolean | undefined) => {
         COMMENT ON FUNCTION ${DB_OBJ_NAMES.data_watch_func} IS 'Prostgles internal function used to notify when data in the table changed';
 
   `;
+
+  /** Ensure every execute is followed by EXCEPTION catch to ensure we remove stale schema/faulty triggers */
+  const queryLines = dataWatchFunctionQuery
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l);
+  queryLines.forEach((line, lineIndex) => {
+    const nextLine = queryLines[lineIndex + 1] ?? "";
+    if (
+      line.toUpperCase().startsWith("EXECUTE") &&
+      !nextLine.toUpperCase().startsWith("EXCEPTION")
+    ) {
+      throw new Error(
+        `Every EXECUTE statement in the data watch function must be followed by an EXCEPTION block to catch errors and avoid stale triggers. Problematic line: ${line}`,
+      );
+    }
+  });
+
+  return dataWatchFunctionQuery;
 };
 
 /**
@@ -208,6 +227,14 @@ IF TG_OP = 'UPDATE' THEN
 
       BEGIN
         EXECUTE query INTO changed_columns;
+        EXCEPTION WHEN OTHERS THEN
+          
+          has_errors := TRUE;
+
+          GET STACKED DIAGNOSTICS 
+            err_text = MESSAGE_TEXT,
+            err_detail = PG_EXCEPTION_DETAIL,
+            err_hint = PG_EXCEPTION_HINT;
       END;
 
       /* It is possible to get no changes */

package/lib/PubSubManager/notifListener.ts

@@ -101,21 +101,21 @@ export async function notifListener(this: PubSubManager, data: { payload: string
   } else if (conditionIds?.every((id) => Number.isInteger(id))) {
     state = "ok";
     const firedTableConditions = tableTriggerConditions.filter(({ idx }) =>
-      conditionIds.includes(idx)
+      conditionIds.includes(idx),
     );
     const orphanedTableConditions = conditionIds.filter((condId) => {
       const tc = tableTriggerConditions.at(condId);
       return !tc || (tc.subs.length === 0 && tc.syncs.length === 0);
     });
     if (orphanedTableConditions.length) {
-      void this.deleteOrphanedTriggers.bind(this)(table_name);
+      void this.deleteOrphanedTriggers(new Set(table_name));
     }
 
     firedTableConditions.map(({ subs, syncs }) => {
       log(
         "notifListener",
         subs.map((s) => s.channel_name),
-        syncs.map((s) => s.channel_name)
+        syncs.map((s) => s.channel_name),
       );
 
       syncs.map((s) => {
@@ -128,8 +128,8 @@ export async function notifListener(this: PubSubManager, data: { payload: string
           (trg) =>
             this.dbo[trg.table_name] &&
             sub.is_ready &&
-            ((sub.socket_id && this.sockets[sub.socket_id]) || sub.localFuncs)
-        )
+            ((sub.socket_id && this.sockets[sub.socket_id]) || sub.onData),
+        ),
       );
 
       activeAndReadySubs.forEach((sub) => {
@@ -143,7 +143,7 @@ export async function notifListener(this: PubSubManager, data: { payload: string
           tracked_columns
         ) {
           const subFieldsHaveChanged = changedColumns.some((changedColumn) =>
-            tracked_columns.includes(changedColumn)
+            tracked_columns.includes(changedColumn),
           );
           if (!subFieldsHaveChanged) return;
         }
@@ -181,11 +181,11 @@ export async function notifListener(this: PubSubManager, data: { payload: string
     state,
     op_name,
     condition_ids_str,
-    tableTriggers: this._triggers[table_name],
+    tableTriggers: this._triggers.get(table_name),
     tableSyncs: JSON.stringify(
       this.syncs
         .filter((s) => s.table_name === table_name)
-        .map((s) => pickKeys(s, ["condition", "socket_id"]))
+        .map((s) => pickKeys(s, ["condition", "socket_id"])),
     ),
     connectedSocketIds: this.connectedSocketIds,
   });

package/lib/PubSubManager/pushSubData.ts

@@ -1,12 +1,10 @@
-import { getSerialisableError } from "prostgles-types";
-import { parseLocalFuncs } from "../DboBuilder/ViewHandler/subscribe";
 import type { EventTypes } from "../Logging";
 import type { Subscription } from "./PubSubManager";
 import { type PubSubManager } from "./PubSubManager";
 import { log } from "./PubSubManagerUtils";
 
 export async function pushSubData(this: PubSubManager, sub: Subscription, err?: any) {
-  const { socket_id, channel_name } = sub;
+  const { socket_id, channel_name, onData } = sub;
 
   const onLog = (
     state: Extract<EventTypes.SyncOrSub, { type: "syncOrSub"; command: "pushSubData" }>["state"],
@@ -28,7 +26,6 @@ export async function pushSubData(this: PubSubManager, sub: Subscription, err?:
     onLog("sub_not_found");
     return;
   }
-  const localFuncs = parseLocalFuncs(sub.localFuncs);
 
   if (err) {
     onLog("error");
@@ -39,40 +36,28 @@ export async function pushSubData(this: PubSubManager, sub: Subscription, err?:
   }
 
   sub.lastPushed = Date.now();
-  return new Promise(async (resolve, reject) => {
-    /* TODO: Retire subOne -> it's redundant */
 
-    const { data, err } = await this.getSubData(sub);
+  const { data, err: subDataError } = await this.getSubData(sub);
 
-    if (data) {
-      if (socket_id && this.sockets[socket_id]) {
-        log("Pushed " + data.length + " records to sub");
-        onLog("Emiting to socket");
-        this.sockets[socket_id].emit(channel_name, { data }, () => {
-          resolve(data);
-        });
+  if (subDataError !== undefined) {
+    onLog("fetch data error");
+  }
+  if (socket_id && this.sockets[socket_id]) {
+    log(`Pushing ${data?.length ?? 0} rows to socket`);
+    onLog("Emiting to socket");
+    this.sockets[socket_id].emit(
+      channel_name,
+      subDataError !== undefined ? { err: subDataError } : { data },
+      () => {
         /* TO DO: confirm receiving data or server will unsubscribe
           { data }, (cb)=> { console.log(cb) });
         */
-      } else if (localFuncs) {
-        onLog("pushed to local client");
-        localFuncs.onData(data);
-        resolve(data);
-      } else {
-        onLog("no client to push data to");
-      }
-    } else {
-      onLog("fetch data error");
-      const errObj = getSerialisableError(err) || "Unknown error fetching subscription data";
-      if (socket_id && this.sockets[socket_id]) {
-        this.sockets[socket_id].emit(channel_name, { err: errObj });
-      } else if (localFuncs) {
-        if (!localFuncs.onError) {
-          console.error("Uncaught subscription error", err);
-        }
-        localFuncs.onError?.(errObj);
-      }
-      reject(errObj);
-    }
-  });
+      },
+    );
+  } else if (onData) {
+    onLog("pushed to local client");
+    onData(data ?? [], subDataError);
+  } else {
+    onLog("no client to push data to");
+  }
 }

package/lib/PubSubManager/refreshTriggers.ts

@@ -2,27 +2,28 @@ import type { PubSubManager } from "./PubSubManager";
 
 export async function refreshTriggers(this: PubSubManager) {
   const start = Date.now();
-  const triggers: {
+  const triggers = await this.db.any<{
     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]
+    [this.dboBuilder.prostgles.appId],
   );
 
-  const oldTriggers = { ...this._triggers };
+  const oldTriggers = new Map(this._triggers);
 
-  this._triggers = {};
+  this._triggers = new Map();
   triggers.map((t) => {
-    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 });
+    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 });
     }
   });
 

package/lib/PublishParser/PublishParser.ts

@@ -104,37 +104,21 @@ export class PublishParser {
     command,
     clientReq,
   }: DboTableCommand): Promise<ParsedTableRule> {
+    const rules = await this.getParsedTableRule({ tableName, clientReq }, undefined);
     const clientInfo =
       clientReq && (await this.prostgles.authHandler.getSidAndUserFromRequest(clientReq));
     if (clientInfo === "new-session-redirect") {
       throw "new-session-redirect";
     }
-    const rules = await this.getValidatedRequestRule(
-      { tableName, command, clientReq },
-      clientInfo,
-      undefined,
-    );
+    this.validateRequestRule({ tableName, command, clientReq }, rules, undefined);
     return rules;
   }
 
-  async getValidatedRequestRule(
-    { tableName, command, clientReq }: DboTableCommand,
+  async getParsedTableRule(
+    { tableName, clientReq }: Pick<DboTableCommand, "tableName" | "clientReq">,
     clientInfo: AuthResultWithSID | undefined,
-    scope: PermissionScope | undefined,
   ): Promise<ParsedTableRule> {
-    if (!command || !tableName) throw "command OR tableName are missing";
-
-    const rule = RULE_TO_METHODS.find((rtms) => rtms.methods.some((v) => v === command));
-    if (!rule) {
-      throw "Invalid command: " + command;
-    }
-
-    if (scope) {
-      const tableScope = scope.tables;
-      if (!tableScope?.[tableName] || !tableScope[tableName][rule.sqlRule]) {
-        throw `Invalid or disallowed command: ${tableName}.${command}. The PermissionsScope does not allow this command.`;
-      }
-    }
+    if (!tableName) throw "tableName missing";
 
     /* Must be local request -> allow everything */
     if (!clientReq) {
@@ -150,17 +134,41 @@ export class PublishParser {
     /* Must be from socket. Must have a publish */
     if (!this.publish) throw "publish is missing";
 
+    const tableErrors = clientReq.socket?.prostgles?.tableSchemaErrors[tableName];
     /* Get any publish errors for socket */
-    const errorInfo = clientReq.socket?.prostgles?.tableSchemaErrors[tableName]?.[command];
-
-    if (errorInfo) throw errorInfo.error;
+    Object.values(tableErrors ?? {}).forEach((errorInfo) => {
+      throw errorInfo.error;
+    });
 
     const tableRule = await this.getTableRules({ tableName, clientReq }, clientInfo);
-    if (!tableRule)
+
+    if (!tableRule) {
       throw {
         stack: ["getValidatedRequestRule()"],
         message: "Invalid or disallowed table: " + tableName,
       };
+    }
+    return tableRule;
+  }
+
+  validateRequestRule(
+    { tableName, command }: DboTableCommand,
+    tableRule: ParsedTableRule,
+    scope: PermissionScope | undefined,
+  ) {
+    if (!command || !tableName) throw "command OR tableName are missing";
+
+    const rule = RULE_TO_METHODS.find((rtms) => rtms.methods.some((v) => v === command));
+    if (!rule) {
+      throw "Invalid command: " + command;
+    }
+
+    if (scope) {
+      const tableScope = scope.tables;
+      if (!tableScope?.[tableName] || !tableScope[tableName][rule.sqlRule]) {
+        throw `Invalid or disallowed command: ${tableName}.${command}. The PermissionsScope does not allow this command.`;
+      }
+    }
 
     if (command === "upsert") {
       if (!tableRule.update || !tableRule.insert) {
@@ -177,8 +185,6 @@ export class PublishParser {
         message: `Invalid or disallowed command: ${tableName}.${command}`,
       };
     }
-
-    return tableRule;
   }
 
   async getTableRules(

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -20,7 +20,7 @@ const SUBSCRIBE_METHODS = ["subscribe", "subscribeOne", "sync", "unsubscribe", "
 export async function getSchemaFromPublish(
   this: PublishParser,
   { userData, ...clientReq }: Args,
-  scope: PermissionScope | undefined
+  scope: PermissionScope | undefined,
 ): Promise<{
   schema: TableSchemaForClient;
   tables: DBSchemaTable[];
@@ -60,7 +60,7 @@ export async function getSchemaFromPublish(
         !tableNames.includes(fileTableName)
       ) {
         const isReferenced = this.prostgles.dboBuilder.tablesOrViews?.some((t) =>
-          t.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName))
+          t.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
         );
         if (isReferenced) {
           tableNames.unshift(fileTableName);
@@ -77,17 +77,17 @@ export async function getSchemaFromPublish(
             throw errMsg;
           }
 
-          const tableRules = await this.getTableRules({ clientReq, tableName }, clientInfo);
+          const parsedTableRule = await this.getTableRules({ clientReq, tableName }, clientInfo);
 
-          if (!tableRules || isEmpty(tableRules)) return;
-          if (!isObject(tableRules)) {
+          if (!parsedTableRule || isEmpty(parsedTableRule)) return;
+          if (!isObject(parsedTableRule)) {
             throw `Invalid tableRules for table ${tableName}. Expecting an object`;
           }
 
           schema[tableName] = {};
           const tableSchema = schema[tableName];
-          const methods = getKeys(tableRules).filter(
-            (m) => canSubscribe || !includes(SUBSCRIBE_METHODS, m)
+          const methods = getKeys(parsedTableRule).filter(
+            (m) => canSubscribe || !includes(SUBSCRIBE_METHODS, m),
           );
           let tableInfo: TableInfo | undefined;
           let tableColumns: DBSchemaTable["columns"] | undefined;
@@ -98,25 +98,25 @@ export async function getSchemaFromPublish(
               .map(async (method) => {
                 if (method === "sync") {
                   /* Pass sync info */
-                  tableSchema[method] = tableRules[method];
-                } else if (includes(getKeys(tableRules), method) && tableRules[method]) {
+                  tableSchema[method] = parsedTableRule[method];
+                } else if (includes(getKeys(parsedTableRule), method) && parsedTableRule[method]) {
                   //@ts-ignore
                   tableSchema[method] =
                     method === "insert" ?
-                      pickKeys(tableRules[method], ["allowedNestedInserts"])
+                      pickKeys(parsedTableRule[method], ["allowedNestedInserts"])
                     : ({} as AnyObject);
 
                   /* Test for issues with the common table CRUD methods () */
                   if (includes(TABLE_METHODS, method)) {
                     try {
-                      const parsedTableRule = await this.getValidatedRequestRule(
+                      this.validateRequestRule(
                         {
                           tableName,
                           command: method,
                           clientReq,
                         },
-                        clientInfo,
-                        scope
+                        parsedTableRule,
+                        scope,
                       );
                       if (this.prostgles.opts.testRulesOnConnect) {
                         await (this.dbo[tableName] as TableHandler)[method](
@@ -128,7 +128,7 @@ export async function getSchemaFromPublish(
                             ...clientReq,
                             isRemoteRequest: {},
                             testRule: true,
-                          }
+                          },
                         );
                       }
                     } catch (e) {
@@ -146,17 +146,17 @@ export async function getSchemaFromPublish(
                   }
 
                   if (method === "getInfo" || method === "getColumns") {
-                    const tableRules = await this.getValidatedRequestRule(
+                    this.validateRequestRule(
                       { tableName, command: method, clientReq },
-                      clientInfo,
-                      scope
+                      parsedTableRule,
+                      scope,
                     );
                     const res = await (this.dbo[tableName] as TableHandler)[method](
                       undefined,
                       undefined,
                       undefined,
-                      tableRules,
-                      { ...clientReq, isRemoteRequest: {} }
+                      parsedTableRule,
+                      { ...clientReq, isRemoteRequest: {} },
                     );
                     if (method === "getInfo") {
                       tableInfo = res as TableInfo;
@@ -165,7 +165,7 @@ export async function getSchemaFromPublish(
                     }
                   }
                 }
-              })
+              }),
           );
 
           if (tableInfo && tableColumns) {
@@ -175,7 +175,7 @@ export async function getSchemaFromPublish(
               columns: tableColumns,
             });
           }
-        })
+        }),
       );
     }
   } catch (error) {

package/lib/PublishParser/getTableRulesWithoutFileTable.ts

@@ -9,7 +9,6 @@ import type {
   ParsedPublishTable,
   PublishTableRule,
   PublishViewRule,
-  SubscribeRule,
 } from "./publishTypesAndUtils";
 import { type PublishObject, RULE_TO_METHODS } from "./publishTypesAndUtils";
 
@@ -17,7 +16,7 @@ export async function getTableRulesWithoutFileTable(
   this: PublishParser,
   { tableName, clientReq }: DboTable,
   clientInfo: AuthResultWithSID | undefined,
-  overridenPublish?: PublishObject
+  overridenPublish?: PublishObject,
 ): Promise<ParsedPublishTable | undefined> {
   if (!tableName) throw new Error("tableName is missing in getTableRules");
 
@@ -111,7 +110,7 @@ export async function getTableRulesWithoutFileTable(
         const rule = parsedTableRule[method];
 
         const ruleInfo = MY_RULES.find(
-          (r) => r.rule === method || (r.methods as readonly string[]).includes(method)
+          (r) => r.rule === method || (r.methods as readonly string[]).includes(method),
         );
         if (!ruleInfo) {
           let extraInfo = "";
@@ -120,7 +119,7 @@ export async function getTableRulesWithoutFileTable(
             RULE_TO_METHODS.find(
               (r) =>
                 r.table_only &&
-                (r.rule === method || (r.methods as readonly string[]).includes(method))
+                (r.rule === method || (r.methods as readonly string[]).includes(method)),
             )
           ) {
             extraInfo = "You've specified table rules to a view\n";
@@ -159,8 +158,8 @@ export async function getTableRulesWithoutFileTable(
         if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
           const sr = MY_RULES.find((r) => r.rule === subKey);
           if (sr && canSubscribe) {
-            parsedTableRule[subKey] = { ...(sr.no_limits) };
-            parsedTableRule.subscribeOne = { ...(sr.no_limits) };
+            parsedTableRule[subKey] = { ...sr.no_limits };
+            parsedTableRule.subscribeOne = { ...sr.no_limits };
           }
         }
       });

package/lib/initProstgles.ts

@@ -155,6 +155,24 @@ export const initProstgles = async function (
         }
       },
     });
+
+    /** Drop stale triggers */
+    await db
+      .any(
+        `
+      WITH active_app_ids AS (
+        SELECT DISTINCT (string_to_array(application_name, ' '))[2] AS app_id
+        FROM pg_stat_activity
+        WHERE application_name LIKE 'prostgles %'
+      )
+      DELETE FROM prostgles.app_triggers
+      WHERE app_id NOT IN (SELECT app_id FROM active_app_ids)
+      AND app_id != $1
+      `,
+        [this.appId],
+      )
+      .catch(() => {});
+
     this.db = db;
     this.pgp = pgp;
     this.isSuperUser = await getIsSuperUser(db);

package/lib/runClientRequest.ts

@@ -101,11 +101,12 @@ export const runClientRequest = async function (
   if (clientInfo === "new-session-redirect") {
     throw clientInfo;
   }
-  const parsedTableRule = await this.publishParser.getValidatedRequestRule(
-    { tableName, command, clientReq },
+
+  const parsedTableRule = await this.publishParser.getParsedTableRule(
+    { tableName, clientReq },
     clientInfo,
-    scope,
   );
+  this.publishParser.validateRequestRule({ tableName, command, clientReq }, parsedTableRule, scope);
 
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (!parsedTableRule) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.440",
+  "version": "4.2.441",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -57,7 +57,7 @@
     "pg": "^8.15.6",
     "pg-cursor": "^2.17.0",
     "pg-promise": "^12.6.0",
-    "prostgles-types": "^4.0.208"
+    "prostgles-types": "^4.0.209"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",