prostgles-server 4.2.439 → 4.2.441

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -5,6 +5,7 @@ import type {
   FieldFilter,
   SelectParams,
   SubscribeParams,
+  SubscriptionChannels,
 } from "prostgles-types";
 import { asName, isObject, postgresToTsType } from "prostgles-types";
 import type { TableEvent } from "../../Logging";
@@ -23,7 +24,7 @@ import { getInfo } from "./getInfo";
 import { parseFieldFilter } from "./parseFieldFilter";
 import { prepareWhere } from "./prepareWhere";
 import { size } from "./size";
-import type { LocalFuncs } from "./subscribe";
+import type { OnData } from "./subscribe";
 import { subscribe } from "./subscribe";
 import { validateViewRules } from "./validateViewRules";
 import { escapeTSNames } from "../../utils/utils";
@@ -64,7 +65,7 @@ export class ViewHandler {
     tableOrViewInfo: TableSchema,
     dboBuilder: DboBuilder,
     tx?: { t: pgPromise.ITask<{}>; dbTX: TableHandlers },
-    joinPaths?: JoinPaths
+    joinPaths?: JoinPaths,
   ) {
     this.db = db;
     this.tx = tx;
@@ -84,7 +85,7 @@ export class ViewHandler {
     this.joins = this.dboBuilder.joins;
     this.columnsForTypes.map(({ name, udt_name, is_nullable }) => {
       this.tsColumnDefs.push(
-        `${escapeTSNames(name)}?: ${postgresToTsType(udt_name) as string} ${is_nullable ? " | null " : ""};`
+        `${escapeTSNames(name)}?: ${postgresToTsType(udt_name) as string} ${is_nullable ? " | null " : ""};`,
       );
     });
   }
@@ -192,7 +193,7 @@ export class ViewHandler {
     selectParams?: SelectParams,
     _param3_unused?: undefined,
     table_rules?: ParsedTableRule,
-    localParams?: LocalParams
+    localParams?: LocalParams,
   ): Promise<any> {
     try {
       const { limit, ...params } = selectParams ?? {};
@@ -205,7 +206,7 @@ export class ViewHandler {
         { ...params, limit: 1, returnType: "row" },
         undefined,
         table_rules,
-        localParams
+        localParams,
       );
       await this._log({
         command: "find",
@@ -226,58 +227,59 @@ export class ViewHandler {
   async subscribe(
     filter: Filter,
     params: SubscribeParams,
-    localFuncs: LocalFuncs
+    onData: OnData,
   ): Promise<{ unsubscribe: () => any }>;
 
   async subscribe(
     filter: Filter,
     params: SubscribeParams,
-    localFuncs: undefined,
-    table_rules: ParsedTableRule | undefined,
-    localParams: LocalParams
-  ): Promise<string>;
+    onData?: OnData,
+    table_rules?: ParsedTableRule,
+    localParams?: LocalParams,
+  ): Promise<SubscriptionChannels>;
 
   async subscribe(
     filter: Filter,
     params: SubscribeParams,
-    localFuncs?: LocalFuncs,
+    onData?: OnData,
     table_rules?: ParsedTableRule,
-    localParams?: LocalParams
-  ): Promise<{ unsubscribe: () => any } | string> {
-    //@ts-ignore
-    return subscribe.bind(this)(
+    localParams?: LocalParams,
+  ): Promise<{ unsubscribe: () => any } | SubscriptionChannels> {
+    const result = await subscribe.bind(this)(
       filter,
       params,
       //@ts-ignore
-      localFuncs,
+      onData,
       table_rules,
-      localParams
+      localParams,
     );
+    return result;
   }
 
   /* This should only be called from server */
   subscribeOne(
     filter: Filter,
     params: SubscribeParams,
-    localFunc: (item: AnyObject) => any
+    onData: (item: AnyObject | undefined, error?: unknown) => any,
   ): Promise<{ unsubscribe: () => any }>;
   subscribeOne(
     filter: Filter,
     params: SubscribeParams,
-    localFunc: undefined,
+    onData: undefined,
     table_rules: ParsedTableRule,
-    localParams: LocalParams
-  ): Promise<string>;
+    localParams: LocalParams,
+  ): Promise<SubscriptionChannels>;
   subscribeOne(
     filter: Filter,
     params: SubscribeParams = {},
-    localFunc?: (item: AnyObject) => any,
+    onData?: (item: AnyObject | undefined, error?: unknown) => void,
     table_rules?: ParsedTableRule,
-    localParams?: LocalParams
-  ): Promise<string | { unsubscribe: () => any }> {
-    //@ts-ignore
-    const func = localParams ? undefined : (rows: AnyObject[]) => localFunc(rows[0]);
-    //@ts-ignore
+    localParams?: LocalParams,
+  ): Promise<SubscriptionChannels | { unsubscribe: () => any }> {
+    const func =
+      localParams || !onData ? undefined : (
+        (rows: AnyObject[], error?: unknown) => onData(rows[0], error)
+      );
     return this.subscribe(filter, { ...params, limit: 2 }, func, table_rules, localParams);
   }
 
@@ -287,7 +289,7 @@ export class ViewHandler {
   getAllowedSelectFields(
     selectParams: FieldFilter = "*",
     allowed_cols: FieldFilter,
-    allow_empty = true
+    allow_empty = true,
   ): string[] {
     const all_columns = this.column_names.slice(0);
     let allowedFields = all_columns.slice(0),
@@ -317,7 +319,7 @@ export class ViewHandler {
   intersectColumns(
     allowedFields: FieldFilter,
     dissallowedFields: FieldFilter,
-    removeDisallowedFields = false
+    removeDisallowedFields = false,
   ): string[] {
     let result: string[] = [];
     if (allowedFields) {
@@ -338,7 +340,7 @@ export class ViewHandler {
   parseFieldFilter(
     fieldParams: FieldFilter = "*",
     allow_empty = true,
-    allowed_cols?: string[]
+    allowed_cols?: string[],
   ): string[] {
     return parseFieldFilter(fieldParams, allow_empty, allowed_cols ?? this.column_names.slice(0));
   }

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -1,68 +1,42 @@
 import type { AnyObject, SubscribeParams, SubscriptionChannels } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type {
-  Filter,
-  LocalParams} from "../DboBuilder";
-import {
-  getErrorAsObject,
-  getSerializedClientErrorFromPGError
-} from "../DboBuilder";
+import type { Filter, LocalParams } from "../DboBuilder";
+import { getErrorAsObject, getSerializedClientErrorFromPGError } from "../DboBuilder";
 import { getSubscribeRelatedTables } from "../getSubscribeRelatedTables";
 import type { NewQuery } from "../QueryBuilder/QueryBuilder";
 import type { ViewHandler } from "./ViewHandler";
 import { getValidatedSubscribeOptions } from "./getValidatedSubscribeOptions";
 
-type OnData = (items: AnyObject[]) => any;
-export type LocalFuncs =
-  | {
-      onData: OnData;
-      onError?: (error: any) => void;
-    }
-  | OnData;
+export type OnData = (items: AnyObject[], error?: unknown) => any;
 
-export const getOnDataFunc = (localFuncs: LocalFuncs | undefined): OnData | undefined => {
-  return typeof localFuncs === "function" ? localFuncs : localFuncs?.onData;
-};
 export const matchesLocalFuncs = (
-  localFuncs1: LocalFuncs | undefined,
-  localFuncs2: LocalFuncs | undefined
+  localFuncs1: OnData | undefined,
+  localFuncs2: OnData | undefined,
 ) => {
-  return localFuncs1 && localFuncs2 && getOnDataFunc(localFuncs1) === getOnDataFunc(localFuncs2);
-};
-export const parseLocalFuncs = (
-  localFuncs1: LocalFuncs | undefined
-): Extract<LocalFuncs, { onData: OnData }> | undefined => {
-  return (
-    !localFuncs1 ? undefined
-    : typeof localFuncs1 === "function" ?
-      {
-        onData: localFuncs1,
-      }
-    : localFuncs1
-  );
+  return localFuncs1 && localFuncs2 && localFuncs1 === localFuncs2;
 };
 
 async function subscribe(
   this: ViewHandler,
   filter: Filter,
   params: SubscribeParams,
-  localFuncs: LocalFuncs
+  onData: OnData,
 ): Promise<{ unsubscribe: () => any }>;
 async function subscribe(
   this: ViewHandler,
   filter: Filter,
   params: SubscribeParams,
-  localFuncs: undefined,
+  onData: undefined,
   table_rules: ParsedTableRule | undefined,
-  localParams: LocalParams
+  localParams: LocalParams,
 ): Promise<SubscriptionChannels>;
 async function subscribe(
   this: ViewHandler,
   filter: Filter,
   params: SubscribeParams,
-  localFuncs?: LocalFuncs,
+  onData?: OnData,
   table_rules?: ParsedTableRule,
-  localParams?: LocalParams
+  localParams?: LocalParams,
 ): Promise<{ unsubscribe: () => any } | SubscriptionChannels> {
   const start = Date.now();
   try {
@@ -74,12 +48,11 @@ async function subscribe(
       throw "subscribe not allowed within transactions";
     }
     const clientReq = localParams?.clientReq;
-    if (!clientReq && !localFuncs) {
-      throw " missing data. provide -> localFunc | localParams { socket } ";
+    if (!clientReq && !onData) {
+      throw " missing data. expecting onData | localParams { socket } ";
     }
-    if (clientReq?.socket && localFuncs) {
-      console.error({ localParams, localFuncs });
-      throw " Cannot have localFunc AND socket ";
+    if (clientReq?.socket && onData) {
+      throw " Cannot have onData and socket ";
     }
 
     const { throttle, throttleOpts, skipFirst, actions, skipChangedColumnsCheck, ...selectParams } =
@@ -93,7 +66,7 @@ async function subscribe(
       { ...selectParams, limit: 0 },
       undefined,
       table_rules,
-      { ...localParams, returnNewQuery: true }
+      { ...localParams, returnNewQuery: true },
     )) as unknown as NewQuery;
     const viewOptions = await getSubscribeRelatedTables.bind(this)({
       filter,
@@ -114,19 +87,20 @@ async function subscribe(
       selectParams: { ...selectParams },
       subscribeOptions: getValidatedSubscribeOptions(
         { actions, skipFirst, throttle, throttleOpts, skipChangedColumnsCheck },
-        table_rules?.subscribe
+        table_rules?.subscribe,
       ),
       lastPushed: 0,
       tracked_columns,
     } as const;
 
     const pubSubManager = await this.dboBuilder.getPubSubManager();
-    if (!localFuncs) {
+
+    if (!onData) {
       const { socket } = clientReq ?? {};
       const result = await pubSubManager.addSub({
         ...commonSubOpts,
         socket,
-        localFuncs: undefined,
+        onData: undefined,
         socket_id: socket?.id,
       });
 
@@ -141,13 +115,13 @@ async function subscribe(
       const { channelName, sendFirstData } = await pubSubManager.addSub({
         ...commonSubOpts,
         socket: undefined,
-        localFuncs,
+        onData,
         socket_id: undefined,
       });
 
       const unsubscribe = async () => {
         const pubSubManager = await this.dboBuilder.getPubSubManager();
-        pubSubManager.removeSubscription(channelName, { type: "local", localFuncs });
+        pubSubManager.removeSubscription(channelName, { type: "local", onData });
       };
       await this._log({
         command: "subscribe",

package/lib/Logging.ts

@@ -58,6 +58,8 @@ export namespace EventTypes {
     tableName: string;
     localParams?: LocalParams;
   };
+  type MapValue<M> = M extends Map<any, infer V> ? V : never;
+
   export type SyncOrSub = DebugInfo & {
     type: "syncOrSub";
     connectedSocketIds: string[];
@@ -83,7 +85,7 @@ export namespace EventTypes {
           command: "notifListener.Finished";
           op_name: string | undefined;
           condition_ids_str: string | undefined;
-          tableTriggers: PubSubManagerTriggers[string] | undefined;
+          tableTriggers: MapValue<PubSubManagerTriggers> | undefined;
           tableSyncs: string;
           state: "ok" | "error" | "no-triggers" | "invalid_condition_ids";
         })

package/lib/PubSubManager/PubSubManager.ts

@@ -20,11 +20,11 @@ import { initialiseEventTriggers } from "./initialiseEventTriggers";
 import { refreshTriggers } from "./refreshTriggers";
 
 import type { AnyObject, FieldFilter, SelectParams, WAL } from "prostgles-types";
-import { CHANNELS, type SubscribeOptions } from "prostgles-types";
+import { CHANNELS, getSerialisableError, type SubscribeOptions } from "prostgles-types";
 
 import { find, pickKeys } from "prostgles-types";
-import type { LocalFuncs } from "../DboBuilder/ViewHandler/subscribe";
-import { getOnDataFunc, matchesLocalFuncs } from "../DboBuilder/ViewHandler/subscribe";
+import type { OnData } from "../DboBuilder/ViewHandler/subscribe";
+import { matchesLocalFuncs } from "../DboBuilder/ViewHandler/subscribe";
 import type { EventTypes } from "../Logging";
 import type { ParsedTableRule } from "../PublishParser/PublishParser";
 import { syncData } from "../SyncReplication";
@@ -109,7 +109,7 @@ export type SubscriptionParams = {
   subscribeOptions: SubscribeOptions;
   tracked_columns: string[] | undefined;
 
-  localFuncs?: LocalFuncs;
+  onData?: OnData;
   socket: PRGLIOSocket | undefined;
 
   lastPushed: number;
@@ -125,7 +125,7 @@ export type Subscription = Pick<
   | "lastPushed"
   | "channel_name"
   | "is_ready"
-  | "localFuncs"
+  | "onData"
   | "socket"
   | "socket_id"
   | "table_info"
@@ -136,7 +136,7 @@ export type Subscription = Pick<
   triggers: AddTriggerParams[];
 };
 
-export type PubSubManagerTriggers = Record<string, { condition: string; hash: string }[]>;
+export type PubSubManagerTriggers = Map<string, { condition: string; hash: string }[]>;
 
 /**
  * Used to facilitate table subscribe and sync
@@ -165,7 +165,7 @@ export class PubSubManager {
    * Triggers used for sync/sub that reflect prostgles.app_triggers.
    * Updated through refreshTriggers()
    */
-  _triggers: PubSubManagerTriggers = {};
+  _triggers: PubSubManagerTriggers = new Map();
   sockets: Record<string, PRGLIOSocket> = {};
 
   subs: Subscription[] = [];
@@ -218,13 +218,13 @@ export class PubSubManager {
 
   getClientSubs({
     channel_name,
-    localFuncs,
+    onData,
     socket_id,
-  }: Pick<Subscription, "localFuncs" | "socket_id" | "channel_name">): Subscription[] {
+  }: Pick<Subscription, "onData" | "socket_id" | "channel_name">): Subscription[] {
     return this.subs.filter((s) => {
       return (
         s.channel_name === channel_name &&
-        (matchesLocalFuncs(localFuncs, s.localFuncs) || (socket_id && s.socket_id === socket_id))
+        (matchesLocalFuncs(onData, s.onData) || (socket_id && s.socket_id === socket_id))
       );
     });
   }
@@ -236,30 +236,31 @@ export class PubSubManager {
 
   removeSubscription = (
     channelName: string,
-    subInfo: { type: "local"; localFuncs: LocalFuncs } | { type: "ws"; socket: PRGLIOSocket },
+    subInfo: { type: "local"; onData: OnData } | { type: "ws"; socket: PRGLIOSocket },
   ) => {
     const matchingSubIdx = this.subs.findIndex(
       (s) =>
         s.channel_name === channelName &&
         (subInfo.type === "local" ?
-          getOnDataFunc(subInfo.localFuncs) === getOnDataFunc(s.localFuncs)
+          subInfo.onData === s.onData
         : subInfo.socket.id === s.socket?.id),
     );
-    if (matchingSubIdx > -1) {
-      const tableName = this.subs[matchingSubIdx]!.table_info.name;
-      const oldActiveTriggers = this.getActiveTriggers(tableName);
+    const matchingSub = this.subs[matchingSubIdx];
+    if (matchingSub) {
+      /** Ensure we check and refresh related table/view triggers as well */
+      const oldActiveTriggers = this.getAllActiveTriggers();
       this.subs.splice(matchingSubIdx, 1);
-      const newActiveTriggers = this.getActiveTriggers(tableName);
+      const newActiveTriggers = this.getAllActiveTriggers();
+      const tableNames = new Set(
+        [...oldActiveTriggers, ...newActiveTriggers].map((t) => t.tableName),
+      );
       if (newActiveTriggers.length < oldActiveTriggers.length) {
-        this.deleteOrphanedTriggers(tableName);
+        this.deleteOrphanedTriggers(tableNames);
       }
     } else {
-      console.error(
-        "Could not unsubscribe localFunc. Subscription might not have initialised yet",
-        {
-          channelName,
-        },
-      );
+      console.error("Could not unsubscribe. Subscription might not have initialised yet", {
+        channelName,
+      });
     }
   };
 
@@ -272,11 +273,11 @@ export class PubSubManager {
   notifListener = notifListener.bind(this);
 
   getTriggerInfo = (tableName: string) => {
-    const tableTriggerConditions = this._triggers[tableName]?.map((cond, idx) => ({
+    const tableTriggerConditions = this._triggers.get(tableName)?.map((triggerInfo, idx) => ({
       idx,
-      ...cond,
-      subs: this.getTriggerSubs(tableName, cond.condition),
-      syncs: this.getSyncs(tableName, cond.condition),
+      ...triggerInfo,
+      subs: this.getTriggerSubs(tableName, triggerInfo.condition),
+      syncs: this.getSyncs(tableName, triggerInfo.condition),
     }));
     return tableTriggerConditions;
   };
@@ -287,13 +288,20 @@ export class PubSubManager {
     return activeTriggers;
   };
 
-  getSubData = async (
-    sub: Subscription,
-  ): Promise<{ data: any[]; err?: undefined } | { data?: undefined; err: unknown }> => {
-    const { table_info, filter, selectParams: params, table_rules, socket, localFuncs } = sub; //, subOne = false
+  getAllActiveTriggers = () => {
+    return Array.from(this._triggers.keys()).flatMap((tableName) => {
+      return this.getActiveTriggers(tableName).map((triggerInfo) => ({
+        ...triggerInfo,
+        tableName,
+      }));
+    });
+  };
+
+  getSubData = async (sub: Subscription) => {
+    const { table_info, filter, selectParams: params, table_rules, socket, onData } = sub; //, subOne = false
     const { name: table_name } = table_info;
     const tableHandler = this.dbo[table_name];
-    if (!localFuncs && !socket) {
+    if (!onData && !socket) {
       throw new Error("Subscription must have either localFuncs or socket");
     }
     if (!tableHandler?.find) {
@@ -301,7 +309,7 @@ export class PubSubManager {
     }
 
     try {
-      const data = await tableHandler.find(
+      const data = (await tableHandler.find(
         filter,
         params,
         undefined,
@@ -309,10 +317,10 @@ export class PubSubManager {
         socket && {
           clientReq: { socket },
         },
-      );
+      )) as AnyObject[];
       return { data };
     } catch (err) {
-      return { err };
+      return { err: getSerialisableError(err) || "Unknown error fetching subscription data" };
     }
   };
 
@@ -401,23 +409,23 @@ export class PubSubManager {
   /** Throttle trigger deletes */
   deletingOrphanedTriggers:
     | {
-        tableNames: string[];
+        tableNames: Set<string>;
         timeout: NodeJS.Timeout;
       }
     | undefined;
-  deleteOrphanedTriggers = (latestTableName: string) => {
+  deleteOrphanedTriggers = (latestTableNames: Set<string>) => {
     this.deletingOrphanedTriggers ??= {
-      tableNames: [latestTableName],
+      tableNames: latestTableNames,
       timeout: setTimeout(() => {
         const tableNames = this.deletingOrphanedTriggers!.tableNames;
         this.deletingOrphanedTriggers = undefined;
-        void deleteOrphanedTriggers.bind(this)(tableNames);
+        void deleteOrphanedTriggers.bind(this)(Array.from(tableNames));
       }, 1000),
     };
 
-    if (!this.deletingOrphanedTriggers.tableNames.includes(latestTableName)) {
-      this.deletingOrphanedTriggers.tableNames.push(latestTableName);
-    }
+    latestTableNames.forEach((latestTableName) => {
+      this.deletingOrphanedTriggers?.tableNames.add(latestTableName);
+    });
   };
 
   addingTrigger: any;

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/addSync.ts

@@ -111,7 +111,7 @@ export async function addSync(
           }
         });
       } else {
-        console.warn("UNCLOSED DUPLICATE SYNC FOUND", existing.channel_name);
+        console.warn("addSync: Client tried to create a duplicate sync", existing.channel_name);
       }
 
       return newSync;

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 */