prostgles-server 2.0.153 → 2.0.156

package/lib/PubSubManager.ts

@@ -18,187 +18,187 @@ import { ClientExpressData, syncData } from "./SyncReplication";
 
 type PGP = pgPromise.IMain<{}, pg.IClient>;
 let pgp: PGP = pgPromise({
-    promiseLib: Bluebird
+  promiseLib: Bluebird
 });
 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){
-        console.log(...args)
-    }
+  if (process.env.TEST_TYPE) {
+    console.log(...args)
+  }
 }
 
 export type BasicCallback = (err?: any, res?: any) => void
 
 export type SyncParams = {
-    socket_id: string; 
-    channel_name: string;
-    table_name: string;
-    table_rules?: TableRule;
-    synced_field: string;
-    allow_delete: boolean;
-    id_fields: string[];
-    batch_size: number;
-    filter: object;
-    params: {
-        select: FieldFilter
-    };
-    condition: string;
-    wal?: WAL,
-    throttle?: number;
-    lr?: AnyObject;
-    last_synced: number;
-    is_syncing: boolean;
+  socket_id: string;
+  channel_name: string;
+  table_name: string;
+  table_rules?: TableRule;
+  synced_field: string;
+  allow_delete: boolean;
+  id_fields: string[];
+  batch_size: number;
+  filter: object;
+  params: {
+    select: FieldFilter
+  };
+  condition: string;
+  wal?: WAL,
+  throttle?: number;
+  lr?: AnyObject;
+  last_synced: number;
+  is_syncing: boolean;
 }
 
 type AddSyncParams = {
-    socket: any;
-    table_info: TableInfo;
-    table_rules: TableRule;
-    synced_field: string;
-    allow_delete?: boolean;
-    id_fields: string[];
-    filter: object;
-    params: {
-        select: FieldFilter
-    };
-    condition: string;
-    throttle?: number;
+  socket: any;
+  table_info: TableInfo;
+  table_rules: TableRule;
+  synced_field: string;
+  allow_delete?: boolean;
+  id_fields: string[];
+  filter: object;
+  params: {
+    select: FieldFilter
+  };
+  condition: string;
+  throttle?: number;
 }
 
 type SubscriptionParams = {
-    socket_id?: string;
-    channel_name: string;
-    table_name: string;
-    socket: PRGLIOSocket | undefined;
-    table_info: TableOrViewInfo;
-    table_rules?: TableRule;
-    filter: object;
-    params: SelectParams;
-    func?: (data: any) => any;
-    throttle?: number;
-    last_throttled: number;
-    is_throttling?: any;
-    is_ready?: boolean;
-    // subOne?: boolean;
+  socket_id?: string;
+  channel_name: string;
+  table_name: string;
+  socket: PRGLIOSocket | undefined;
+  table_info: TableOrViewInfo;
+  table_rules?: TableRule;
+  filter: object;
+  params: SelectParams;
+  func?: (data: any) => any;
+  throttle?: number;
+  last_throttled: number;
+  is_throttling?: any;
+  is_ready?: boolean;
+  // subOne?: boolean;
 }
 type AddSubscriptionParams = SubscriptionParams & {
-    condition: string;
+  condition: string;
 }
 
 export type PubSubManagerOptions = {
-    dboBuilder: DboBuilder;
-    db: DB;
-    dbo: DbHandler;
-    wsChannelNamePrefix?: string; 
-    pgChannelName?: string;
-    onSchemaChange?: (event: { command: string; query: string }) => void;
+  dboBuilder: DboBuilder;
+  db: DB;
+  dbo: DbHandler;
+  wsChannelNamePrefix?: string;
+  pgChannelName?: string;
+  onSchemaChange?: (event: { command: string; query: string }) => void;
 }
 
 export class PubSubManager {
-    static DELIMITER = '|$prstgls$|';
-
-    dboBuilder: DboBuilder;
-    db: DB;
-    dbo: DbHandler;
-    _triggers?: Record<string, string[]>;
-    sockets: any;
-    subs: { [ke: string]: { [ke: string]: { subs: SubscriptionParams[] } } };
-    syncs: SyncParams[];
-    socketChannelPreffix: string;
-    onSchemaChange?: ((event: { command: string; query: string }) => void) = undefined;
-
-    postgresNotifListenManager?: PostgresNotifListenManager;
-
-    private constructor (options: PubSubManagerOptions) {
-        const { db, dbo, wsChannelNamePrefix, pgChannelName, onSchemaChange, dboBuilder } = options;
-        if(!db || !dbo){
-            throw 'MISSING: db_pg, db';
-        }
-        this.db = db;
-        this.dbo = dbo;
-        this.onSchemaChange = onSchemaChange;
-        this.dboBuilder = dboBuilder;
-        
-        this.sockets = {};
-        this.subs = {};
-        this.syncs = [];
-        this.socketChannelPreffix = wsChannelNamePrefix || "_psqlWS_";
-
-        log("Created PubSubManager");
+  static DELIMITER = '|$prstgls$|';
+
+  dboBuilder: DboBuilder;
+  db: DB;
+  dbo: DbHandler;
+  _triggers?: Record<string, string[]>;
+  sockets: any;
+  subs: { [ke: string]: { [ke: string]: { subs: SubscriptionParams[] } } };
+  syncs: SyncParams[];
+  socketChannelPreffix: string;
+  onSchemaChange?: ((event: { command: string; query: string }) => void) = undefined;
+
+  postgresNotifListenManager?: PostgresNotifListenManager;
+
+  private constructor(options: PubSubManagerOptions) {
+    const { db, dbo, wsChannelNamePrefix, pgChannelName, onSchemaChange, dboBuilder } = options;
+    if (!db || !dbo) {
+      throw 'MISSING: db_pg, db';
     }
-
-    NOTIF_TYPE = {
-        data: "data_has_changed",
-        schema: "schema_has_changed"
-    }
-    NOTIF_CHANNEL = {
-        preffix: 'prostgles_',
-        getFull: (appID?: string) => {
-            if(!this.appID && !appID) throw "No appID";
-            return this.NOTIF_CHANNEL.preffix + (appID || this.appID);
-        }
+    this.db = db;
+    this.dbo = dbo;
+    this.onSchemaChange = onSchemaChange;
+    this.dboBuilder = dboBuilder;
+
+    this.sockets = {};
+    this.subs = {};
+    this.syncs = [];
+    this.socketChannelPreffix = wsChannelNamePrefix || "_psqlWS_";
+
+    log("Created PubSubManager");
+  }
+
+  NOTIF_TYPE = {
+    data: "data_has_changed",
+    schema: "schema_has_changed"
+  }
+  NOTIF_CHANNEL = {
+    preffix: 'prostgles_',
+    getFull: (appID?: string) => {
+      if (!this.appID && !appID) throw "No appID";
+      return this.NOTIF_CHANNEL.preffix + (appID || this.appID);
     }
+  }
 
-    private appID?: string;
-    
-    appCheckFrequencyMS = 10 * 1000;
-    appCheck?: ReturnType<typeof setInterval>;
-    
-    
+  private appID?: string;
 
-    //     ,datname
-    //     ,usename
-    //     ,client_hostname
-    //     ,client_port
-    //     ,backend_start
-    //     ,query_start
-    //     ,query
-    //     ,state
-
-    //     console.log(await _db.any(`
-    //         SELECT pid, application_name, state
-    //         FROM pg_stat_activity
-    //         WHERE application_name IS NOT NULL AND application_name != '' -- state = 'active';
-    //     `))
-
-
-    public static create = async (options: PubSubManagerOptions) => {
-        const res = new PubSubManager(options);
-        return await res.init();
-    }
+  appCheckFrequencyMS = 10 * 1000;
+  appCheck?: ReturnType<typeof setInterval>;
 
-    destroyed = false;
-    destroy = () => {
-        this.destroyed = true;
-        if(this.appCheck){
-            clearInterval(this.appCheck);
-        }
-        this.onSocketDisconnected();
-        // if(this.postgresNotifListenManager){
-        //     this.postgresNotifListenManager.stopListening();
-        // }
-        if(!this.postgresNotifListenManager) throw "this.postgresNotifListenManager missing"
-        this.postgresNotifListenManager.destroy();
-    }
 
-    canContinue = () => {
-        if(this.destroyed){
-            console.trace("Could not start destroyed instance");
-            return false
-        }
-        return true
+
+  //     ,datname
+  //     ,usename
+  //     ,client_hostname
+  //     ,client_port
+  //     ,backend_start
+  //     ,query_start
+  //     ,query
+  //     ,state
+
+  //     console.log(await _db.any(`
+  //         SELECT pid, application_name, state
+  //         FROM pg_stat_activity
+  //         WHERE application_name IS NOT NULL AND application_name != '' -- state = 'active';
+  //     `))
+
+
+  public static create = async (options: PubSubManagerOptions) => {
+    const res = new PubSubManager(options);
+    return await res.init();
+  }
+
+  destroyed = false;
+  destroy = () => {
+    this.destroyed = true;
+    if (this.appCheck) {
+      clearInterval(this.appCheck);
+    }
+    this.onSocketDisconnected();
+    // if(this.postgresNotifListenManager){
+    //     this.postgresNotifListenManager.stopListening();
+    // }
+    if (!this.postgresNotifListenManager) throw "this.postgresNotifListenManager missing"
+    this.postgresNotifListenManager.destroy();
+  }
+
+  canContinue = () => {
+    if (this.destroyed) {
+      console.trace("Could not start destroyed instance");
+      return false
     }
+    return true
+  }
 
-    appChecking = false;
-    init = async (): Promise<PubSubManager | undefined> => {
-        if(!this.canContinue()) return undefined;
+  appChecking = false;
+  init = async (): Promise<PubSubManager | undefined> => {
+    if (!this.canContinue()) return undefined;
 
-        try {
-            const schema_version = 4;
-           
-            const q = `
+    try {
+      const schema_version = 4;
+
+      const q = `
                 BEGIN; --  ISOLATION LEVEL SERIALIZABLE;-- TRANSACTION ISOLATION LEVEL SERIALIZABLE;
 
                 --SET  TRANSACTION ISOLATION LEVEL SERIALIZABLE;
@@ -698,48 +698,48 @@ export class PubSubManager {
                 COMMIT;
             `;
 
-            // const prgl_exists = await this.db.oneOrNone(`
-            //     DROP SCHEMA IF EXISTS prostgles CASCADE;
-            //     SELECT 1 FROM information_schema.schemata WHERE schema_name = 'prostgles'
-            // `);
-            
-            // if(!prgl_exists){
-            //     await this.db.any(q); 
-            // }
-            await this.db.any(q);
-            if(!this.canContinue()) return;
- 
- 
-            /* Prepare App id */
-            if(!this.appID){ 
-                const raw = await this.db.one(
-                    "INSERT INTO prostgles.apps (check_frequency_ms, watching_schema, application_name) VALUES($1, $2, current_setting('application_name')) RETURNING *; "
-                    , [this.appCheckFrequencyMS, Boolean(this.onSchemaChange)]
-                );
-                this.appID = raw.id;
-                
-                if(!this.appCheck) {
-                    
-                    this.appCheck = setInterval(async () => {
-                        let appQ = "";
-                        try {   //  drop owned by api
+      // const prgl_exists = await this.db.oneOrNone(`
+      //     DROP SCHEMA IF EXISTS prostgles CASCADE;
+      //     SELECT 1 FROM information_schema.schemata WHERE schema_name = 'prostgles'
+      // `);
+
+      // if(!prgl_exists){
+      //     await this.db.any(q); 
+      // }
+      await this.db.any(q);
+      if (!this.canContinue()) return;
 
-                            this.appChecking = true;
 
-                            let trgUpdateLastUsed = "",
-                                listeners = this.getActiveListeners();
+      /* Prepare App id */
+      if (!this.appID) {
+        const raw = await this.db.one(
+          "INSERT INTO prostgles.apps (check_frequency_ms, watching_schema, application_name) VALUES($1, $2, current_setting('application_name')) RETURNING *; "
+          , [this.appCheckFrequencyMS, Boolean(this.onSchemaChange)]
+        );
+        this.appID = raw.id;
 
-                            if(listeners.length){
-                                trgUpdateLastUsed = `
+        if (!this.appCheck) {
+
+          this.appCheck = setInterval(async () => {
+            let appQ = "";
+            try {   //  drop owned by api
+
+              this.appChecking = true;
+
+              let trgUpdateLastUsed = "",
+                listeners = this.getActiveListeners();
+
+              if (listeners.length) {
+                trgUpdateLastUsed = `
                                 UPDATE prostgles.app_triggers
                                 SET last_used = CASE WHEN (table_name, condition) IN (
-                                    ${listeners.map(l => ` ( ${asValue(l.table_name)}, ${asValue(l.condition)} ) ` ).join(", ") }
+                                    ${listeners.map(l => ` ( ${asValue(l.table_name)}, ${asValue(l.condition)} ) `).join(", ")}
                                 ) THEN NOW() ELSE last_used END
                                 WHERE app_id = ${asValue(this.appID)};
                                 `
-                            }
+              }
 
-                            appQ = `
+              appQ = `
                             
                                 DO $$
                                 BEGIN
@@ -812,46 +812,46 @@ export class PubSubManager {
                                 --COMMIT;
                                 END $$;
                             `
-                            await this.db.any(appQ);
-                            log("updated last_check");
-                        } catch (e) {
-                            console.error("appCheck FAILED: \n", e, appQ);
-                        }
-
-                        this.appChecking = false;
-                    }, 0.8 * this.appCheckFrequencyMS);
-                }
+              await this.db.any(appQ);
+              log("updated last_check");
+            } catch (e) {
+              console.error("appCheck FAILED: \n", e, appQ);
             }
 
-            this.postgresNotifListenManager = new PostgresNotifListenManager(this.db, this.notifListener, this.NOTIF_CHANNEL.getFull());
+            this.appChecking = false;
+          }, 0.8 * this.appCheckFrequencyMS);
+        }
+      }
 
-            await this.prepareTriggers()
+      this.postgresNotifListenManager = new PostgresNotifListenManager(this.db, this.notifListener, this.NOTIF_CHANNEL.getFull());
 
-            return this;
-             
-        } catch (e) {
-            console.error("PubSubManager init failed: ", e);
-        }
-    }
+      await this.prepareTriggers()
+
+      return this;
 
-    DB_OBJ_NAMES = {
-        trigger_add_remove_func: "prostgles.trigger_add_remove_func",
-        data_watch_func: "prostgles.prostgles_trigger_function",
-        schema_watch_func: "prostgles.schema_watch_func",
-        schema_watch_trigger: "prostgles_schema_watch_trigger_new"
+    } catch (e) {
+      console.error("PubSubManager init failed: ", e);
+    }
+  }
+
+  DB_OBJ_NAMES = {
+    trigger_add_remove_func: "prostgles.trigger_add_remove_func",
+    data_watch_func: "prostgles.prostgles_trigger_function",
+    schema_watch_func: "prostgles.schema_watch_func",
+    schema_watch_trigger: "prostgles_schema_watch_trigger_new"
+  }
+
+  static EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID = "prostgles internal query that should be excluded from "
+  prepareTriggers = async () => {
+    // SELECT * FROM pg_catalog.pg_event_trigger WHERE evtname
+    if (!this.appID) throw "prepareTriggers failed: this.appID missing";
+    if (this.dboBuilder.prostgles.opts.watchSchema && !(await isSuperUser(this.db))) {
+      console.warn("prostgles watchSchema requires superuser db user. Will not watch")
     }
 
-    static EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID = "prostgles internal query that should be excluded from "
-    prepareTriggers = async () => {
-        // SELECT * FROM pg_catalog.pg_event_trigger WHERE evtname
-        if(!this.appID) throw "prepareTriggers failed: this.appID missing";
-        if(this.dboBuilder.prostgles.opts.watchSchema && !(await isSuperUser(this.db))){
-            console.warn("prostgles watchSchema requires superuser db user. Will not watch")
-        }
+    try {
 
-        try {
-           
-            await this.db.any(`
+      await this.db.any(`
                 BEGIN;--  ISOLATION LEVEL SERIALIZABLE;
                 
                 /**                                 ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
@@ -952,606 +952,607 @@ export class PubSubManager {
 
                 COMMIT;
             `).catch(e => {
-                console.error("prepareTriggers failed: ", e);
-                throw e;
-            });
+        console.error("prepareTriggers failed: ", e);
+        throw e;
+      });
 
-            return true;
-             
-        } catch (e){
-            console.error("prepareTriggers failed: ", e);
-            throw e;
-        }
-    }
+      return true;
 
-    isReady(){
-        if(!this.postgresNotifListenManager) throw "this.postgresNotifListenManager missing";
-        return this.postgresNotifListenManager.isListening();
+    } catch (e) {
+      console.error("prepareTriggers failed: ", e);
+      throw e;
     }
+  }
 
-    getSubs(table_name: string, condition: string): SubscriptionParams[]{
-        return get(this.subs, [table_name, condition, "subs"])
-    }
+  isReady() {
+    if (!this.postgresNotifListenManager) throw "this.postgresNotifListenManager missing";
+    return this.postgresNotifListenManager.isListening();
+  }
 
-    getSyncs(table_name: string, condition: string){
-        return (this.syncs || [])
-            .filter((s: SyncParams) => s.table_name === table_name && s.condition === condition);
-    }
+  getSubs(table_name: string, condition: string): SubscriptionParams[] {
+    return get(this.subs, [table_name, condition, "subs"])
+  }
 
-    /* Relay relevant data to relevant subscriptions */
-    notifListener = async (data: { payload: string }) => {
-        const str = data.payload;
+  getSyncs(table_name: string, condition: string) {
+    return (this.syncs || [])
+      .filter((s: SyncParams) => s.table_name === table_name && s.condition === condition);
+  }
 
-        if(!str) {
-            console.error("Empty notif?")
-            return;
-        }
-        const dataArr = str.split(PubSubManager.DELIMITER),
-            notifType = dataArr[0];
+  /* Relay relevant data to relevant subscriptions */
+  notifListener = async (data: { payload: string }) => {
+    const str = data.payload;
 
-        log(str); 
+    if (!str) {
+      console.error("Empty notif?")
+      return;
+    }
+    const dataArr = str.split(PubSubManager.DELIMITER),
+      notifType = dataArr[0];
 
-        if(notifType === this.NOTIF_TYPE.schema){
-            if(this.onSchemaChange){
-                const command = dataArr[1],
-                    event_type = dataArr[2],
-                    query = dataArr[3];
+    log(str);
 
-                if(query){
-                    this.onSchemaChange({ command, query })
-                }
-            }
+    if (notifType === this.NOTIF_TYPE.schema) {
+      if (this.onSchemaChange) {
+        const command = dataArr[1],
+          event_type = dataArr[2],
+          query = dataArr[3];
 
-            return;
+        if (query) {
+          this.onSchemaChange({ command, query })
         }
-        
-        if(notifType !== this.NOTIF_TYPE.data){
-            console.error("Unexpected notif type: ", notifType);
-            return;
-        }
-
-        const table_name = dataArr[1],
-            op_name = dataArr[2],
-            condition_ids_str = dataArr[3];
-
-        // const triggers = await this.db.any("SELECT * FROM prostgles.triggers WHERE table_name = $1 AND id IN ($2:csv)", [table_name, condition_ids_str.split(",").map(v => +v)]);
-        // const conditions: string[] = triggers.map(t => t.condition);
-
-        log("PG Trigger ->", dataArr.join("__"))
-        if(
-            condition_ids_str && condition_ids_str.startsWith("error") &&
-            this._triggers && this._triggers[table_name] && this._triggers[table_name].length
-        ){
-            const pref = "INTERNAL ERROR. Schema might have changed";
-            console.error(`${pref}: ${condition_ids_str}`)
-            this._triggers[table_name].map(c => {
-                const subs = this.getSubs(table_name, c);
-                subs.map(s => {
-                    this.pushSubData(s, pref + ". Check server logs");
-                })
-            });
-        } else if(
-            condition_ids_str &&
-            condition_ids_str.split(",").length &&
-            !condition_ids_str.split(",").find((c: string )=> !Number.isInteger(+c)) &&
-            this._triggers && this._triggers[table_name] && this._triggers[table_name].length
-        ){
-            const idxs = condition_ids_str.split(",").map(v => +v);
-            const conditions = this._triggers[table_name].filter((c, i) => idxs.includes(i))
-
-            log("PG Trigger -> ",{ table_name, op_name, condition_ids_str, conditions }, this._triggers[table_name]);
-
-            conditions.map(condition => {
-                
-                const subs = this.getSubs(table_name, condition);
-                const syncs = this.getSyncs(table_name, condition);
-                
+      }
 
-                syncs.map((s) => {
-                    log("PG Trigger -> syncData. LR: ", s.lr);
-                    this.syncData(s);
-                });
+      return;
+    }
 
-                if(!subs){
+    if (notifType !== this.NOTIF_TYPE.data) {
+      console.error("Unexpected notif type: ", notifType);
+      return;
+    }
 
-                    // console.error(`sub missing for ${table_name} ${condition}`, this.triggers);
-                    // console.log(this.subs)
-                    return;
-                }
+    const table_name = dataArr[1],
+      op_name = dataArr[2],
+      condition_ids_str = dataArr[3];
+
+    // const triggers = await this.db.any("SELECT * FROM prostgles.triggers WHERE table_name = $1 AND id IN ($2:csv)", [table_name, condition_ids_str.split(",").map(v => +v)]);
+    // const conditions: string[] = triggers.map(t => t.condition);
+
+    log("PG Trigger ->", dataArr.join("__"))
+    if (
+      condition_ids_str && condition_ids_str.startsWith("error") &&
+      this._triggers && this._triggers[table_name] && this._triggers[table_name].length
+    ) {
+      const pref = "INTERNAL ERROR. Schema might have changed";
+      console.error(`${pref}: ${condition_ids_str}`)
+      this._triggers[table_name].map(c => {
+        const subs = this.getSubs(table_name, c);
+        subs.map(s => {
+          this.pushSubData(s, pref + ". Check server logs");
+        })
+      });
+    } else if (
+      condition_ids_str &&
+      condition_ids_str.split(",").length &&
+      !condition_ids_str.split(",").find((c: string) => !Number.isInteger(+c)) &&
+      this._triggers && this._triggers[table_name] && this._triggers[table_name].length
+    ) {
+      const idxs = condition_ids_str.split(",").map(v => +v);
+      const conditions = this._triggers[table_name].filter((c, i) => idxs.includes(i))
+
+      log("PG Trigger -> ", { table_name, op_name, condition_ids_str, conditions }, this._triggers[table_name]);
+
+      conditions.map(condition => {
+
+        const subs = this.getSubs(table_name, condition);
+        const syncs = this.getSyncs(table_name, condition);
+
+
+        syncs.map((s) => {
+          log("PG Trigger -> syncData. LR: ", s.lr);
+          this.syncData(s);
+        });
 
-                /* Throttle the subscriptions */                
-                for(var i = 0; i < subs.length; i++){
-                    var sub = subs[i];
-                    if(
-                        this.dbo[sub.table_name] &&
-                        sub.is_ready &&
-                        (sub.socket_id && this.sockets[sub.socket_id]) || sub.func
-                    ){
-                        const throttle = sub.throttle || 0;
-                        if(sub.last_throttled <= Date.now() - throttle){
-
-                            /* It is assumed the policy was checked before this point */
-                            this.pushSubData(sub);
-                            // sub.last_throttled = Date.now();
-                        } else if(!sub.is_throttling) {
-                            
-                            
-                            log("throttling sub")
-                            sub.is_throttling = setTimeout(() => {
-                                log("throttling finished. pushSubData...")
-                                sub.is_throttling = null;
-                                this.pushSubData(sub);
-                            }, throttle);// sub.throttle);
-                        }
-                    }
-                }
-            });
+        if (!subs) {
 
-        } else {
+          // console.error(`sub missing for ${table_name} ${condition}`, this.triggers);
+          // console.log(this.subs)
+          return;
+        }
 
-            // if(!this._triggers || !this._triggers[table_name] || !this._triggers[table_name].length){
-            //     console.warn(190, "Trigger sub not found. DROPPING TRIGGER", table_name, condition_ids_str, this._triggers);
-            //     this.dropTrigger(table_name);
-            // } else {
-            // }
-            console.warn(190, "Trigger sub issue: ", table_name, condition_ids_str, this._triggers);
+        /* Throttle the subscriptions */
+        for (var i = 0; i < subs.length; i++) {
+          var sub = subs[i];
+          if (
+            this.dbo[sub.table_name] &&
+            sub.is_ready &&
+            (sub.socket_id && this.sockets[sub.socket_id]) || sub.func
+          ) {
+            const throttle = sub.throttle || 0;
+            if (sub.last_throttled <= Date.now() - throttle) {
+
+              /* It is assumed the policy was checked before this point */
+              this.pushSubData(sub);
+              // sub.last_throttled = Date.now();
+            } else if (!sub.is_throttling) {
+
+
+              log("throttling sub")
+              sub.is_throttling = setTimeout(() => {
+                log("throttling finished. pushSubData...")
+                sub.is_throttling = null;
+                this.pushSubData(sub);
+              }, throttle);// sub.throttle);
+            }
+          }
         }
+      });
+
+    } else {
+
+      // if(!this._triggers || !this._triggers[table_name] || !this._triggers[table_name].length){
+      //     console.warn(190, "Trigger sub not found. DROPPING TRIGGER", table_name, condition_ids_str, this._triggers);
+      //     this.dropTrigger(table_name);
+      // } else {
+      // }
+      console.warn(190, "Trigger sub issue: ", table_name, condition_ids_str, this._triggers);
     }
+  }
 
 
-    pushSubData(sub: SubscriptionParams, err?: any){
-        if(!sub) throw "pushSubData: invalid sub";
-        const { table_name, filter, params, table_rules, socket_id, channel_name, func } = sub;  //, subOne = false 
+  pushSubData(sub: SubscriptionParams, err?: any) {
+    if (!sub) throw "pushSubData: invalid sub";
+    const { table_name, filter, params, table_rules, socket_id, channel_name, func } = sub;  //, subOne = false 
 
-        sub.last_throttled = Date.now();
+    sub.last_throttled = Date.now();
 
-        if(err){
-            if(socket_id){
-                this.sockets[socket_id].emit(channel_name, { err });
-            }
-            return true;
-        }
+    if (err) {
+      if (socket_id) {
+        this.sockets[socket_id].emit(channel_name, { err });
+      }
+      return true;
+    }
 
-        return new Promise(async (resolve, reject) => {
-            /* TODO: Retire subOne -> it's redundant */
-            // this.dbo[table_name][subOne? "findOne" : "find"](filter, params, null, table_rules)
-            if(!this.dbo?.[table_name]?.find) throw "1107 this.dbo[table_name].find";
+    return new Promise(async (resolve, reject) => {
+      /* TODO: Retire subOne -> it's redundant */
+      // this.dbo[table_name][subOne? "findOne" : "find"](filter, params, null, table_rules)
+      if (!this.dbo?.[table_name]?.find) throw "1107 this.dbo[table_name].find";
 
-            this.dbo?.[table_name]?.find?.(filter, params, undefined, table_rules)
-                .then(data => {
-                    
-                    if(socket_id && this.sockets[socket_id]){
-                        log("Pushed " + data.length + " records to sub")
-                        this.sockets[socket_id].emit(channel_name, { data }, () => {
-                            resolve(data);
-                        });
-                        /* TO DO: confirm receiving data or server will unsubscribe
-                                { data }, (cb)=> { console.log(cb) });
-                        */
-                    } else if(func) {
-                        func(data);
-                        resolve(data);
-                    }
-                    sub.last_throttled = Date.now();
-                }).catch(err => {
-                    const errObj = { _err_msg: err.toString(), err };
-                    if(socket_id && this.sockets[socket_id]){
-                        this.sockets[socket_id].emit(channel_name, { err: errObj });
-                    } else if(func) {
-                        func({ err: errObj });
-                    }
-                    reject(errObj)
-                });
+      this.dbo?.[table_name]?.find?.(filter, params, undefined, table_rules)
+        .then(data => {
+
+          if (socket_id && this.sockets[socket_id]) {
+            log("Pushed " + data.length + " records to sub")
+            this.sockets[socket_id].emit(channel_name, { data }, () => {
+              resolve(data);
+            });
+            /* TO DO: confirm receiving data or server will unsubscribe
+                    { data }, (cb)=> { console.log(cb) });
+            */
+          } else if (func) {
+            func(data);
+            resolve(data);
+          }
+          sub.last_throttled = Date.now();
+        }).catch(err => {
+          const errObj = { _err_msg: err.toString(), err };
+          if (socket_id && this.sockets[socket_id]) {
+            this.sockets[socket_id].emit(channel_name, { err: errObj });
+          } else if (func) {
+            func({ err: errObj });
+          }
+          reject(errObj)
         });
-    }
+    });
+  }
 
-    upsertSocket(socket: any, channel_name: string){
-        if(socket && !this.sockets[socket.id]){
-            this.sockets[socket.id] = socket;
-            socket.on("disconnect", () => this.onSocketDisconnected(socket));
-        }
+  upsertSocket(socket: any, channel_name: string) {
+    if (socket && !this.sockets[socket.id]) {
+      this.sockets[socket.id] = socket;
+      socket.on("disconnect", () => this.onSocketDisconnected(socket));
     }
+  }
+
+  syncTimeout?: ReturnType<typeof setTimeout>;
+  async syncData(sync: SyncParams, clientData?: ClientExpressData) {
+    return await syncData(this, sync, clientData);
+  }
+
+  /**
+   * Returns a sync channel
+   * A sync channel is unique per socket for each filter
+   */
+  async addSync(syncParams: AddSyncParams) {
+    const {
+      socket = null, table_info = null, table_rules, synced_field = null,
+      allow_delete = false, id_fields = [], filter = {},
+      params, condition = "", throttle = 0
+    } = syncParams || {};
+
+    let conditionParsed = this.parseCondition(condition);
+    if (!socket || !table_info) throw "socket or table_info missing";
+
+
+    const { name: table_name } = table_info,
+      channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.sync`;
+
+    if (!synced_field) throw "synced_field missing from table_rules";
+
+    this.upsertSocket(socket, channel_name);
+
+    const upsertSync = () => {
+      let newSync = {
+        channel_name,
+        table_name,
+        filter,
+        condition: conditionParsed,
+        synced_field,
+        id_fields,
+        allow_delete,
+        table_rules,
+        throttle: Math.max(throttle || 0, table_rules?.sync?.throttle || 0),
+        batch_size: get(table_rules, "sync.batch_size") || DEFAULT_SYNC_BATCH_SIZE,
+        last_throttled: 0,
+        socket_id: socket.id,
+        is_sync: true,
+        last_synced: 0,
+        lr: undefined,
+        table_info,
+        is_syncing: false,
+        wal: undefined,
+        socket,
+        params
+      };
+
+      /* Only a sync per socket per table per condition allowed */
+      this.syncs = this.syncs || [];
+      let existing = this.syncs.find(s => s.socket_id === socket.id && s.channel_name === channel_name);
+      if (!existing) {
+        this.syncs.push(newSync);
+        // console.log("Added SYNC");
+
+        socket.removeAllListeners(channel_name + "unsync");
+        socket.once(channel_name + "unsync", (_data: any, cb: BasicCallback) => {
+          this.onSocketDisconnected(socket, channel_name);
+          cb(null, { res: "ok" })
+        });
 
-    syncTimeout?: ReturnType<typeof setTimeout>;
-    async syncData(sync: SyncParams, clientData?: ClientExpressData){
-        return await syncData(this, sync, clientData);
-    }
+        socket.removeAllListeners(channel_name);
+        socket.on(channel_name, (data: any, cb: BasicCallback) => {
 
-    /**
-     * Returns a sync channel
-     * A sync channel is unique per socket for each filter
-     */
-    async addSync(syncParams: AddSyncParams){
-        const { 
-            socket = null, table_info = null, table_rules, synced_field = null, 
-            allow_delete = false, id_fields = [], filter = {}, 
-            params, condition = "", throttle = 0 
-        } = syncParams || {};
-
-        let conditionParsed = this.parseCondition(condition);
-        if(!socket || !table_info) throw "socket or table_info missing";
-        
+          if (!data) {
+            cb({ err: "Unexpected request. Need data or onSyncRequest" });
+            return;
+          }
+
+          /*
+          */
+
+          /* Server will:
+              1. Ask for last_synced  emit(onSyncRequest)
+              2. Ask for data >= server_synced    emit(onPullRequest)
+                  -> Upsert that data
+              2. Push data >= last_synced     emit(data.data)
+
+             Client will:
+              1. Send last_synced     on(onSyncRequest)
+              2. Send data >= server_synced   on(onPullRequest)
+              3. Send data on CRUD    emit(data.data | data.deleted)
+              4. Upsert data.data | deleted     on(data.data | data.deleted)
+          */
+
+          // if(data.data){
+          //     console.error("THIS SHOUKD NEVER FIRE !! NEW DATA FROM SYNC");
+          //     this.upsertClientData(newSync, data.data);
+          // } else 
+          if (data.onSyncRequest) {
+            // console.log("syncData from socket")
+            this.syncData(newSync, data.onSyncRequest);
+
+            // console.log("onSyncRequest ", socket._user)
+          } else {
+            console.error("Unexpected sync request data from client: ", data)
+          }
+        });
 
-        const { name: table_name } = table_info,
-            channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.sync`;
-
-        if(!synced_field) throw "synced_field missing from table_rules";
-            
-        this.upsertSocket(socket, channel_name);
-
-        const upsertSync = () => {
-                let newSync = {
-                    channel_name,
-                    table_name,
-                    filter,
-                    condition: conditionParsed,
-                    synced_field, 
-                    id_fields,
-                    allow_delete,
-                    table_rules,
-                    throttle: Math.max(throttle || 0, table_rules?.sync?.throttle || 0),
-                    batch_size: get(table_rules, "sync.batch_size") || DEFAULT_SYNC_BATCH_SIZE,
-                    last_throttled: 0,
-                    socket_id: socket.id,
-                    is_sync: true,
-                    last_synced: 0,
-                    lr: undefined,
-                    table_info,
-                    is_syncing: false,
-                    wal: undefined,
-                    socket,
-                    params
-                };
-
-                /* Only a sync per socket per table per condition allowed */
-                this.syncs = this.syncs || [];
-                let existing = this.syncs.find(s => s.socket_id === socket.id && s.channel_name === channel_name );
-                if(!existing){
-                    this.syncs.push(newSync);
-                    // console.log("Added SYNC");
-
-                    socket.removeAllListeners(channel_name + "unsync");
-                    socket.once(channel_name + "unsync", (_data: any, cb: BasicCallback) => {
-                        this.onSocketDisconnected(socket, channel_name);
-                        cb(null, { res: "ok" })
-                    });
-
-                    socket.removeAllListeners(channel_name);
-                    socket.on(channel_name, (data: any, cb: BasicCallback) => {
-
-                        if(!data){
-                            cb({ err: "Unexpected request. Need data or onSyncRequest"});
-                            return;
-                        }
+        // socket.emit(channel_name, { onSyncRequest: true }, (response) => {
+        //     console.log(response)
+        // });
+      } else {
+        console.error("UNCLOSED DUPLICATE SYNC FOUND");
+      }
 
-                        /*
-                        */
+      return newSync;
+    };
 
-                        /* Server will:
-                            1. Ask for last_synced  emit(onSyncRequest)
-                            2. Ask for data >= server_synced    emit(onPullRequest)
-                                -> Upsert that data
-                            2. Push data >= last_synced     emit(data.data)
-
-                           Client will:
-                            1. Send last_synced     on(onSyncRequest)
-                            2. Send data >= server_synced   on(onPullRequest)
-                            3. Send data on CRUD    emit(data.data | data.deleted)
-                            4. Upsert data.data | deleted     on(data.data | data.deleted)
-                        */
 
-                        // if(data.data){
-                        //     console.error("THIS SHOUKD NEVER FIRE !! NEW DATA FROM SYNC");
-                        //     this.upsertClientData(newSync, data.data);
-                        // } else 
-                        if(data.onSyncRequest){
-                            // console.log("syncData from socket")
-                            this.syncData(newSync, data.onSyncRequest);
-
-                            // console.log("onSyncRequest ", socket._user)
-                        } else {
-                            console.error("Unexpected sync request data from client: ", data)
-                        }
-                    });
-
-                    // socket.emit(channel_name, { onSyncRequest: true }, (response) => {
-                    //     console.log(response)
-                    // });
-                } else {
-                    console.error("UNCLOSED DUPLICATE SYNC FOUND");
-                }
+    // const { min_id, max_id, count, max_synced } = params;
 
-                return newSync;
-            };
-            
+    let sync = upsertSync();
 
-        // const { min_id, max_id, count, max_synced } = params;
+    await this.addTrigger({ table_name, condition: conditionParsed });
 
-        let sync = upsertSync();
-        
-        await this.addTrigger({ table_name, condition: conditionParsed });
+    return channel_name;
+  }
 
-        return channel_name;
-    }
+  parseCondition = (condition: string): string => Boolean(condition && condition.trim().length) ? condition : "TRUE"
 
-    parseCondition = (condition: string): string => Boolean(condition && condition.trim().length)? condition : "TRUE"
+  /* Must return a channel for socket */
+  /* The distinct list of channel names must have a corresponding trigger in the database */
+  async addSub(subscriptionParams: Omit<AddSubscriptionParams, "channel_name">) {
+    const {
+      socket, func = null, table_info = null, table_rules, filter = {},
+      params = {}, condition = "", throttle = 0  //subOne = false, 
+    } = subscriptionParams || {};
 
-    /* Must return a channel for socket */
-    /* The distinct list of channel names must have a corresponding trigger in the database */
-    async addSub(subscriptionParams: Omit<AddSubscriptionParams, "channel_name">){
-        const { 
-            socket, func = null, table_info = null, table_rules, filter = {}, 
-            params = {}, condition = "", throttle = 0  //subOne = false, 
-        } = subscriptionParams || {};
+    let validated_throttle = subscriptionParams.throttle || 10;
+    if ((!socket && !func) || !table_info) throw "socket/func or table_info missing";
 
-        let validated_throttle = subscriptionParams.throttle || 10;
-        if((!socket && !func) || !table_info) throw "socket/func or table_info missing";
+    const pubThrottle = get(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 pubThrottle = get(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;
+    let channel_name = `${this.socketChannelPreffix}.${table_info.name}.${JSON.stringify(filter)}.${JSON.stringify(params)}.${"m"}.sub`;  //.${subOne? "o" : "m"}.sub`;
+
+    this.upsertSocket(socket, channel_name);
+
+    const upsertSub = (newSubData: { table_name: string, condition: string, is_ready: boolean }) => {
+      const { table_name, condition: _cond, is_ready = false } = newSubData,
+        condition = this.parseCondition(_cond),
+        newSub: SubscriptionParams = {
+          socket,
+          table_name: table_info.name,
+          table_info,
+          filter,
+          params,
+          table_rules,
+          channel_name,
+          func: func ? func : undefined,
+          socket_id: socket?.id,
+          throttle: validated_throttle,
+          is_throttling: null,
+          last_throttled: 0,
+          is_ready,
+          // subOne
+        };
+
+      this.subs[table_name] = this.subs[table_name] || {};
+      this.subs[table_name][condition] = this.subs[table_name][condition] || { subs: [] };
+      this.subs[table_name][condition].subs = this.subs[table_name][condition].subs || [];
+
+      // console.log("1034 upsertSub", this.subs)
+      const sub_idx = this.subs[table_name][condition].subs.findIndex(s =>
+        s.channel_name === channel_name &&
+        (
+          socket && s.socket_id === socket.id ||
+          func && s.func === func
+        )
+      );
+      if (sub_idx < 0) {
+        this.subs[table_name][condition].subs.push(newSub);
+        if (socket) {
+          const chnUnsub = channel_name + "unsubscribe";
+          socket.removeAllListeners(chnUnsub);
+          socket.once(chnUnsub, (_data: any, cb: BasicCallback) => {
+            const res = this.onSocketDisconnected(socket, channel_name);
+            cb(null, { res });
+          });
         }
-        
-        let channel_name = `${this.socketChannelPreffix}.${table_info.name}.${JSON.stringify(filter)}.${JSON.stringify(params)}.${"m"}.sub`;  //.${subOne? "o" : "m"}.sub`;
+      } else {
+        this.subs[table_name][condition].subs[sub_idx] = newSub;
+      }
 
-        this.upsertSocket(socket, channel_name);
-        
-        const upsertSub = (newSubData: { table_name: string, condition: string, is_ready: boolean }) => {
-                const { table_name, condition: _cond, is_ready = false } = newSubData,
-                    condition = this.parseCondition(_cond),
-                    newSub: SubscriptionParams = {
-                        socket,
-                        table_name: table_info.name,
-                        table_info,
-                        filter, 
-                        params, 
-                        table_rules,
-                        channel_name, 
-                        func: func? func : undefined,
-                        socket_id: socket?.id,
-                        throttle: validated_throttle,
-                        is_throttling: null,
-                        last_throttled: 0,
-                        is_ready,
-                        // subOne
-                    };
-
-                this.subs[table_name] = this.subs[table_name] || {};
-                this.subs[table_name][condition] = this.subs[table_name][condition] || { subs: [] };
-                this.subs[table_name][condition].subs = this.subs[table_name][condition].subs || [];
-
-                // console.log("1034 upsertSub", this.subs)
-                const sub_idx = this.subs[table_name][condition].subs.findIndex(s => 
-                    s.channel_name === channel_name && 
-                    (
-                        socket && s.socket_id === socket.id ||
-                        func && s.func === func
-                    )
-                );
-                if(sub_idx < 0){
-                    this.subs[table_name][condition].subs.push(newSub);
-                    if(socket){
-                        const chnUnsub = channel_name + "unsubscribe";
-                        socket.removeAllListeners(chnUnsub);
-                        socket.once(chnUnsub, (_data: any, cb: BasicCallback) =>{
-                            const res = this.onSocketDisconnected(socket, channel_name);
-                            cb(null, { res });
-                        });
-                    }
-                } else {
-                    this.subs[table_name][condition].subs[sub_idx] = newSub;
-                }
+      if (is_ready) {
+        this.pushSubData(newSub);
+      }
+    };
 
-                if(is_ready){
-                    this.pushSubData(newSub);
-                }
-            };
-            
 
-        if(table_info.is_view && table_info.parent_tables){
-            if(table_info.parent_tables.length){
-                
-                let _condition = "TRUE";
-                table_info.parent_tables.map(async table_name => {
-                    
-                    upsertSub({
-                        table_name,
-                        condition: _condition,
-                        is_ready: true
-                    });
-
-                    await this.addTrigger({
-                        table_name, 
-                        condition: _condition
-                    });
-
-                    upsertSub({
-                        table_name,
-                        condition: _condition,
-                        is_ready: true
-                    });
-                });
-
-                return channel_name
-            } else {
-                throw "PubSubManager: view parent_tables missing";
-            }
-            /*  */
-        } else {
-            /* Just a table, add table + condition trigger */
-            // console.log(table_info, 202);
-            
-            upsertSub({
-                table_name: table_info.name,
-                condition: this.parseCondition(condition),
-                is_ready: false
-            });
-            await this.addTrigger({
-                table_name: table_info.name,
-                condition:  this.parseCondition(condition),
-            });
-            upsertSub({
-                table_name: table_info.name,
-                condition:  this.parseCondition(condition),
-                is_ready: true
-            });
+    if (table_info.is_view && table_info.parent_tables) {
+      if (table_info.parent_tables.length) {
 
-            return channel_name
-        }
-    }
+        let _condition = "TRUE";
+        table_info.parent_tables.map(async table_name => {
 
-    removeLocalSub(table_name: string, condition: string, func: (items: object[])=>any){
-        let cond = this.parseCondition(condition);
-        if(get(this.subs, [table_name, cond, "subs"])){
-            this.subs[table_name][cond].subs.map((sub, i) => {
-                if(
-                    sub.func && sub.func === func
-                ){
-                    this.subs[table_name][cond].subs.splice(i, 1);
-                }
-            });
-        } else {
-            console.error("Could not unsubscribe. Subscription might not have initialised yet")
-        }
-    }
+          upsertSub({
+            table_name,
+            condition: _condition,
+            is_ready: true
+          });
 
-    getActiveListeners = (): { table_name: string; condition: string }[] => {
-        let result: { table_name: string; condition: string }[] = [];
-        const upsert = (t: string, c: string) => {
-            if(!result.find(r => r.table_name === t && r.condition === c)){
-                result.push({ table_name: t, condition: c });
-            }
-        }
-        (this.syncs  || []).map(s => {
-            upsert(s.table_name, s.condition)
-        });
-        Object.keys(this.subs || {}).map(table_name => {
-            Object.keys(this.subs[table_name] || {}).map(condition => {
-                if(this.subs[table_name][condition].subs.length) {
-                    upsert(table_name, condition);
-                }
-            });
+          await this.addTrigger({
+            table_name,
+            condition: _condition
+          });
+
+          upsertSub({
+            table_name,
+            condition: _condition,
+            is_ready: true
+          });
         });
 
-        return result;
+        return channel_name
+      } else {
+        throw "PubSubManager: view parent_tables missing";
+      }
+      /*  */
+    } else {
+      /* Just a table, add table + condition trigger */
+      // console.log(table_info, 202);
+
+      upsertSub({
+        table_name: table_info.name,
+        condition: this.parseCondition(condition),
+        is_ready: false
+      });
+      await this.addTrigger({
+        table_name: table_info.name,
+        condition: this.parseCondition(condition),
+      });
+      upsertSub({
+        table_name: table_info.name,
+        condition: this.parseCondition(condition),
+        is_ready: true
+      });
+
+      return channel_name
     }
-
-    onSocketDisconnected(socket?: any, channel_name?: string){
-        // process.on('warning', e => {
-        //     console.warn(e.stack)
-        // });
-        // console.log("onSocketDisconnected", channel_name, this.syncs)
-        if(this.subs){
-            Object.keys(this.subs).map(table_name => {
-                Object.keys(this.subs[table_name]).map(condition => {
-                    this.subs[table_name][condition].subs.map((sub, i) => {
-
-                        /**
-                         * If a channel name is specified then delete triggers 
-                         */
-                        if(
-                            (socket && sub.socket_id === socket.id) &&
-                            (!channel_name || sub.channel_name === channel_name)
-                        ){
-                            this.subs[table_name][condition].subs.splice(i, 1);
-                            if(!this.subs[table_name][condition].subs.length) {
-                                delete this.subs[table_name][condition];
-
-                                if(isEmpty(this.subs[table_name])){
-                                    delete this.subs[table_name];
-                                }
-                            }
-                        }
-                    });
-                })
-            });
+  }
+
+  removeLocalSub(table_name: string, condition: string, func: (items: object[]) => any) {
+    let cond = this.parseCondition(condition);
+    if (get(this.subs, [table_name, cond, "subs"])) {
+      this.subs[table_name][cond].subs.map((sub, i) => {
+        if (
+          sub.func && sub.func === func
+        ) {
+          this.subs[table_name][cond].subs.splice(i, 1);
         }
-
-        if(this.syncs){
-            this.syncs = this.syncs.filter(s => {
-                if(channel_name){
-                    return (socket && s.socket_id !== socket.id) || s.channel_name !== channel_name
+      });
+    } else {
+      console.error("Could not unsubscribe. Subscription might not have initialised yet")
+    }
+  }
+
+  getActiveListeners = (): { table_name: string; condition: string }[] => {
+    let result: { table_name: string; condition: string }[] = [];
+    const upsert = (t: string, c: string) => {
+      if (!result.find(r => r.table_name === t && r.condition === c)) {
+        result.push({ table_name: t, condition: c });
+      }
+    }
+    (this.syncs || []).map(s => {
+      upsert(s.table_name, s.condition)
+    });
+    Object.keys(this.subs || {}).map(table_name => {
+      Object.keys(this.subs[table_name] || {}).map(condition => {
+        if (this.subs[table_name][condition].subs.length) {
+          upsert(table_name, condition);
+        }
+      });
+    });
+
+    return result;
+  }
+
+  onSocketDisconnected(socket?: PRGLIOSocket, channel_name?: string) {
+    // process.on('warning', e => {
+    //     console.warn(e.stack)
+    // });
+    // console.log("onSocketDisconnected", channel_name, this.syncs)
+    if (this.subs) {
+      Object.keys(this.subs).map(table_name => {
+        Object.keys(this.subs[table_name]).map(condition => {
+          this.subs[table_name][condition].subs.map((sub, i) => {
+
+            /**
+             * If a channel name is specified then delete triggers 
+             */
+            if (
+              (socket && sub.socket_id === socket.id) &&
+              (!channel_name || sub.channel_name === channel_name)
+            ) {
+              this.subs[table_name][condition].subs.splice(i, 1);
+              if (!this.subs[table_name][condition].subs.length) {
+                delete this.subs[table_name][condition];
+
+                if (isEmpty(this.subs[table_name])) {
+                  delete this.subs[table_name];
                 }
+              }
+            }
+          });
+        })
+      });
+    }
 
-                return (socket && s.socket_id !== socket.id)
-            });
+    if (this.syncs) {
+      this.syncs = this.syncs.filter(s => {
+        const matchesSocket = Boolean(socket && s.socket_id !== socket.id)
+        if (channel_name) {
+          return matchesSocket || s.channel_name !== channel_name
         }
 
-        if(!socket){
+        return matchesSocket;
+      });
+    }
 
-        } else if(!channel_name){
-            delete this.sockets[socket.id];
-        } else {
-            socket.removeAllListeners(channel_name);
-            socket.removeAllListeners(channel_name + "unsync");
-            socket.removeAllListeners(channel_name + "unsubscribe");
-        }
+    if (!socket) {
 
-        return "ok";
+    } else if (!channel_name) {
+      delete this.sockets[socket.id];
+    } else {
+      socket.removeAllListeners(channel_name);
+      socket.removeAllListeners(channel_name + "unsync");
+      socket.removeAllListeners(channel_name + "unsubscribe");
     }
 
+    return "ok";
+  }
 
-    checkIfTimescaleBug = async (table_name: string) => {
-        const schema = "_timescaledb_catalog", 
-            res = await this.db.oneOrNone("SELECT EXISTS( \
+
+  checkIfTimescaleBug = async (table_name: string) => {
+    const schema = "_timescaledb_catalog",
+      res = await this.db.oneOrNone("SELECT EXISTS( \
             SELECT * \
             FROM information_schema.tables \
             WHERE 1 = 1 \
                 AND table_schema = ${schema} \
                 AND table_name = 'hypertable' \
         );", { schema });
-        if(res.exists){
-            let isHyperTable = await this.db.any("SELECT * FROM " + asName(schema) + ".hypertable WHERE table_name = ${table_name};", { table_name, schema });
-            if(isHyperTable && isHyperTable.length){
-                throw "Triggers do not work on timescaledb hypertables due to bug:\nhttps://github.com/timescale/timescaledb/issues/1084"
-            }
-        }
-        return true;
+    if (res.exists) {
+      let isHyperTable = await this.db.any("SELECT * FROM " + asName(schema) + ".hypertable WHERE table_name = ${table_name};", { table_name, schema });
+      if (isHyperTable && isHyperTable.length) {
+        throw "Triggers do not work on timescaledb hypertables due to bug:\nhttps://github.com/timescale/timescaledb/issues/1084"
+      }
     }
+    return true;
+  }
 
-    /* 
-        A table will only have a trigger with all conditions (for different subs) 
-            conditions = ["user_id = 1"]
-            fields = ["user_id"]
-    */
+  /* 
+      A table will only have a trigger with all conditions (for different subs) 
+          conditions = ["user_id = 1"]
+          fields = ["user_id"]
+  */
 
-    getMyTriggerQuery = async () => {
-        return pgp.as.format(` 
+  getMyTriggerQuery = async () => {
+    return pgp.as.format(` 
             SELECT * --, ROW_NUMBER() OVER(PARTITION BY table_name ORDER BY table_name, condition ) - 1 as id
             FROM prostgles.v_triggers
             WHERE app_id = $1
             ORDER BY table_name, condition
         `, [this.appID]
-        )
-    }
+    )
+  }
 
-    // waitingTriggers: { [key: string]: string[] } = undefined;
-    addingTrigger: any;
-    addTriggerPool?: Record<string, string[]> = undefined;
-    async addTrigger(params: { table_name: string; condition: string; }){
-        try{
+  // waitingTriggers: { [key: string]: string[] } = undefined;
+  addingTrigger: any;
+  addTriggerPool?: Record<string, string[]> = undefined;
+  async addTrigger(params: { table_name: string; condition: string; }) {
+    try {
 
-            let { table_name, condition } = { ...params }
-            if(!table_name) throw "MISSING table_name";
-            if(!this.appID) throw "MISSING appID";
+      let { table_name, condition } = { ...params }
+      if (!table_name) throw "MISSING table_name";
+      if (!this.appID) throw "MISSING appID";
 
-            if(!condition || !condition.trim().length) condition = "TRUE";
+      if (!condition || !condition.trim().length) condition = "TRUE";
 
-            const app_id = this.appID;
+      const app_id = this.appID;
 
-            // console.log(1623, { app_id, addTrigger: { table_name, condition } });
+      // console.log(1623, { app_id, addTrigger: { table_name, condition } });
 
-            await this.checkIfTimescaleBug(table_name);
+      await this.checkIfTimescaleBug(table_name);
 
-            const trgVals = { 
-                tbl: asValue(table_name), 
-                cond: asValue(condition),
-            }
+      const trgVals = {
+        tbl: asValue(table_name),
+        cond: asValue(condition),
+      }
 
-            await this.db.any(`
+      await this.db.any(`
                 BEGIN WORK;
                 LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
 
@@ -1562,52 +1563,52 @@ export class PubSubManager {
                 COMMIT WORK;
             `);
 
-            log("addTrigger.. ", {table_name, condition});
+      log("addTrigger.. ", { table_name, condition });
 
-            const triggers: { 
-                table_name: string; 
-                condition: string; 
-            }[] = await this.db.any(await this.getMyTriggerQuery());
+      const triggers: {
+        table_name: string;
+        condition: string;
+      }[] = await this.db.any(await this.getMyTriggerQuery());
 
 
-            this._triggers = {};
-            triggers.map(t => {
-                this._triggers = this._triggers || {};
-                this._triggers[t.table_name] = this._triggers[t.table_name] || [];
-                if(!this._triggers[t.table_name].includes(t.condition)){
-                    this._triggers[t.table_name].push(t.condition)
-                }
-            });
-            log("trigger added.. ", {table_name, condition});
+      this._triggers = {};
+      triggers.map(t => {
+        this._triggers = this._triggers || {};
+        this._triggers[t.table_name] = this._triggers[t.table_name] || [];
+        if (!this._triggers[t.table_name].includes(t.condition)) {
+          this._triggers[t.table_name].push(t.condition)
+        }
+      });
+      log("trigger added.. ", { table_name, condition });
 
-            return true;
-            // console.log("1612", JSON.stringify(triggers, null, 2))
-            // console.log("1613",JSON.stringify(this._triggers, null, 2))
-            
+      return true;
+      // console.log("1612", JSON.stringify(triggers, null, 2))
+      // console.log("1613",JSON.stringify(this._triggers, null, 2))
 
-        } catch(e){
-            console.trace("Failed adding trigger", e); 
-            // throw e
-        }
 
+    } catch (e) {
+      console.trace("Failed adding trigger", e);
+      // throw e
     }
+
+  }
 }
 
 
 /* Get only the specified properties of an object */
-export function filterObj(obj: AnyObject, keys: string[] = [], exclude?: string[]): AnyObject{
-    if(exclude && exclude.length) keys = Object.keys(obj).filter(k => !exclude.includes(k))
-    if(!keys.length) {
-        // console.warn("filterObj: returning empty object");
-        return {};
-    }
-    if(obj && keys.length){
-        let res: AnyObject = {};
-        keys.map(k => {
-            res[k] = obj[k];
-        });
-        return res;
-    }
-
-    return obj;
+export function filterObj(obj: AnyObject, keys: string[] = [], exclude?: string[]): AnyObject {
+  if (exclude && exclude.length) keys = Object.keys(obj).filter(k => !exclude.includes(k))
+  if (!keys.length) {
+    // console.warn("filterObj: returning empty object");
+    return {};
+  }
+  if (obj && keys.length) {
+    let res: AnyObject = {};
+    keys.map(k => {
+      res[k] = obj[k];
+    });
+    return res;
+  }
+
+  return obj;
 }