prostgles-server 4.2.265 → 4.2.267

package/lib/JSONBValidation/validate_jsonb_schema_sql.ts

@@ -1,5 +1,5 @@
 import { DATA_TYPES } from "prostgles-types";
-import { PubSubManager } from "../PubSubManager/PubSubManager";
+import { EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID } from "../PubSubManager/PubSubManagerUtils";
 
 const raiseException = (err: string) => `
 IF (context->'silent')::BOOLEAN = TRUE THEN
@@ -15,7 +15,7 @@ export const JSONB_DATA_TYPES = [...DATA_TYPES, "Lookup", "Lookup[]"] as const;
 export const validate_jsonb_schema_sql = `
 
 /* 
-* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
+* ${EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
 */
 
 CREATE OR REPLACE FUNCTION ${VALIDATE_SCHEMA_FUNCNAME}(
@@ -402,7 +402,7 @@ BEGIN
 END;
 $f$ LANGUAGE 'plpgsql' IMMUTABLE;
 
-COMMENT ON FUNCTION ${VALIDATE_SCHEMA_FUNCNAME}  /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+COMMENT ON FUNCTION ${VALIDATE_SCHEMA_FUNCNAME}  /* ${EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
 IS $$prostgles-server internal function used in column CHECK conditions to validate jsonb data against a column schema specified in tableConfig.
 Example usage:
 validate_jsonb_schema(

package/lib/Logging.ts

@@ -1,6 +1,7 @@
 import { AnyObject, ClientSchema, TableHandler } from "prostgles-types";
 import { LocalParams } from "./DboBuilder/DboBuilder";
-import { NotifTypeName, PubSubManagerTriggers } from "./PubSubManager/PubSubManager";
+import { PubSubManagerTriggers } from "./PubSubManager/PubSubManager";
+import type { NotifTypeName } from "./PubSubManager/PubSubManagerUtils";
 
 type ClientInfo = {
   socketId: string | undefined;

package/lib/PubSubManager/PubSubManager.ts

@@ -19,19 +19,16 @@ import { initialiseEventTriggers } from "./initialiseEventTriggers";
 import { initPubSubManager } from "./initPubSubManager";
 import { refreshTriggers } from "./refreshTriggers";
 
-import * as pgPromise from "pg-promise";
-import pg from "pg-promise/typescript/pg-subset";
-
 import {
   AnyObject,
   CHANNELS,
   FieldFilter,
   SelectParams,
-  SubscribeParams,
   WAL,
+  type SubscribeOptions,
 } from "prostgles-types";
 
-import { find, pickKeys } from "prostgles-types/dist/util";
+import { find, pickKeys } from "prostgles-types";
 import { LocalFuncs, getOnDataFunc, matchesLocalFuncs } from "../DboBuilder/ViewHandler/subscribe";
 import { EventTypes } from "../Logging";
 import { ParsedTableRule } from "../PublishParser/PublishParser";
@@ -39,18 +36,7 @@ import { syncData } from "../SyncReplication";
 import { addSub } from "./addSub";
 import { notifListener } from "./notifListener";
 import { pushSubData } from "./pushSubData";
-
-type PGP = pgPromise.IMain<{}, pg.IClient>;
-export const pgp: PGP = pgPromise({});
-export const asValue = (v: any) => pgp.as.format("$1", [v]);
-export const DEFAULT_SYNC_BATCH_SIZE = 50;
-
-export const log = (...args: any[]) => {
-  if (process.env.TEST_TYPE) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    console.log(...args);
-  }
-};
+import { log } from "./PubSubManagerUtils";
 
 export type BasicCallback = (err?: any, res?: any) => void;
 
@@ -109,7 +95,7 @@ export type ViewSubscriptionOptions = (
   }[];
 };
 
-export type SubscriptionParams = Pick<SubscribeParams, "throttle" | "throttleOpts"> & {
+export type SubscriptionParams = {
   socket_id?: string;
   channel_name: string;
 
@@ -124,22 +110,23 @@ export type SubscriptionParams = Pick<SubscribeParams, "throttle" | "throttleOpt
   /* Used as input */
   table_rules?: ParsedTableRule;
   filter: object;
-  params: SelectParams;
+  selectParams: SelectParams;
+  subscribeOptions: SubscribeOptions;
 
   localFuncs?: LocalFuncs;
   socket: PRGLIOSocket | undefined;
 
-  last_throttled: number;
+  lastPushed: number;
   is_throttling?: any;
   is_ready?: boolean;
 };
 
 export type Subscription = Pick<
   SubscriptionParams,
-  | "throttle"
+  | "selectParams"
+  | "subscribeOptions"
   | "is_throttling"
-  | "last_throttled"
-  | "throttleOpts"
+  | "lastPushed"
   | "channel_name"
   | "is_ready"
   | "localFuncs"
@@ -147,7 +134,6 @@ export type Subscription = Pick<
   | "socket_id"
   | "table_info"
   | "filter"
-  | "params"
   | "table_rules"
 > & {
   triggers: {
@@ -163,11 +149,6 @@ export type PubSubManagerTriggers = Record<string, { condition: string; hash: st
  * Used to facilitate table subscribe and sync
  */
 export class PubSubManager {
-  static DELIMITER = "|$prstgls$|" as const;
-
-  static EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID =
-    "prostgles internal query that should be excluded from schema watch " as const;
-
   public static create = async (dboBuilder: DboBuilder) => {
     const instance = new PubSubManager(dboBuilder);
     const result = await initPubSubManager.bind(instance)();
@@ -298,7 +279,7 @@ export class PubSubManager {
   getSubData = async (
     sub: Subscription
   ): Promise<{ data: any[]; err?: undefined } | { data?: undefined; err: any }> => {
-    const { table_info, filter, params, table_rules } = sub; //, subOne = false
+    const { table_info, filter, selectParams: params, table_rules } = sub; //, subOne = false
     const { name: table_name } = table_info;
 
     if (!this.dbo[table_name]?.find) {
@@ -402,21 +383,6 @@ export class PubSubManager {
   addTrigger = addTrigger.bind(this);
 }
 
-export const NOTIF_TYPE = {
-  data: "data_has_changed",
-  data_trigger_change: "data_watch_triggers_have_changed",
-  schema: "schema_has_changed",
-} as const;
-
-export type NotifTypeName = (typeof NOTIF_TYPE)[keyof typeof NOTIF_TYPE];
-export const NOTIF_CHANNEL = {
-  preffix: "prostgles_" as const,
-  getFull: (appID: string | undefined) => {
-    if (!appID) throw "No appID";
-    return NOTIF_CHANNEL.preffix + appID;
-  },
-};
-
 function debounce<Params extends any[]>(
   func: (...args: Params) => any,
   timeout: number
@@ -429,8 +395,3 @@ function debounce<Params extends any[]>(
     }, timeout);
   };
 }
-
-export const parseCondition = (condition: string): string =>
-  condition && condition.trim().length ? condition : "TRUE";
-
-export { omitKeys, pickKeys } from "prostgles-types";

package/lib/PubSubManager/PubSubManagerUtils.ts

@@ -0,0 +1,37 @@
+import * as pgPromise from "pg-promise";
+import pg from "pg-promise/typescript/pg-subset";
+
+export const NOTIF_TYPE = {
+  data: "data_has_changed",
+  data_trigger_change: "data_watch_triggers_have_changed",
+  schema: "schema_has_changed",
+} as const;
+
+export type NotifTypeName = (typeof NOTIF_TYPE)[keyof typeof NOTIF_TYPE];
+export const NOTIF_CHANNEL = {
+  preffix: "prostgles_" as const,
+  getFull: (appID: string | undefined) => {
+    if (!appID) throw "No appID";
+    return NOTIF_CHANNEL.preffix + appID;
+  },
+};
+
+export const parseCondition = (condition: string): string =>
+  condition && condition.trim().length ? condition : "TRUE";
+
+export const DELIMITER = "|$prstgls$|";
+
+export const EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID =
+  "prostgles internal query that should be excluded from schema watch ";
+
+type PGP = pgPromise.IMain<{}, pg.IClient>;
+export const pgp: PGP = pgPromise({});
+export const asValue = (v: any) => pgp.as.format("$1", [v]);
+export const DEFAULT_SYNC_BATCH_SIZE = 50;
+
+export const log = (...args: any[]) => {
+  if (process.env.TEST_TYPE) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    console.log(...args);
+  }
+};

package/lib/PubSubManager/addSub.ts

@@ -1,12 +1,8 @@
 import { SubscriptionChannels } from "prostgles-types";
-import {
-  BasicCallback,
-  parseCondition,
-  PubSubManager,
-  Subscription,
-  SubscriptionParams,
-} from "./PubSubManager";
 import { VoidFunction } from "../SchemaWatch/SchemaWatch";
+import { tout } from "./initPubSubManager";
+import { BasicCallback, PubSubManager, Subscription, SubscriptionParams } from "./PubSubManager";
+import { parseCondition } from "./PubSubManagerUtils";
 
 type AddSubscriptionParams = SubscriptionParams & {
   condition: string;
@@ -27,12 +23,11 @@ export async function addSub(
     localFuncs,
     table_rules,
     filter = {},
-    params = {},
+    selectParams = {},
     condition = "",
-    throttle = 0, //subOne = false,
     viewOptions,
     table_info,
-    throttleOpts,
+    subscribeOptions,
   } = subscriptionParams;
   const table_name = table_info.name;
 
@@ -43,16 +38,7 @@ export async function addSub(
     throw "addSub: cannot have socket AND func";
   }
 
-  let validated_throttle = subscriptionParams.throttle || 10;
-  const pubThrottle = table_rules?.subscribe?.throttle || 0;
-  if (pubThrottle && Number.isInteger(pubThrottle) && pubThrottle > 0) {
-    validated_throttle = pubThrottle;
-  }
-  if (throttle && Number.isInteger(throttle) && throttle >= pubThrottle) {
-    validated_throttle = throttle;
-  }
-
-  const channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.${JSON.stringify(params)}.${"m"}.sub`;
+  const channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.${JSON.stringify(selectParams)}.${"m"}.sub`;
   const mainTrigger = {
     table_name: table_name,
     condition: parseCondition(condition),
@@ -63,16 +49,16 @@ export async function addSub(
     channel_name,
     filter,
     localFuncs,
-    params,
-    last_throttled: 0,
+    selectParams: selectParams,
+    lastPushed: 0,
     socket,
-    throttleOpts,
+    subscribeOptions,
     table_info,
     is_ready: true,
     is_throttling: false,
     socket_id: socket?.id,
     table_rules,
-    throttle: validated_throttle,
+
     triggers: [mainTrigger],
   };
 
@@ -105,14 +91,21 @@ export async function addSub(
     }
   }
 
+  const { skipFirst, throttleOpts, throttle } = subscribeOptions;
+  const sendFirstData = async () => {
+    if (skipFirst) return;
+    if (throttleOpts?.skipFirst && throttle) {
+      await tout(throttle);
+    }
+    void this.pushSubData(newSub);
+  };
+
   if (localFuncs) {
     /**
      * 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
      */
-    result.sendFirstData = () => {
-      void this.pushSubData(newSub);
-    };
+    result.sendFirstData = sendFirstData;
   } else if (socket) {
     const removeListeners = () => {
       socket.removeAllListeners(channel_name);
@@ -121,9 +114,7 @@ export async function addSub(
     };
     removeListeners();
 
-    socket.once(result.channelNameReady, () => {
-      void this.pushSubData(newSub);
-    });
+    socket.once(result.channelNameReady, sendFirstData);
     socket.once(result.channelNameUnsubscribe, (_data: any, cb: BasicCallback) => {
       const res = "ok";
       this.subs = this.subs.filter((s) => {

package/lib/PubSubManager/addSync.ts

@@ -1,11 +1,6 @@
 import { find, tryCatchV2 } from "prostgles-types";
-import {
-  AddSyncParams,
-  BasicCallback,
-  DEFAULT_SYNC_BATCH_SIZE,
-  PubSubManager,
-  parseCondition,
-} from "./PubSubManager";
+import { AddSyncParams, BasicCallback, PubSubManager } from "./PubSubManager";
+import { DEFAULT_SYNC_BATCH_SIZE, parseCondition } from "./PubSubManagerUtils";
 
 /**
  * Returns a sync channel

package/lib/PubSubManager/addTrigger.ts

@@ -1,7 +1,8 @@
 import { tryCatchV2 } from "prostgles-types";
-import { asValue, PubSubManager, ViewSubscriptionOptions } from "./PubSubManager";
+import { type PubSubManager, ViewSubscriptionOptions } from "./PubSubManager";
 import * as crypto from "crypto";
 import { PRGLIOSocket } from "../DboBuilder/DboBuilderTypes";
+import { asValue, EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID } from "./PubSubManagerUtils";
 
 export async function addTrigger(
   this: PubSubManager,
@@ -31,7 +32,7 @@ export async function addTrigger(
     await this.db.tx((t) =>
       t.any(`
       BEGIN WORK;
-      /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+      /* ${EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
       /* why is this lock level needed? */
       --LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
 

package/lib/PubSubManager/deleteOrphanedTriggers.ts

@@ -1,4 +1,5 @@
 import { PubSubManager } from "./PubSubManager";
+import { EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID } from "./PubSubManagerUtils";
 
 export function deleteOrphanedTriggers(this: PubSubManager, tableName: string) {
   const activeConditions = (this.getTriggerInfo(tableName) ?? []).filter(
@@ -10,7 +11,7 @@ export function deleteOrphanedTriggers(this: PubSubManager, tableName: string) {
     .any(
       `
         /* Delete removed subscriptions */
-        /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+        /* ${EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
         DELETE FROM prostgles.app_triggers at
         WHERE EXISTS (
           SELECT 1

package/lib/PubSubManager/getPubSubManagerInitQuery.ts

@@ -1,14 +1,15 @@
-import { tryCatch } from "prostgles-types";
+import { tryCatchV2 } from "prostgles-types";
+import { DboBuilder } from "../DboBuilder/DboBuilder";
 import { pgp } from "../DboBuilder/DboBuilderTypes";
 import {
   asValue,
+  DELIMITER,
+  EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID,
   NOTIF_CHANNEL,
   NOTIF_TYPE,
-  PubSubManager,
-} from "./PubSubManager";
-const { version } = require("../../package.json");
+} from "./PubSubManagerUtils";
 import { getAppCheckQuery } from "./orphanTriggerCheck";
-import { DboBuilder } from "../DboBuilder/DboBuilder";
+const { version } = require("../../package.json");
 
 export const DB_OBJ_NAMES = {
   trigger_add_remove_func: "prostgles.trigger_add_remove_func",
@@ -35,8 +36,9 @@ const PROSTGLES_SCHEMA_VERSION_OK_QUERY = `
 
 const getInitQuery = (debugMode: boolean | undefined, pgVersion: number) => {
   const canReplaceTriggers = pgVersion >= 140006;
-  const createTriggerQuery = canReplaceTriggers
-    ? `CREATE OR REPLACE TRIGGER %1$I`
+  const createTriggerQuery =
+    canReplaceTriggers ?
+      `CREATE OR REPLACE TRIGGER %1$I`
     : `
     DROP TRIGGER IF EXISTS %1$I ON %2$s;
     CREATE TRIGGER %1$I
@@ -48,7 +50,7 @@ BEGIN; -- TRANSACTION ISOLATION LEVEL SERIALIZABLE;
 --SET  TRANSACTION ISOLATION LEVEL SERIALIZABLE;
 
 /* 
-* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
+* ${EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
 */
 
 DO
@@ -328,7 +330,7 @@ BEGIN
                             PERFORM pg_notify( 
                               ${asValue(NOTIF_CHANNEL.preffix)} || v_trigger.app_id , 
                               LEFT(concat_ws(
-                                ${asValue(PubSubManager.DELIMITER)},
+                                ${asValue(DELIMITER)},
 
                                 ${asValue(NOTIF_TYPE.data)}, 
                                 COALESCE(escaped_table, 'MISSING'), 
@@ -507,7 +509,7 @@ BEGIN
                             $q$
                                 DO $e$ 
                                 BEGIN
-                                    /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+                                    /* ${EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
                                     %s
 
                                 END $e$;
@@ -530,7 +532,7 @@ BEGIN
                     PERFORM pg_notify( 
                       ${asValue(NOTIF_CHANNEL.preffix)} || app.id, 
                       LEFT(concat_ws(
-                        ${asValue(PubSubManager.DELIMITER)}, 
+                        ${asValue(DELIMITER)}, 
                         ${asValue(NOTIF_TYPE.data_trigger_change)},
                         json_build_object(
                           'TG_OP', TG_OP, 
@@ -603,12 +605,12 @@ BEGIN
                       SELECT * 
                       FROM prostgles.apps 
                       WHERE tg_tag = ANY(watching_schema_tag_names)
-                      AND curr_query NOT ILIKE '%${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}%'
+                      AND curr_query NOT ILIKE '%${EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}%'
                     LOOP
                       PERFORM pg_notify( 
                         ${asValue(NOTIF_CHANNEL.preffix)} || app.id, 
                         LEFT(concat_ws(
-                          ${asValue(PubSubManager.DELIMITER)}, 
+                          ${asValue(DELIMITER)}, 
                           ${asValue(NOTIF_TYPE.schema)}, 
                           tg_tag , 
                           TG_event, 
@@ -639,40 +641,28 @@ COMMIT;
  * undefined returned if the database contains the apropriate prostgles schema
  */
 export const getPubSubManagerInitQuery = async function (
-  this: DboBuilder,
+  this: DboBuilder
 ): Promise<string | undefined> {
-  const versionNum = await this.db.one(
-    "SELECT current_setting('server_version_num')::int as val",
-  );
-  const initQuery = getInitQuery(
-    this.prostgles.opts.DEBUG_MODE,
-    versionNum.val,
-  );
-  const { schema_md5 = "none" } = await this.db.oneOrNone(
-    "SELECT md5($1) as schema_md5",
-    [initQuery.trim()],
-  );
+  const versionNum = await this.db.one("SELECT current_setting('server_version_num')::int as val");
+  const initQuery = getInitQuery(this.prostgles.opts.DEBUG_MODE, versionNum.val);
+  const { schema_md5 = "none" } = await this.db.oneOrNone("SELECT md5($1) as schema_md5", [
+    initQuery.trim(),
+  ]);
   const query = pgp.as.format(initQuery, { schema_md5, version });
   const existingSchema = await this.db.any(PROSTGLES_SCHEMA_EXISTS_QUERY);
   if (!existingSchema.length) {
-    console.log(
-      "getPubSubManagerInitQuery: No prostgles.versions table found. Creating...",
-    );
+    console.log("getPubSubManagerInitQuery: No prostgles.versions table found. Creating...");
     return query;
   }
-  const { existingSchemaVersions } = await tryCatch(async () => {
-    const existingSchemaVersions = await this.db.any(
-      PROSTGLES_SCHEMA_VERSION_OK_QUERY,
-      { schema_md5, version },
-    );
-    return {
-      existingSchemaVersions,
-    };
+  const { data: existingSchemaVersions } = await tryCatchV2(async () => {
+    const existingSchemaVersions = await this.db.any(PROSTGLES_SCHEMA_VERSION_OK_QUERY, {
+      schema_md5,
+      version,
+    });
+    return existingSchemaVersions;
   });
   if (!existingSchemaVersions?.length) {
-    console.log(
-      "getPubSubManagerInitQuery: Outdated prostgles schema. Re-creating...",
-    );
+    console.log("getPubSubManagerInitQuery: Outdated prostgles schema. Re-creating...");
     return query;
   }
 

package/lib/PubSubManager/initPubSubManager.ts

@@ -1,8 +1,9 @@
 import { isDefined, isObject } from "prostgles-types";
 import { PostgresNotifListenManager } from "../PostgresNotifListenManager";
 import { getWatchSchemaTagList } from "../SchemaWatch/getWatchSchemaTagList";
-import { NOTIF_CHANNEL, PubSubManager, asValue } from "./PubSubManager";
+import { type PubSubManager } from "./PubSubManager";
 import { getPubSubManagerInitQuery } from "./getPubSubManagerInitQuery";
+import { asValue, NOTIF_CHANNEL } from "./PubSubManagerUtils";
 export const REALTIME_TRIGGER_CHECK_QUERY =
   "prostgles-server internal query used to manage realtime triggers";
 

package/lib/PubSubManager/initialiseEventTriggers.ts

@@ -1,9 +1,10 @@
 import * as pgp from "pg-promise";
-import { PubSubManager } from "./PubSubManager";
+import { type 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";
+import { EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID } from "./PubSubManagerUtils";
 
 const asValue = (v: any) => pgp.as.format("$1", [v]);
 
@@ -27,7 +28,7 @@ export async function initialiseEventTriggers(this: PubSubManager) {
         BEGIN;--  ISOLATION LEVEL SERIALIZABLE;
         
         /**                                 
-         * ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
+         * ${EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
          *  Drop stale triggers
          * */
         DO

package/lib/PubSubManager/notifListener.ts

@@ -1,4 +1,7 @@
-import { log, NOTIF_TYPE, NotifTypeName, pickKeys, PubSubManager } from "./PubSubManager";
+import { pickKeys } from "prostgles-types";
+import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
+import { PubSubManager } from "./PubSubManager";
+import { DELIMITER, log, NOTIF_TYPE, type NotifTypeName } from "./PubSubManagerUtils";
 
 /* Relay relevant data to relevant subscriptions */
 export async function notifListener(this: PubSubManager, data: { payload: string }) {
@@ -9,7 +12,7 @@ export async function notifListener(this: PubSubManager, data: { payload: string
     return;
   }
 
-  const dataArr = str.split(PubSubManager.DELIMITER);
+  const dataArr = str.split(DELIMITER);
   const notifType = dataArr[0] as NotifTypeName;
 
   log(str);
@@ -128,10 +131,22 @@ export async function notifListener(this: PubSubManager, data: { payload: string
         )
       );
       activeAndReadySubs.forEach((sub) => {
-        const { throttle = 0, throttleOpts } = sub;
-        if (!throttleOpts?.skipFirst && sub.last_throttled <= Date.now() - throttle) {
-          sub.last_throttled = Date.now();
+        const { throttle = 0, throttleOpts, actions } = sub.subscribeOptions;
+
+        const commandLowerCase = (op_name?.toLowerCase() || "insert") as keyof NonNullable<
+          typeof actions
+        >;
+
+        const actionIsIgnored =
+          actions &&
+          !parseFieldFilter(actions, false, ["insert", "update", "delete"]).includes(
+            commandLowerCase as any
+          );
+        if (actionIsIgnored) {
+          return;
+        }
 
+        if (!throttleOpts?.skipFirst && sub.lastPushed <= Date.now() - throttle) {
           /* It is assumed the policy was checked before this point */
           void this.pushSubData(sub);
         } else if (!sub.is_throttling) {
@@ -139,7 +154,6 @@ export async function notifListener(this: PubSubManager, data: { payload: string
           sub.is_throttling = setTimeout(() => {
             log("throttling finished. pushSubData...");
             sub.is_throttling = null;
-            sub.last_throttled = Date.now();
             void this.pushSubData(sub);
           }, throttle);
         }

package/lib/PubSubManager/orphanTriggerCheck.ts

@@ -1,4 +1,5 @@
 import { PubSubManager } from "./PubSubManager";
+import { EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID } from "./PubSubManagerUtils";
 import { REALTIME_TRIGGER_CHECK_QUERY } from "./initPubSubManager";
 
 /**
@@ -32,7 +33,7 @@ export const getAppCheckQuery = () => `
   /* 
     ${queryIdentifier}
     ${REALTIME_TRIGGER_CHECK_QUERY} 
-    ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
+    ${EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
   */
   IF
     /* prostgles schema must exist */

package/lib/PubSubManager/pushSubData.ts

@@ -1,6 +1,7 @@
 import { parseLocalFuncs } from "../DboBuilder/ViewHandler/subscribe";
 import { EventTypes } from "../Logging";
-import { log, PubSubManager, Subscription } from "./PubSubManager";
+import { type PubSubManager, Subscription } from "./PubSubManager";
+import { log } from "./PubSubManagerUtils";
 
 export async function pushSubData(this: PubSubManager, sub: Subscription, err?: any) {
   const { socket_id, channel_name } = sub;
@@ -35,6 +36,7 @@ export async function pushSubData(this: PubSubManager, sub: Subscription, err?:
     return true;
   }
 
+  sub.lastPushed = Date.now();
   return new Promise(async (resolve, reject) => {
     /* TODO: Retire subOne -> it's redundant */
 
@@ -57,7 +59,6 @@ export async function pushSubData(this: PubSubManager, sub: Subscription, err?:
       } else {
         onLog("no client to push data to");
       }
-      // sub.last_throttled = Date.now();
     } else {
       onLog("fetch data error");
       const errObj = { _err_msg: err.toString(), err };

package/lib/PublishParser/getTableRulesWithoutFileTable.ts

@@ -2,7 +2,7 @@ import { getKeys, isObject } from "prostgles-types";
 import { AuthResultWithSID } from "../Auth/AuthTypes";
 import { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
 import { ViewHandler } from "../DboBuilder/ViewHandler/ViewHandler";
-import { DEFAULT_SYNC_BATCH_SIZE } from "../PubSubManager/PubSubManager";
+import { DEFAULT_SYNC_BATCH_SIZE } from "../PubSubManager/PubSubManagerUtils";
 import { PublishParser } from "./PublishParser";
 import {
   DboTable,

package/lib/SchemaWatch/SchemaWatch.ts

@@ -1,7 +1,7 @@
 import type { DboBuilder } from "../DboBuilder/DboBuilder";
 import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
 import type { OnReadyCallbackBasic } from "../initProstgles";
-import { PubSubManager, log } from "../PubSubManager/PubSubManager";
+import { EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID, log } from "../PubSubManager/PubSubManagerUtils";
 import {
   ValidatedWatchSchemaType,
   getValidatedWatchSchemaType,
@@ -47,10 +47,7 @@ export class SchemaWatch {
    * Fallback for watchSchema in case of not a superuser (cannot add db event listener)
    */
   onSchemaChangeFallback: OnSchemaChangeCallback | undefined = ({ command, query }) => {
-    if (
-      typeof query === "string" &&
-      query.includes(PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID)
-    ) {
+    if (typeof query === "string" && query.includes(EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID)) {
       log("Schema change event excluded from triggers due to EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID");
       return;
     }

package/lib/SyncReplication.ts

@@ -1,6 +1,7 @@
-import { PubSubManager, SyncParams, pickKeys, omitKeys, log } from "./PubSubManager/PubSubManager";
-import { OrderBy, WAL, AnyObject, SyncBatchParams } from "prostgles-types";
+import { AnyObject, OrderBy, SyncBatchParams, WAL, omitKeys, pickKeys } from "prostgles-types";
 import { TableHandler } from "./DboBuilder/TableHandler/TableHandler";
+import { PubSubManager, SyncParams } from "./PubSubManager/PubSubManager";
+import { log } from "./PubSubManager/PubSubManagerUtils";
 
 export type ClientSyncInfo = Partial<{
   c_fr: AnyObject;