prostgles-server 3.0.64 → 3.0.67

package/dist/PubSubManager.js

@@ -1,1398 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Stefan L. All rights reserved.
- *  Licensed under the MIT License. See LICENSE in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pickKeys = exports.omitKeys = exports.PubSubManager = exports.log = exports.DEFAULT_SYNC_BATCH_SIZE = exports.asValue = void 0;
-const PostgresNotifListenManager_1 = require("./PostgresNotifListenManager");
-const utils_1 = require("./utils");
-const DboBuilder_1 = require("./DboBuilder");
-const Prostgles_1 = require("./Prostgles");
-const Bluebird = require("bluebird");
-const pgPromise = require("pg-promise");
-const prostgles_types_1 = require("prostgles-types");
-const SyncReplication_1 = require("./SyncReplication");
-const REALTIME_TRIGGER_CHECK_QUERY = "prostgles-server internal query used to manage realtime triggers";
-let pgp = pgPromise({
-    promiseLib: Bluebird
-});
-const asValue = (v) => pgp.as.format("$1", [v]);
-exports.asValue = asValue;
-exports.DEFAULT_SYNC_BATCH_SIZE = 50;
-const log = (...args) => {
-    if (process.env.TEST_TYPE) {
-        console.log(...args);
-    }
-};
-exports.log = log;
-class PubSubManager {
-    constructor(options) {
-        this.onSchemaChange = undefined;
-        this.NOTIF_TYPE = {
-            data: "data_has_changed",
-            schema: "schema_has_changed"
-        };
-        this.NOTIF_CHANNEL = {
-            preffix: 'prostgles_',
-            getFull: (appID) => {
-                const finalAppId = appID ?? this.appID;
-                if (!finalAppId)
-                    throw "No appID";
-                return this.NOTIF_CHANNEL.preffix + finalAppId;
-            }
-        };
-        this.appCheckFrequencyMS = 10 * 1000;
-        this.destroyed = false;
-        this.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();
-        };
-        this.canContinue = () => {
-            if (this.destroyed) {
-                console.trace("Could not start destroyed instance");
-                return false;
-            }
-            return true;
-        };
-        this.appChecking = false;
-        this.init = async () => {
-            if (!this.canContinue())
-                return undefined;
-            try {
-                const schema_version = 5;
-                const q = `
-                BEGIN; --  ISOLATION LEVEL SERIALIZABLE;-- TRANSACTION ISOLATION LEVEL SERIALIZABLE;
-
-                --SET  TRANSACTION ISOLATION LEVEL SERIALIZABLE;
-
-                /* 
-                * ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
-                */
-
-                DO
-                $do$
-                BEGIN
-
-                    /* Reduce deadlocks */
-                    PERFORM pg_sleep(random());
-
-                    /* Drop older version */
-                    IF EXISTS (SELECT 1 FROM information_schema.schemata WHERE schema_name = 'prostgles') THEN
-
-                        IF
-                            NOT EXISTS (
-                                SELECT 1 
-                                FROM information_schema.tables 
-                                WHERE  table_schema = 'prostgles'
-                                AND    table_name   = 'versions'
-                            )
-                        THEN
-                            DROP SCHEMA IF EXISTS prostgles CASCADE;
-                        ELSE 
-                            IF NOT EXISTS(SELECT 1 FROM prostgles.versions WHERE version >= ${schema_version}) THEN
-                              DROP SCHEMA IF EXISTS prostgles CASCADE;
-                            END IF;
-                        END IF;
-
-                    END IF;
-
- 
-                    IF  NOT EXISTS (SELECT 1 FROM information_schema.schemata WHERE schema_name = 'prostgles') 
-                    THEN
-                        --RAISE NOTICE 'CREATE SCHEMA IF NOT EXISTS prostgles';
-
-                        CREATE SCHEMA IF NOT EXISTS prostgles;
-
-                        CREATE TABLE IF NOT EXISTS prostgles.versions(
-                            version NUMERIC PRIMARY KEY
-                        );
-                        INSERT INTO prostgles.versions(version) VALUES(${schema_version}) ON CONFLICT DO NOTHING;
-
-                        CREATE OR REPLACE FUNCTION prostgles.random_string(length INTEGER DEFAULT 33) RETURNS TEXT AS $$
-                            DECLARE
-                                chars TEXT[] := '{0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}';
-                                result TEXT := '';
-                                i INTEGER := 0;
-                            BEGIN
-                            IF length < 0 THEN
-                                RAISE exception 'Given length cannot be less than 0';
-                            END IF;
-                            FOR i IN 1..length LOOP
-                                result := result || chars[1+random()*(array_length(chars, 1)-1)];
-                            END LOOP;
-                            RETURN result;
-                            END;
-                        $$ language plpgsql;
-                        COMMENT ON FUNCTION prostgles.random_string IS 'UUIDs without installing pgcrypto';
-
-
-                        CREATE OR REPLACE FUNCTION prostgles.debug(VARIADIC args TEXT[]) RETURNS VOID AS $$     
-                            BEGIN
-
-                                --PERFORM pg_notify('debug', concat_ws(' ', args));
-                                IF
-                                    NOT EXISTS (
-                                        SELECT 1 
-                                        FROM information_schema.tables 
-                                        WHERE  table_schema = 'prostgles'
-                                        AND    table_name   = 'debug'
-                                    )
-                                THEN
-                                    CREATE TABLE IF NOT EXISTS prostgles.debug(m TEXT);
-                                END IF;
-
-                                INSERT INTO prostgles.debug(m) VALUES(concat_ws(' ', args));
-
-                            END;
-                        $$ LANGUAGE plpgsql;
-                        COMMENT ON FUNCTION prostgles.debug IS 'Used for internal debugging';
-
-
-                        CREATE TABLE IF NOT EXISTS prostgles.apps (
-                            id                  TEXT PRIMARY KEY DEFAULT prostgles.random_string(),
-                            added               TIMESTAMP DEFAULT NOW(),
-                            application_name    TEXT,
-                            last_check          TIMESTAMP NOT NULL DEFAULT NOW(),
-                            last_check_ended    TIMESTAMP NOT NULL DEFAULT NOW(),
-                            watching_schema     BOOLEAN DEFAULT FALSE,
-                            check_frequency_ms  INTEGER NOT NULL  
-                        );
-                        COMMENT ON TABLE prostgles.apps IS 'Keep track of prostgles server apps connected to db to combine common triggers. Heartbeat used due to no logout triggers in postgres';
-
-                        CREATE TABLE IF NOT EXISTS prostgles.app_triggers (
-                            app_id          TEXT NOT NULL,
-                            table_name      TEXT NOT NULL,
-                            condition       TEXT NOT NULL,
-                            inserted        TIMESTAMP NOT NULL DEFAULT NOW(),
-                            last_used       TIMESTAMP NOT NULL DEFAULT NOW(),
-                            PRIMARY KEY (app_id, table_name, condition) -- This unqique index limits the condition column value to be less than 'SELECT current_setting('block_size');'
-                        );
-                        COMMENT ON TABLE prostgles.app_triggers IS 'Tables and conditions that are currently subscribed/synced';
-
-
-                        CREATE OR REPLACE VIEW prostgles.v_triggers AS
-                        SELECT *
-                        , (ROW_NUMBER() OVER( ORDER BY table_name, condition ))::text AS id
-                        -- , concat_ws('-', table_name, condition) AS id
-                        , ROW_NUMBER() OVER(PARTITION BY app_id, table_name ORDER BY table_name, condition ) - 1 AS c_id
-                        FROM prostgles.app_triggers;
-                        COMMENT ON VIEW prostgles.v_triggers IS 'Augment trigger table with natural IDs and per app IDs';
-
-
-                    /*
-                        CREATE OR REPLACE VIEW prostgles.v_triggers_unnested AS
-                            SELECT *
-                            , ROW_NUMBER() OVER(PARTITION BY app_id, table_name ORDER BY table_name, condition ) - 1 AS c_id
-                            FROM (
-                                SELECT *, unnest(app_ids) as app_id
-                                FROM prostgles.v_triggers
-                            ) t;
-
-                        -- Force table into cache
-                        IF EXISTS (select * from pg_extension where extname = 'pg_prewarm') THEN
-                          CREATE EXTENSION IF NOT EXISTS pg_prewarm;
-                          PERFORM pg_prewarm('prostgles.app_triggers');
-                        END IF;
-                    */
-
-
-                        CREATE OR REPLACE FUNCTION ${this.DB_OBJ_NAMES.data_watch_func}() RETURNS TRIGGER 
-                        AS $$
-                
-                            DECLARE t_ids TEXT[];
-                            DECLARE c_ids INTEGER[];  
-                            DECLARE err_c_ids INTEGER[]; 
-                            DECLARE unions TEXT := '';          
-                            DECLARE query TEXT := '';            
-                            DECLARE nrw RECORD;               
-                            DECLARE erw RECORD;     
-                            DECLARE has_errors BOOLEAN := FALSE;
-                            
-                            DECLARE err_text    TEXT;
-                            DECLARE err_detail  TEXT;
-                            DECLARE err_hint    TEXT;
-                            
-                            BEGIN
-
-                                -- PERFORM pg_notify('debug', concat_ws(' ', 'TABLE', TG_TABLE_NAME, TG_OP));
-
-                                SELECT string_agg(
-                                  concat_ws(
-                                    E' UNION \n ',
-                                    CASE WHEN (TG_OP = 'DELETE' OR TG_OP = 'UPDATE') THEN (p1 || ' old_table ' || p2) END,
-                                    CASE WHEN (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN (p1 || ' new_table ' || p2) END 
-                                  ),
-                                  E' UNION \n '::text
-                                )
-                                INTO unions
-                                FROM (
-                                    SELECT 
-                                        $z$ 
-                                          SELECT CASE WHEN EXISTS( SELECT 1 FROM 
-                                        $z$ AS p1,
-                                        format( 
-                                          $c$ 
-                                            as %I WHERE %s ) THEN %s::text END AS t_ids 
-                                          $c$, 
-                                          table_name, condition, id 
-                                        ) AS p2
-                                    FROM prostgles.v_triggers
-                                    WHERE table_name = TG_TABLE_NAME
-                                ) t;
-                                
-                                /*
-                                PERFORM pg_notify( 
-                                  ${(0, exports.asValue)(this.NOTIF_CHANNEL.preffix)} || (SELECT id FROM prostgles.apps LIMIT 1) , 
-                                  concat_ws(
-                                    ${(0, exports.asValue)(PubSubManager.DELIMITER)},
-
-                                    ${(0, exports.asValue)(this.NOTIF_TYPE.data)}, 
-                                    COALESCE(TG_TABLE_NAME, 'MISSING'), 
-                                    COALESCE(TG_OP, 'MISSING'), 
-                                    unions
-                                  )
-                                );
-                                RAISE 'unions: % , cids: %', unions, c_ids;
-                                */
-
-                                IF unions IS NOT NULL THEN
-                                    query = format(
-                                        $s$
-                                          SELECT ARRAY_AGG(DISTINCT t.t_ids)
-                                          FROM ( %s ) t
-                                        $s$, 
-                                        unions
-                                    );
-
-                                    BEGIN
-                                      EXECUTE query INTO t_ids;
-
-                                      --RAISE NOTICE 'trigger fired ok';
-
-                                    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;
-
-                                    --RAISE NOTICE 'has_errors: % ', has_errors;
-                                    --RAISE NOTICE 'unions: % , cids: %', unions, c_ids;
-
-                                    IF (t_ids IS NOT NULL OR has_errors) THEN
-
-                                        FOR nrw IN
-                                            SELECT app_id, string_agg(c_id::text, ',') as cids
-                                            FROM prostgles.v_triggers
-                                            WHERE id = ANY(t_ids) 
-                                            OR has_errors
-                                            GROUP BY app_id
-                                        LOOP
-                                            
-                                            PERFORM pg_notify( 
-                                                ${(0, exports.asValue)(this.NOTIF_CHANNEL.preffix)} || nrw.app_id , 
-                                                concat_ws(
-                                                    ${(0, exports.asValue)(PubSubManager.DELIMITER)},
-
-                                                    ${(0, exports.asValue)(this.NOTIF_TYPE.data)}, 
-                                                    COALESCE(TG_TABLE_NAME, 'MISSING'), 
-                                                    COALESCE(TG_OP, 'MISSING'), 
-                                                    CASE WHEN has_errors 
-                                                      THEN concat_ws('; ', 'error', err_text, err_detail, err_hint ) 
-                                                      ELSE COALESCE(nrw.cids, '') 
-                                                    END
-                                                    ${this.dboBuilder.prostgles.opts.DEBUG_MODE ? (", (select json_agg(t)::TEXT FROM (SELECT * from old_table) t), query") : ""}
-                                                )
-                                            );
-                                        END LOOP;
-
-
-                                        IF has_errors THEN
-
-                                            DELETE FROM prostgles.app_triggers;
-                                            RAISE NOTICE 'trigger dropped due to exception: % % %', err_text, err_detail, err_hint;
-
-                                        END IF;
-
-                                        
-                                    END IF;
-                                END IF;
-
-        
-                                RETURN NULL;
-                                
-                        /*
-                            EXCEPTION WHEN OTHERS THEN 
-                                DELETE FROM prostgles.app_triggers; -- delete all or will need to loop through all conditions to find issue;
-                                RAISE NOTICE 'trigger dropped due to exception';
-                                ${"--EXCEPTION_WHEN_COLUMN_WAS_RENAMED_THEN_DROP_TRIGGER"};
-                            
-                                
-
-                                RETURN NULL; 
-                        */
-                            END;
-
-                        --COMMIT;
-                        $$ LANGUAGE plpgsql;
-                        COMMENT ON FUNCTION ${this.DB_OBJ_NAMES.data_watch_func} IS 'Prostgles internal function used to notify when data in the table changed';
-
-
-
-                        CREATE OR REPLACE FUNCTION ${this.DB_OBJ_NAMES.trigger_add_remove_func}() RETURNS TRIGGER 
-                        AS $$
-                
-                            DECLARE operations TEXT[] := ARRAY['insert', 'update', 'delete'];
-                            DECLARE op TEXT;
-                            DECLARE query TEXT;
-                            DECLARE trw RECORD;            
-                            
-                            BEGIN
-
-
-                                --RAISE NOTICE 'prostgles.app_triggers % ', TG_OP;
-
-                                /* If no other listeners on table then DROP triggers */
-                                IF TG_OP = 'DELETE' THEN
-
-                                    --RAISE NOTICE 'DELETE trigger_add_remove_func table: % ', ' ' || COALESCE((SELECT concat_ws(' ', string_agg(table_name, ' & '), count(*), min(inserted) ) FROM prostgles.app_triggers) , ' 0 ');
-                                    --RAISE NOTICE 'DELETE trigger_add_remove_func old_table:  % ', '' || COALESCE((SELECT concat_ws(' ', string_agg(table_name, ' & '), count(*), min(inserted) ) FROM old_table), ' 0 ');
-
-                                    
-                                    /* Drop actual triggers if needed */
-                                    FOR trw IN 
-                                        SELECT DISTINCT table_name FROM old_table ot
-                                        WHERE NOT EXISTS (
-                                            SELECT 1 FROM prostgles.app_triggers t 
-                                            WHERE t.table_name = ot.table_name
-                                        ) 
-                                    LOOP
-
-                                        FOREACH op IN ARRAY operations
-                                        LOOP 
-                                            --RAISE NOTICE ' DROP DATA TRIGGER FOR:  % ', trw.table_name;
-                                            EXECUTE format(' DROP TRIGGER IF EXISTS %I ON %I ;' , 'prostgles_triggers_' || trw.table_name || '_' || op, trw.table_name);
-                                        END LOOP;
-                                                     
-                                    END LOOP;
-
-                                /* If newly added listeners on table then CREATE triggers */
-                                ELSIF TG_OP = 'INSERT' THEN
-                                     
-
-                                    --RAISE NOTICE 'INSERT trigger_add_remove_func table: % ', ' ' || COALESCE((SELECT concat_ws(' ', string_agg(table_name, ' & '), count(*), min(inserted) ) FROM prostgles.triggers) , ' 0 ');
-                                    --RAISE NOTICE 'INSERT trigger_add_remove_func new_table:  % ', '' || COALESCE((SELECT concat_ws(' ', string_agg(table_name, ' & '), count(*), min(inserted) ) FROM new_table), ' 0 ');
-
-                                    /* Loop through newly added tables */
-                                    FOR trw IN  
-
-                                        SELECT DISTINCT table_name 
-                                        FROM new_table nt
-
-                                        /* Table did not exist prior to this insert */
-                                        WHERE NOT EXISTS (
-                                            SELECT 1 
-                                            FROM prostgles.app_triggers t 
-                                            WHERE t.table_name = nt.table_name
-                                            AND   t.inserted   < nt.inserted    -- exclude current record (this is an after trigger). Turn into before trigger?
-                                        )
-
-                                        /* Table is valid */
-                                        AND  EXISTS (
-                                            SELECT 1 
-                                            FROM information_schema.tables 
-                                            WHERE  table_schema = 'public'
-                                            AND    table_name   = nt.table_name
-                                        )
-                                    LOOP
-                                     
-                                        /*
-                                            RAISE NOTICE ' CREATE DATA TRIGGER FOR:  % TABLE EXISTS?', trw.table_name, SELECT EXISTS (
-                                                SELECT 1 
-                                                FROM information_schema.tables 
-                                                WHERE  table_schema = 'public'
-                                                AND    table_name   = nt.table_name
-                                            );
-                                        */
-
-                                        query := format(
-                                            $q$ 
-                                                DROP TRIGGER IF EXISTS %1$I ON %2$I;
-                                                CREATE TRIGGER %1$I
-                                                AFTER INSERT ON %2$I
-                                                REFERENCING NEW TABLE AS new_table
-                                                FOR EACH STATEMENT EXECUTE PROCEDURE ${this.DB_OBJ_NAMES.data_watch_func}();
-                                                COMMENT ON TRIGGER %1$I ON %2$I IS 'Prostgles internal trigger used to notify when data in the table changed';
-                                            $q$,  
-                                            'prostgles_triggers_' || trw.table_name || '_insert', trw.table_name                                                
-                                        ) || format(
-                                            $q$ 
-                                                DROP TRIGGER IF EXISTS %1$I ON %2$I;
-                                                CREATE TRIGGER %1$I
-                                                AFTER UPDATE ON %2$I
-                                                REFERENCING OLD TABLE AS old_table NEW TABLE AS new_table
-                                                FOR EACH STATEMENT EXECUTE PROCEDURE ${this.DB_OBJ_NAMES.data_watch_func}();
-                                                COMMENT ON TRIGGER %1$I ON %2$I IS 'Prostgles internal trigger used to notify when data in the table changed';
-                                            $q$,  
-                                            'prostgles_triggers_' || trw.table_name || '_update', trw.table_name   
-                                        ) || format(
-                                            $q$ 
-                                                DROP TRIGGER IF EXISTS %1$I ON %2$I;
-                                                CREATE TRIGGER %1$I
-                                                AFTER DELETE ON %2$I
-                                                REFERENCING OLD TABLE AS old_table
-                                                FOR EACH STATEMENT EXECUTE PROCEDURE ${this.DB_OBJ_NAMES.data_watch_func}();
-                                                COMMENT ON TRIGGER %1$I ON %2$I IS 'Prostgles internal trigger used to notify when data in the table changed';
-                                            $q$,
-                                            'prostgles_triggers_' || trw.table_name || '_delete', trw.table_name  
-                                        );
-
-                                        --RAISE NOTICE ' % ', query;
-
-                                        
-                                        query := format(
-                                            $q$
-                                                DO $e$ 
-                                                BEGIN
-
-                                                    IF EXISTS (
-                                                        SELECT 1 
-                                                        FROM information_schema.tables 
-                                                        WHERE  table_schema = 'public'
-                                                        AND    table_name   = %L
-                                                    ) THEN
-
-                                                        %s
-
-                                                    END IF;
-
-                                                END $e$;
-                                            $q$,
-                                            trw.table_name,
-                                            query
-                                        ) ;
-                                        
-
-                                        EXECUTE query;
-                                                    
-                                    END LOOP;
-
-                                END IF;
-
-        
-                                RETURN NULL;
-                            END;
-
-                        $$ LANGUAGE plpgsql;
-                        COMMENT ON FUNCTION ${this.DB_OBJ_NAMES.trigger_add_remove_func} IS 'Used to add/remove table watch triggers concurrently ';
-
-                        DROP TRIGGER IF EXISTS prostgles_triggers_insert ON prostgles.app_triggers;
-                        CREATE TRIGGER prostgles_triggers_insert
-                        AFTER INSERT ON prostgles.app_triggers
-                        REFERENCING NEW TABLE AS new_table
-                        FOR EACH STATEMENT EXECUTE PROCEDURE ${this.DB_OBJ_NAMES.trigger_add_remove_func}();
-                      
-                        DROP TRIGGER IF EXISTS prostgles_triggers_delete ON prostgles.app_triggers;
-                        CREATE TRIGGER prostgles_triggers_delete
-                        AFTER DELETE ON prostgles.app_triggers
-                        REFERENCING OLD TABLE AS old_table
-                        FOR EACH STATEMENT EXECUTE PROCEDURE ${this.DB_OBJ_NAMES.trigger_add_remove_func}();
-                      
-
-                        CREATE OR REPLACE FUNCTION ${this.DB_OBJ_NAMES.schema_watch_func}() RETURNS event_trigger AS $$
-                            
-                            DECLARE curr_query TEXT := '';                                       
-                            DECLARE arw RECORD;
-                            
-                            BEGIN
-                            
-                                --RAISE NOTICE 'SCHEMA_WATCH: %', tg_tag;
-                    
-                                /* 
-                                  This event trigger will outlive a prostgles app instance. 
-                                  Must ensure it only fires if an app instance is running  
-                                */
-                                IF
-                                  EXISTS (
-                                    SELECT 1 
-                                    FROM information_schema.tables 
-                                    WHERE  table_schema = 'prostgles'
-                                    AND    table_name   = 'apps'
-                                  )          
-                                THEN
-
-                                    SELECT LEFT(COALESCE(current_query(), ''), 5000)
-                                    INTO curr_query;
-                                    
-                                    FOR arw IN 
-                                      SELECT * FROM prostgles.apps WHERE watching_schema IS TRUE
-
-                                    LOOP
-                                      PERFORM pg_notify( 
-                                        ${(0, exports.asValue)(this.NOTIF_CHANNEL.preffix)} || arw.id, 
-                                        concat_ws(
-                                          ${(0, exports.asValue)(PubSubManager.DELIMITER)}, 
-                                          ${(0, exports.asValue)(this.NOTIF_TYPE.schema)}, tg_tag , TG_event, curr_query
-                                        )
-                                      );
-                                    END LOOP;
-
-                                END IF;
-
-                            END;
-                        $$ LANGUAGE plpgsql;
-                        COMMENT ON FUNCTION ${this.DB_OBJ_NAMES.schema_watch_func} IS 'Prostgles internal function used to notify when schema has changed';
-
-                    END IF;
-
-                END
-                $do$;
-
-
-                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
-                                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 => ` ( ${(0, exports.asValue)(l.table_name)}, ${(0, exports.asValue)(l.condition)} ) `).join(", ")}
-                  ) THEN NOW() ELSE last_used END
-                  WHERE app_id = ${(0, exports.asValue)(this.appID)};
-                `;
-                                }
-                                appQ = `
-                            
-                                DO $$
-                                BEGIN
-
-                                    /* ${REALTIME_TRIGGER_CHECK_QUERY} */
-                                    /* prostgles schema must exist */
-                                    IF
-                                        EXISTS (
-                                            SELECT 1 
-                                            FROM information_schema.tables 
-                                            WHERE  table_schema = 'prostgles'
-                                            AND    table_name   = 'apps'
-                                        )
-                                    THEN
-
-    
-                                        /* Concurrency control to avoid deadlock 
-                                        IF NOT EXISTS (
-                                            SELECT 1 FROM prostgles.apps
-                                            WHERE last_check < last_check_ended
-                                            AND last_check_ended > NOW() - interval '5 minutes'
-                                        ) THEN
-                                        */
-                                            UPDATE prostgles.apps 
-                                            SET last_check = NOW()
-                                            WHERE id = ${(0, exports.asValue)(this.appID)};
-
-
-    
-                                            /* Delete unused triggers. Might deadlock */
-                                            IF EXISTS ( SELECT 1 FROM prostgles.app_triggers)
-
-                                                /* If this is the latest app then proceed
-                                                    AND ( 
-                                                        SELECT id = ${(0, exports.asValue)(this.appID)} 
-                                                        FROM prostgles.apps 
-                                                        ORDER BY last_check DESC 
-                                                        LIMIT 1  
-                                                    ) = TRUE
-                                                */
-                                                
-                                            THEN
-    
-                                                /* TODO: Fixed deadlocks */
-                                                --LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
-    
-                                                /* UPDATE currently used triggers */
-                                                ${trgUpdateLastUsed}
-    
-                                                /* DELETE stale triggers for current app. Other triggers will be deleted on app startup */
-                                                DELETE FROM prostgles.app_triggers
-                                                WHERE app_id = ${(0, exports.asValue)(this.appID)}
-                                                AND last_used < NOW() - 4 * ${(0, exports.asValue)(this.appCheckFrequencyMS)} * interval '1 millisecond'; -- 10 seconds at the moment
-    
-                                            END IF;
-
-
-
-                                            UPDATE prostgles.apps 
-                                            SET last_check_ended = NOW()
-                                            WHERE id = ${(0, exports.asValue)(this.appID)};
-
-                                        /*
-                                        END IF;    
-                                        */
-
-    
-                                    END IF;
-
-                                -- must not commit without a lock
-                                --COMMIT;
-                                END $$;
-                            `;
-                                await this.db.any(appQ);
-                                (0, exports.log)("updated last_check");
-                            }
-                            catch (e) {
-                                /** In some cases a query idles and blocks everything else. Terminate all similar queries */
-                                this.db.any("SELECT state, pg_terminate_backend(pid) from pg_stat_activity WHERE query ilike ${qid} and pid <>  pg_backend_pid();", { qid: "%" + REALTIME_TRIGGER_CHECK_QUERY + "%" });
-                                /** If this database was dropped then stop interval */
-                                if (e?.code === "3D000") { //  && e.message.includes(this.db.$cn.database)
-                                    clearInterval(this.appCheck);
-                                }
-                                console.error("appCheck FAILED: \n", e, appQ);
-                            }
-                            this.appChecking = false;
-                        }, 0.8 * this.appCheckFrequencyMS);
-                    }
-                }
-                this.postgresNotifListenManager = new PostgresNotifListenManager_1.PostgresNotifListenManager(this.db, this.notifListener, this.NOTIF_CHANNEL.getFull());
-                await this.prepareTriggers();
-                return this;
-            }
-            catch (e) {
-                console.error("PubSubManager init failed: ", e);
-            }
-        };
-        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"
-        };
-        this.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 (0, Prostgles_1.isSuperUser)(this.db))) {
-                console.warn("prostgles watchSchema requires superuser db user. Will not watch using event triggers");
-            }
-            try {
-                await this.db.any(`
-                BEGIN;--  ISOLATION LEVEL SERIALIZABLE;
-                
-                /**                                 ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
-                 *  Drop stale triggers
-                 * */
-                DO
-                $do$
-                    DECLARE trg RECORD;
-                        q   TEXT;
-                        ev_trg_needed BOOLEAN := FALSE;
-                        ev_trg_exists BOOLEAN := FALSE;
-                        is_super_user BOOLEAN := FALSE;
-                BEGIN
-                    --SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
-                    
-                    LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
-                    EXECUTE format(
-                        $q$
-
-                            CREATE TEMP TABLE %1$I AS --ON COMMIT DROP AS
-                            SELECT * FROM prostgles.app_triggers;
-
-                            DELETE FROM prostgles.app_triggers;
-
-                            INSERT INTO prostgles.app_triggers
-                            SELECT * FROM %1$I;
-
-                            DROP TABLE IF EXISTS %1$I;
-                        $q$, 
-                        ${(0, exports.asValue)('triggers_' + this.appID)}
-                    );
-  
-                    is_super_user := EXISTS (select 1 from pg_user where usename = CURRENT_USER AND usesuper IS TRUE);
-                    /**
-                     *  Delete stale app records
-                     * */
-                    DELETE FROM prostgles.apps
-                    WHERE last_check < NOW() - 8 * check_frequency_ms * interval '1 millisecond';
-
-                    DELETE FROM prostgles.app_triggers
-                    WHERE app_id NOT IN (SELECT id FROM prostgles.apps);
-                    
-                    /* DROP the old buggy schema watch trigger */
-                    IF EXISTS (
-                        SELECT 1 FROM pg_catalog.pg_event_trigger
-                        WHERE evtname = 'prostgles_schema_watch_trigger'
-                    ) AND is_super_user IS TRUE 
-                    THEN
-                        DROP EVENT TRIGGER IF EXISTS prostgles_schema_watch_trigger;
-                    END IF;
-
-                    ev_trg_needed := EXISTS (SELECT 1 FROM prostgles.apps WHERE watching_schema IS TRUE);
-                    ev_trg_exists := EXISTS (
-                        SELECT 1 FROM pg_catalog.pg_event_trigger
-                        WHERE evtname = ${(0, exports.asValue)(this.DB_OBJ_NAMES.schema_watch_trigger)}
-                    );
-
-                     -- RAISE NOTICE ' ev_trg_needed %, ev_trg_exists %', ev_trg_needed, ev_trg_exists;
-
-                    /**
-                     *  DROP stale event trigger
-                     * */
-                    IF is_super_user IS TRUE AND ev_trg_needed IS FALSE AND ev_trg_exists IS TRUE THEN
-
-                        SELECT format(
-                            $$ DROP EVENT TRIGGER IF EXISTS %I ; $$
-                            , ${(0, exports.asValue)(this.DB_OBJ_NAMES.schema_watch_trigger)}
-                        )
-                        INTO q;
-
-                        --RAISE NOTICE ' DROP EVENT TRIGGER %', q;
-
-                        EXECUTE q;
-
-                    /**
-                     *  CREATE event trigger
-                     * */
-                    ELSIF 
-                        is_super_user IS TRUE 
-                        AND ev_trg_needed IS TRUE 
-                        AND ev_trg_exists IS FALSE 
-                    THEN
-
-                        DROP EVENT TRIGGER IF EXISTS ${this.DB_OBJ_NAMES.schema_watch_trigger};
-                        CREATE EVENT TRIGGER ${this.DB_OBJ_NAMES.schema_watch_trigger} ON ddl_command_end
-                        WHEN TAG IN ('COMMENT', 'CREATE TABLE', 'ALTER TABLE', 'DROP TABLE', 'CREATE VIEW', 'DROP VIEW', 'ALTER VIEW', 'CREATE TABLE AS', 'SELECT INTO')
-                        --WHEN TAG IN ('CREATE TABLE', 'ALTER TABLE', 'DROP TABLE', 'CREATE TRIGGER', 'DROP TRIGGER')
-                        EXECUTE PROCEDURE ${this.DB_OBJ_NAMES.schema_watch_func}();
-
-                        --RAISE NOTICE ' CREATED EVENT TRIGGER %', q;
-                    END IF;
- 
-                    
-                END
-                $do$; 
-  
-
-                COMMIT;
-            `).catch(e => {
-                    console.error("prepareTriggers failed: ", e);
-                    throw e;
-                });
-                return true;
-            }
-            catch (e) {
-                console.error("prepareTriggers failed: ", e);
-                throw e;
-            }
-        };
-        /* Relay relevant data to relevant subscriptions */
-        this.notifListener = async (data) => {
-            const str = data.payload;
-            if (!str) {
-                console.error("Empty notif?");
-                return;
-            }
-            const dataArr = str.split(PubSubManager.DELIMITER), notifType = dataArr[0];
-            (0, exports.log)(str);
-            if (notifType === this.NOTIF_TYPE.schema) {
-                if (this.onSchemaChange) {
-                    const command = dataArr[1], event_type = dataArr[2], query = dataArr[3];
-                    if (query) {
-                        this.onSchemaChange({ command, query });
-                    }
-                }
-                return;
-            }
-            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);
-            (0, exports.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?.split(",").length &&
-                condition_ids_str?.split(",").every((c) => Number.isInteger(+c)) &&
-                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));
-                (0, exports.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) => {
-                        this.syncData(s, undefined, "trigger");
-                    });
-                    if (!subs) {
-                        // console.error(`sub missing for ${table_name} ${condition}`, this.triggers);
-                        // console.log(this.subs)
-                        return;
-                    }
-                    /* 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) {
-                                (0, exports.log)("throttling sub");
-                                sub.is_throttling = setTimeout(() => {
-                                    (0, exports.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);
-            }
-        };
-        this.getActiveListeners = () => {
-            let result = [];
-            const upsert = (t, c) => {
-                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;
-        };
-        this.checkIfTimescaleBug = async (table_name) => {
-            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 " + (0, prostgles_types_1.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"]
-        */
-        this.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]);
-        };
-        this.addTriggerPool = undefined;
-        const { wsChannelNamePrefix, pgChannelName, onSchemaChange, dboBuilder } = options;
-        if (!dboBuilder.db || !dboBuilder.dbo) {
-            throw 'MISSING: db_pg, db';
-        }
-        this.onSchemaChange = onSchemaChange;
-        this.dboBuilder = dboBuilder;
-        this.sockets = {};
-        this.subs = {};
-        this.syncs = [];
-        this.socketChannelPreffix = wsChannelNamePrefix || "_psqlWS_";
-        (0, exports.log)("Created PubSubManager");
-    }
-    get db() {
-        return this.dboBuilder.db;
-    }
-    get dbo() {
-        return this.dboBuilder.dbo;
-    }
-    isReady() {
-        if (!this.postgresNotifListenManager)
-            throw "this.postgresNotifListenManager missing";
-        return this.postgresNotifListenManager.isListening();
-    }
-    getSubs(table_name, condition) {
-        return this.subs?.[table_name]?.[condition]?.subs;
-    }
-    getSyncs(table_name, condition) {
-        return (this.syncs || [])
-            .filter((s) => s.table_name === table_name && s.condition === condition);
-    }
-    pushSubData(sub, err) {
-        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();
-        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 new Error(`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]) {
-                    (0, exports.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, channel_name) {
-        if (socket && !this.sockets[socket.id]) {
-            this.sockets[socket.id] = socket;
-            socket.on("disconnect", () => this.onSocketDisconnected(socket));
-        }
-    }
-    async syncData(sync, clientData, source) {
-        return await (0, SyncReplication_1.syncData)(this, sync, clientData, source);
-    }
-    /**
-     * Returns a sync channel
-     * A sync channel is unique per socket for each filter
-     */
-    async addSync(syncParams) {
-        const { socket = null, table_info = null, table_rules, synced_field = null, allow_delete = false, id_fields = [], filter = {}, params, condition = "", throttle = 0 } = syncParams || {};
-        let conditionParsed = 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: (0, utils_1.get)(table_rules, "sync.batch_size") || exports.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, cb) => {
-                    this.onSocketDisconnected(socket, channel_name);
-                    cb(null, { res: "ok" });
-                });
-                socket.removeAllListeners(channel_name);
-                socket.on(channel_name, (data, cb) => {
-                    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, "client");
-                        // 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");
-            }
-            return newSync;
-        };
-        // const { min_id, max_id, count, max_synced } = params;
-        let sync = upsertSync();
-        await this.addTrigger({ table_name, condition: conditionParsed });
-        return channel_name;
-    }
-    /* Must return a channel for socket */
-    /* The distinct list of channel names must have a corresponding trigger in the database */
-    async addSub(subscriptionParams) {
-        const { socket, func = null, table_info = null, table_rules, filter = {}, params = {}, condition = "", throttle = 0, //subOne = false, 
-        relatedTableSubscriptions } = subscriptionParams || {};
-        let validated_throttle = subscriptionParams.throttle || 10;
-        if ((!socket && !func) || !table_info)
-            throw "socket/func or table_info missing";
-        const pubThrottle = (0, utils_1.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 channel_name = `${this.socketChannelPreffix}.${table_info.name}.${JSON.stringify(filter)}.${JSON.stringify(params)}.${"m"}.sub`;
-        this.upsertSocket(socket, channel_name);
-        const upsertSub = (newSubData) => {
-            const { table_name, condition: _cond, is_ready = false, parentSubParams } = newSubData, condition = parseCondition(_cond), newSub = {
-                socket,
-                table_name: table_info.name,
-                table_info,
-                filter,
-                params,
-                table_rules,
-                channel_name,
-                parentSubParams,
-                func: func ?? undefined,
-                socket_id: socket?.id,
-                throttle: validated_throttle,
-                is_throttling: null,
-                last_throttled: 0,
-                is_ready,
-            };
-            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, cb) => {
-                        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 (table_info.is_view) {
-            if (relatedTableSubscriptions?.length) {
-                relatedTableSubscriptions.map(async (relatedTable) => {
-                    const params = {
-                        table_name: relatedTable.tableName,
-                        condition: relatedTable.condition,
-                        parentSubParams: {
-                            ...subscriptionParams,
-                            channel_name
-                        },
-                    };
-                    upsertSub({
-                        ...params,
-                        is_ready: false
-                    });
-                    await this.addTrigger(params);
-                    upsertSub({
-                        ...params,
-                        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: parseCondition(condition),
-                parentSubParams: undefined,
-                is_ready: false
-            });
-            await this.addTrigger({
-                table_name: table_info.name,
-                condition: parseCondition(condition),
-            });
-            upsertSub({
-                table_name: table_info.name,
-                condition: parseCondition(condition),
-                parentSubParams: undefined,
-                is_ready: true
-            });
-            return channel_name;
-        }
-    }
-    removeLocalSub(table_name, condition, func) {
-        let cond = parseCondition(condition);
-        if ((0, utils_1.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");
-        }
-    }
-    onSocketDisconnected(socket, channel_name) {
-        // 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 ((0, prostgles_types_1.isEmpty)(this.subs[table_name])) {
-                                    delete this.subs[table_name];
-                                }
-                            }
-                        }
-                    });
-                });
-            });
-        }
-        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;
-                }
-                return matchesSocket;
-            });
-        }
-        if (!socket) {
-        }
-        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";
-    }
-    async addTrigger(params) {
-        try {
-            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";
-            }
-            // console.log(1623, { app_id, addTrigger: { table_name, condition } });
-            await this.checkIfTimescaleBug(table_name);
-            const trgVals = {
-                tbl: (0, exports.asValue)(table_name),
-                cond: (0, exports.asValue)(condition),
-            };
-            await this.db.any(`
-        BEGIN WORK;
-        LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
-
-        INSERT INTO prostgles.app_triggers (table_name, condition, app_id) 
-          VALUES (${trgVals.tbl}, ${trgVals.cond}, ${(0, exports.asValue)(this.appID)})
-        ON CONFLICT DO NOTHING;
-              
-        COMMIT WORK;
-      `);
-            (0, exports.log)("addTrigger.. ", { table_name, condition });
-            const triggers = 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);
-                }
-            });
-            (0, exports.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))
-        }
-        catch (e) {
-            console.trace("Failed adding trigger", e);
-            // throw e
-        }
-    }
-}
-exports.PubSubManager = PubSubManager;
-_a = PubSubManager;
-PubSubManager.DELIMITER = '|$prstgls$|';
-//     ,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';
-//     `))
-PubSubManager.canCreate = async (db) => {
-    const canExecute = await (0, DboBuilder_1.canEXECUTE)(db);
-    const isSuperUs = await (0, Prostgles_1.isSuperUser)(db);
-    return { canExecute, isSuperUs, yes: canExecute && isSuperUs };
-};
-PubSubManager.create = async (options) => {
-    const res = new PubSubManager(options);
-    return await res.init();
-};
-PubSubManager.SCHEMA_ALTERING_QUERIES = ['CREATE TABLE', 'ALTER TABLE', 'DROP TABLE', 'CREATE VIEW', 'DROP VIEW', 'ALTER VIEW', 'CREATE TABLE AS', 'SELECT INTO'];
-PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID = "prostgles internal query that should be excluded from ";
-const parseCondition = (condition) => Boolean(condition && condition.trim().length) ? condition : "TRUE";
-function omitKeys(obj, exclude) {
-    return pickKeys(obj, (0, prostgles_types_1.getKeys)(obj).filter(k => !exclude.includes(k)));
-}
-exports.omitKeys = omitKeys;
-function pickKeys(obj, include = []) {
-    let keys = include;
-    if (!keys.length) {
-        return {};
-    }
-    if (obj && keys.length) {
-        let res = {};
-        keys.forEach(k => {
-            res[k] = obj[k];
-        });
-        return res;
-    }
-    return obj;
-}
-exports.pickKeys = pickKeys;
-//# sourceMappingURL=PubSubManager.js.map