prostgles-server 4.2.41 → 4.2.42

package/lib/PubSubManager/PubSubManager.ts

@@ -3,9 +3,9 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { DBHandlerServer, DboBuilder, PRGLIOSocket, TableInfo, TableOrViewInfo, canEXECUTE } from "../DboBuilder/DboBuilder";
+import { DBHandlerServer, DboBuilder, PRGLIOSocket, TableInfo, TableOrViewInfo, getCanExecute } from "../DboBuilder/DboBuilder";
 import { PostgresNotifListenManager } from "../PostgresNotifListenManager";
-import { DB, isSuperUser } from "../Prostgles";
+import { DB, getIsSuperUser } from "../Prostgles";
 import { addSync } from "./addSync";
 import { initPubSubManager } from "./initPubSubManager";
 
@@ -122,7 +122,6 @@ export type PubSubManagerOptions = {
   dboBuilder: DboBuilder; 
   wsChannelNamePrefix?: string;
   pgChannelName?: string;
-  onSchemaChange?: (event: { command: string; query: string }) => void;
 }
 
 export type Subscription = Pick<SubscriptionParams, 
@@ -147,20 +146,24 @@ export type Subscription = Pick<SubscriptionParams,
   }[];
 }
 
+/**
+ * Used to facilitate table subscribe and sync
+ */
 export class PubSubManager {
   static DELIMITER = '|$prstgls$|' as const;
 
   static EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID = "prostgles internal query that should be excluded from schema watch " as const;
 
   public static canCreate = async (db: DB) => {
-    const canExecute = await canEXECUTE(db);
-    const isSuperUs = await isSuperUser(db);
+    const canExecute = await getCanExecute(db);
+    const isSuperUs = await getIsSuperUser(db);
     return { canExecute, isSuperUs, yes: canExecute && isSuperUs };
   }
 
   public static create = async (options: PubSubManagerOptions) => {
-    const res = new PubSubManager(options);
-    return await res.init();
+    const instance = new PubSubManager(options);
+    const result = await initPubSubManager.bind(instance)();
+    return result;
   }
 
   get db(): DB  {
@@ -177,17 +180,14 @@ export class PubSubManager {
   subs: Subscription[] = [];
   syncs: SyncParams[] = [];
   socketChannelPreffix: string;
-  onSchemaChange?: ((event: { command: string; query: string }) => void) = undefined;
-
   postgresNotifListenManager?: PostgresNotifListenManager;
 
   private constructor(options: PubSubManagerOptions) {
-    const { wsChannelNamePrefix, onSchemaChange, dboBuilder } = options;
+    const { wsChannelNamePrefix, dboBuilder } = options;
     if (!dboBuilder.db || !dboBuilder.dbo) {
       throw 'MISSING: db_pg, db';
     }
     
-    this.onSchemaChange = onSchemaChange;
     this.dboBuilder = dboBuilder;
   
     this.socketChannelPreffix = wsChannelNamePrefix || "_psqlWS_";
@@ -195,20 +195,6 @@ export class PubSubManager {
     log("Created PubSubManager");
   }
 
-  NOTIF_TYPE = {
-    data: "data_has_changed",
-    data_trigger_change: "data_watch_triggers_have_changed",
-    schema: "schema_has_changed"
-  } as const;
-  NOTIF_CHANNEL = {
-    preffix: 'prostgles_' as const,
-    getFull: (appID?: string) => {
-      const finalAppId = appID ?? this.appID;
-      if (!finalAppId) throw "No appID";
-      return this.NOTIF_CHANNEL.preffix + finalAppId;
-    }
-  }
-
   /**
    * Used facilitate concurrent prostgles connections to the same database
    */
@@ -225,13 +211,10 @@ export class PubSubManager {
     }
     this.subs = [];
     this.syncs = [];
-    if (!this.postgresNotifListenManager) {
-      throw "this.postgresNotifListenManager missing"
-    }
-    this.postgresNotifListenManager.destroy();
+    this.postgresNotifListenManager?.destroy();
   }
 
-  canContinue = () => {
+  getIsDestroyed = () => {
     if (this.destroyed) {
       console.trace("Could not start destroyed instance");
       return false
@@ -241,13 +224,12 @@ export class PubSubManager {
 
   appChecking = false;
   checkedListenerTableCond?: string[];
-  init = initPubSubManager.bind(this);
 
   initialiseEventTriggers = async () => {
     if (!this.appID) throw "prepareTriggers failed: this.appID missing";
 
     const { watchSchema } = this.dboBuilder.prostgles.opts;
-    if (watchSchema && !(await isSuperUser(this.db))) {
+    if (watchSchema && !(await getIsSuperUser(this.db))) {
       console.warn("prostgles watchSchema requires superuser db user. Will not watch using event triggers")
     }
 
@@ -299,52 +281,7 @@ export class PubSubManager {
             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_tag_names IS NOT NULL
-            );
-            ev_trg_exists := EXISTS (
-              SELECT 1 FROM pg_catalog.pg_event_trigger
-              WHERE evtname = ${asValue(DB_OBJ_NAMES.schema_watch_trigger)}
-            );
-
-            /* 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 ; $$
-                  , ${asValue(DB_OBJ_NAMES.schema_watch_trigger)}
-                )
-                INTO 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 ${DB_OBJ_NAMES.schema_watch_trigger};
-                CREATE EVENT TRIGGER ${DB_OBJ_NAMES.schema_watch_trigger} ON ddl_command_end
-                WHEN TAG IN (\${EVENT_TRIGGER_TAGS:csv})
-                EXECUTE PROCEDURE ${DB_OBJ_NAMES.schema_watch_func}();
-
-            END IF;
-
+            ${SCHEMA_WATCH_EVENT_TRIGGER_QUERY}
             
         END
         $do$; 
@@ -367,11 +304,6 @@ export class PubSubManager {
     }
   }
 
-  isReady() {
-    if (!this.postgresNotifListenManager) throw "this.postgresNotifListenManager missing";
-    return this.postgresNotifListenManager.isListening();
-  } 
-
   getClientSubs(client: Pick<Subscription, "localFuncs" | "socket_id" | "channel_name">): Subscription[] { 
     return this.subs.filter(s => {
       return s.channel_name === client.channel_name && (matchesLocalFuncs(client.localFuncs, s.localFuncs) || client.socket_id && s.socket_id === client.socket_id)
@@ -577,6 +509,66 @@ export class PubSubManager {
   }
 }
 
+const SCHEMA_WATCH_EVENT_TRIGGER_QUERY = `
+  /* 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_tag_names IS NOT NULL
+  );
+  ev_trg_exists := EXISTS (
+    SELECT 1 FROM pg_catalog.pg_event_trigger
+    WHERE evtname = ${asValue(DB_OBJ_NAMES.schema_watch_trigger)}
+  );
+
+  /* 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 ; $$
+        , ${asValue(DB_OBJ_NAMES.schema_watch_trigger)}
+      )
+      INTO 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 ${DB_OBJ_NAMES.schema_watch_trigger};
+      CREATE EVENT TRIGGER ${DB_OBJ_NAMES.schema_watch_trigger} ON ddl_command_end
+      WHEN TAG IN (\${EVENT_TRIGGER_TAGS:csv})
+      EXECUTE PROCEDURE ${DB_OBJ_NAMES.schema_watch_func}();
+
+  END IF;
+`
+
+export const NOTIF_TYPE = {
+  data: "data_has_changed",
+  data_trigger_change: "data_watch_triggers_have_changed",
+  schema: "schema_has_changed"
+} as const;
+export const NOTIF_CHANNEL = {
+  preffix: 'prostgles_' as const,
+  getFull: (appID: string | undefined) => {
+    if (!appID) throw "No appID";
+    return NOTIF_CHANNEL.preffix + appID;
+  }
+}
 
 export const parseCondition = (condition: string): string => condition && condition.trim().length ? condition : "TRUE"
 

package/lib/PubSubManager/addSub.ts

@@ -127,66 +127,3 @@ export async function addSub(this: PubSubManager, subscriptionParams: Omit<AddSu
 
   return result;
 }
-
-// const _upsertSub = async function(
-//   this: PubSubManager, 
-//   newSubData: {
-//     table_name: string; 
-//     condition: string; 
-//     is_ready: boolean; 
-//     channel_name: string;
-//     viewOptions: SubscriptionParams["viewOptions"];
-//   },
-//   consumer: Pick<SubscriptionParams, "channel_name" | "socket" | "func">,
-//   isReadyOverride: boolean | undefined
-// ){
-//   const { table_name, condition: _cond, is_ready = false, viewOptions } = newSubData;
-//   const { channel_name, func, socket } = consumer;
-//   const condition = parseCondition(_cond);
-//   const newSub: SubscriptionParams = {
-//       socket,
-//       table_name,
-//       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
-//     ) && 
-//     JSON.stringify(s.viewOptions) === JSON.stringify((subscriptionParams.viewOptions)
-//   ));
-//   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, subChannel: channel_name });
-//         cb(null, { res });
-//       });
-//     }
-//   } else {
-//     this.subs[table_name]![condition]!.subs[sub_idx] = newSub;
-//   }
-
-//   if (isReadyOverride ?? is_ready) {
-//     this.pushSubData(newSub);
-//   }
-// };

package/lib/PubSubManager/getInitQuery.ts

@@ -1,5 +1,5 @@
 
-import { asValue, PubSubManager } from "./PubSubManager";
+import { asValue, NOTIF_CHANNEL, NOTIF_TYPE, PubSubManager } from "./PubSubManager";
 const { version } = require("../../package.json");
 
 export const DB_OBJ_NAMES = {
@@ -289,11 +289,11 @@ BEGIN
                         LOOP
                             
                             PERFORM pg_notify( 
-                              ${asValue(this.NOTIF_CHANNEL.preffix)} || v_trigger.app_id , 
+                              ${asValue(NOTIF_CHANNEL.preffix)} || v_trigger.app_id , 
                               LEFT(concat_ws(
                                 ${asValue(PubSubManager.DELIMITER)},
 
-                                ${asValue(this.NOTIF_TYPE.data)}, 
+                                ${asValue(NOTIF_TYPE.data)}, 
                                 COALESCE(TG_TABLE_NAME, 'MISSING'), 
                                 COALESCE(TG_OP, 'MISSING'), 
                                 CASE WHEN has_errors 
@@ -487,10 +487,10 @@ BEGIN
                     SELECT * FROM prostgles.apps
                   LOOP
                     PERFORM pg_notify( 
-                      ${asValue(this.NOTIF_CHANNEL.preffix)} || app.id, 
+                      ${asValue(NOTIF_CHANNEL.preffix)} || app.id, 
                       LEFT(concat_ws(
                         ${asValue(PubSubManager.DELIMITER)}, 
-                        ${asValue(this.NOTIF_TYPE.data_trigger_change)},
+                        ${asValue(NOTIF_TYPE.data_trigger_change)},
                         json_build_object(
                           'TG_OP', TG_OP, 
                           'duration', (EXTRACT(EPOCH FROM now()) * 1000) - start_time,
@@ -551,10 +551,10 @@ BEGIN
                       WHERE tg_tag = ANY(watching_schema_tag_names)
                     LOOP
                       PERFORM pg_notify( 
-                        ${asValue(this.NOTIF_CHANNEL.preffix)} || app.id, 
+                        ${asValue(NOTIF_CHANNEL.preffix)} || app.id, 
                         LEFT(concat_ws(
                           ${asValue(PubSubManager.DELIMITER)}, 
-                          ${asValue(this.NOTIF_TYPE.schema)}, tg_tag , TG_event, curr_query
+                          ${asValue(NOTIF_TYPE.schema)}, tg_tag , TG_event, curr_query
                         ), 7999/4)
                       );
                     END LOOP;

package/lib/PubSubManager/initPubSubManager.ts

@@ -1,50 +1,23 @@
-import { getKeys, isObject } from "prostgles-types";
 import { PostgresNotifListenManager } from "../PostgresNotifListenManager";
-import { asValue, log, PubSubManager } from "./PubSubManager";
+import { getWatchSchemaTagList } from "../SchemaWatch/getWatchSchemaTagList";
+import { asValue, log, NOTIF_CHANNEL, PubSubManager } from "./PubSubManager";
 const REALTIME_TRIGGER_CHECK_QUERY = "prostgles-server internal query used to manage realtime triggers" as const;  
 import { getInitQuery } from "./getInitQuery";
-import { ProstglesInitOptions } from "../Prostgles";
-import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
-
-const getWatchSchemaTagList = (watchSchema: ProstglesInitOptions["watchSchema"]) => {
-  if(!watchSchema) return undefined;
-
-  if(watchSchema === "*"){
-    return EVENT_TRIGGER_TAGS.slice(0);
-  } 
-  if (isObject(watchSchema) && typeof watchSchema !== "function"){
-    const watchSchemaKeys = getKeys(watchSchema);
-    const isInclusive = Object.values(watchSchema).every(v => v);
-    return EVENT_TRIGGER_TAGS
-      .slice(0)
-      .filter(v => {
-        const matches = watchSchemaKeys.includes(v);
-        return isInclusive? matches : !matches;
-      });
-  }
-
-  const coreTags: typeof EVENT_TRIGGER_TAGS[number][] = [
-    'COMMENT', 'CREATE TABLE', 'ALTER TABLE', 'DROP TABLE', 'CREATE VIEW', 
-    'DROP VIEW', 'ALTER VIEW', 'CREATE TABLE AS', 'SELECT INTO', 'CREATE POLICY'
-  ];
-  return coreTags;
-}
 
 export async function initPubSubManager(this: PubSubManager): Promise<PubSubManager | undefined> {
-  if (!this.canContinue()) return undefined;
+  if (!this.getIsDestroyed()) return undefined;
 
   let tries = 5;
   try {
 
     const initQuery = await getInitQuery.bind(this)()
     await this.db.any(initQuery);
-    if (!this.canContinue()) return;
-
+    if (!this.getIsDestroyed()) return;
 
     /* Prepare App id */
     if (!this.appID) {
       const check_frequency_ms = this.appCheckFrequencyMS;
-      const watching_schema_tag_names = this.onSchemaChange? getWatchSchemaTagList(this.dboBuilder.prostgles.opts.watchSchema) : null;
+      const watching_schema_tag_names = this.dboBuilder.prostgles.schemaWatch?.type.watchType !== "NONE" ? getWatchSchemaTagList(this.dboBuilder.prostgles.opts.watchSchema) : null;
       const raw = await this.db.one(
         "INSERT INTO prostgles.apps (check_frequency_ms, watching_schema_tag_names, application_name) \
         VALUES($1, $2, current_setting('application_name')) \
@@ -65,6 +38,14 @@ export async function initPubSubManager(this: PubSubManager): Promise<PubSubMana
             this.appChecking = true;
  
             const listeners = this.getActiveListeners();
+            const updateCurrentlyUsedTriggersQuery = !listeners.length? "" : `
+              UPDATE prostgles.app_triggers
+              SET last_used = CASE WHEN (table_name, condition) IN (
+                ${listeners.map(l => ` ( ${asValue(l.table_name)}, ${asValue(l.condition)} ) `).join(", ")}
+              ) THEN NOW() ELSE last_used END
+              WHERE app_id = ${asValue(this.appID)};
+            `;
+
             const checkedListenerTableCond = listeners.map(l => `${l.table_name}.${l.condition}`);
             let dataTriggerCheckQuery = "";
             if(this.checkedListenerTableCond?.sort().join() !== checkedListenerTableCond.sort().join()){
@@ -79,13 +60,7 @@ export async function initPubSubManager(this: PubSubManager): Promise<PubSubMana
                     --LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
 
                     /* UPDATE currently used triggers */
-                    ${!listeners.length? "" : `
-                      UPDATE prostgles.app_triggers
-                      SET last_used = CASE WHEN (table_name, condition) IN (
-                        ${listeners.map(l => ` ( ${asValue(l.table_name)}, ${asValue(l.condition)} ) `).join(", ")}
-                      ) THEN NOW() ELSE last_used END
-                      WHERE app_id = ${asValue(this.appID)};
-                    `}
+                    ${updateCurrentlyUsedTriggersQuery}
 
                     /* DELETE stale triggers for current app. Other triggers will be deleted on app startup */
                     DELETE FROM prostgles.app_triggers
@@ -175,9 +150,9 @@ export async function initPubSubManager(this: PubSubManager): Promise<PubSubMana
       }
     }
 
-    this.postgresNotifListenManager = new PostgresNotifListenManager(this.db, this.notifListener, this.NOTIF_CHANNEL.getFull());
+    this.postgresNotifListenManager = new PostgresNotifListenManager(this.db, this.notifListener, NOTIF_CHANNEL.getFull(this.appID));
 
-    await this.initialiseEventTriggers()
+    await this.initialiseEventTriggers();
 
     return this;
 

package/lib/PubSubManager/notifListener.ts

@@ -1,4 +1,4 @@
-import { log, pickKeys, PubSubManager } from "./PubSubManager";
+import { log, NOTIF_TYPE, pickKeys, PubSubManager } from "./PubSubManager";
 
 /* Relay relevant data to relevant subscriptions */
 export async function notifListener(this: PubSubManager, data: { payload: string }) {
@@ -14,25 +14,25 @@ export async function notifListener(this: PubSubManager, data: { payload: string
 
   log(str);
 
-  if (notifType === this.NOTIF_TYPE.schema) {
+  if (notifType === NOTIF_TYPE.schema) {
 
-    if (this.onSchemaChange) {
+    if (this.dboBuilder.prostgles.schemaWatch?.onSchemaChange) {
       const [_, command, _event_type, query] = dataArr;
       await this.dboBuilder.prostgles.opts.onLog?.({ type: "debug", command: "schemaChangeNotif", duration: 0, data: { command, query } });
 
       if (query && command) {
-        this.onSchemaChange({ command, query })
+        this.dboBuilder.prostgles.schemaWatch.onSchemaChange({ command, query })
       }
     }
 
     return;
-  } else if(notifType === this.NOTIF_TYPE.data_trigger_change) {
+  } else if(notifType === NOTIF_TYPE.data_trigger_change) {
     
     await this.refreshTriggers();
     return;
   }
 
-  if (notifType !== this.NOTIF_TYPE.data) {
+  if (notifType !== NOTIF_TYPE.data) {
     console.error("Unexpected notif type: ", notifType);
     return;
   }

package/lib/PublishParser/PublishParser.ts

@@ -6,7 +6,7 @@ import { getFileTableRules } from "./getFileTableRules";
 import { getSchemaFromPublish } from "./getSchemaFromPublish";
 import { getTableRulesWithoutFileTable } from "./getTableRulesWithoutFileTable";
 import { DboTable, DboTableCommand, ParsedPublishTable, PublishMethods, PublishObject, PublishParams, RULE_TO_METHODS, TableRule } from "./publishTypesAndUtils";
-import { VoidFunction } from "../SchemaWatch";
+import { VoidFunction } from "../SchemaWatch/SchemaWatch";
 
 export class PublishParser {
   publish: any;

package/lib/SchemaWatch/SchemaWatch.ts

@@ -0,0 +1,79 @@
+import type { DboBuilder } from "../DboBuilder/DboBuilder";
+import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
+import { OnSchemaChangeCallback } from "../Prostgles";
+import { PubSubManager, log } from "../PubSubManager/PubSubManager";
+import { ValidatedWatchSchemaType, getValidatedWatchSchemaType } from "./getValidatedWatchSchemaType";
+
+export type VoidFunction = () => void;
+
+export class SchemaWatch {
+
+  dboBuilder: DboBuilder;
+  type: ValidatedWatchSchemaType;
+  private constructor(dboBuilder: DboBuilder){
+    this.dboBuilder = dboBuilder;
+    this.type = getValidatedWatchSchemaType(dboBuilder);
+    if(this.type.watchType === "NONE") {
+      this.onSchemaChange = undefined;
+    }
+  }
+
+  static create = async (dboBuilder: DboBuilder) => {
+    const instance = new SchemaWatch(dboBuilder);
+    if(instance.type.watchType === "DDL_trigger") {
+      await dboBuilder.getPubSubManager()
+    }
+    return instance;
+  }
+  
+  onSchemaChange: OnSchemaChangeCallback | undefined = async (event) => {
+    if(this.type.watchType === "NONE") return;
+    
+    const { watchSchema, onReady, tsGeneratedTypesDir } = this.dboBuilder.prostgles.opts;
+    if (watchSchema && this.dboBuilder.prostgles.loaded) {
+      log("Schema changed");
+      const { query, command } = event;
+      if (typeof query === "string" && query.includes(PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID)) {
+        log("Schema change event excluded from triggers due to EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID");
+        return;
+      }
+
+      if (typeof watchSchema === "function") {
+        /* Only call the provided func */
+        watchSchema(event);
+
+      } else if (watchSchema === "hotReloadMode") {
+        if (tsGeneratedTypesDir) {
+          /* Hot reload integration. Will only touch tsGeneratedTypesDir */
+          console.log("watchSchema: Re-writing TS schema");
+
+          await this.dboBuilder.prostgles.refreshDBO();
+          this.dboBuilder.prostgles.writeDBSchema(true);
+        }
+
+      } else if (watchSchema) {
+        /* Full re-init. Sockets must reconnect */
+        console.log("watchSchema: Full re-initialisation", { query })
+        this.dboBuilder.prostgles.init(onReady as any, { type: "schema change", query, command });
+      }
+    }
+  };
+}
+
+
+/**
+ * Fallback for watchSchema in case of not a superuser (cannot add db event listener)
+ */
+export const watchSchemaFallback = async function(this: DboBuilder, { queryWithoutRLS, command }: { queryWithoutRLS: string; command: string; }){
+  const SCHEMA_ALTERING_COMMANDS = EVENT_TRIGGER_TAGS;// ["CREATE", "ALTER", "DROP", "REVOKE", "GRANT"];
+  const isNotPickedUpByDDLTrigger = ["REVOKE", "GRANT"].includes(command);
+  const { watchSchema, watchSchemaType } = this.prostgles?.opts || {};
+  if (
+    watchSchema &&
+    (!this.prostgles.isSuperUser || watchSchemaType === "prostgles_queries" || isNotPickedUpByDDLTrigger)
+  ) {
+    if (SCHEMA_ALTERING_COMMANDS.includes(command as any)) {
+      this.prostgles.schemaWatch?.onSchemaChange?.({ command, query: queryWithoutRLS })
+    }
+  }
+}

package/lib/SchemaWatch/getValidatedWatchSchemaType.ts

@@ -0,0 +1,45 @@
+import type { DboBuilder } from "../DboBuilder/DboBuilder";
+import { OnSchemaChangeCallback } from "../Prostgles";
+
+export type ValidatedWatchSchemaType = 
+| { watchType: "NONE" }
+| { watchType: "DDL_trigger"; onChange?: OnSchemaChangeCallback; }
+| { watchType: "prostgles_queries"; onChange?: OnSchemaChangeCallback; isFallbackFromDDL: boolean; }
+
+export const getValidatedWatchSchemaType = (dboBuilder: DboBuilder): ValidatedWatchSchemaType => {
+  const {watchSchema, watchSchemaType, tsGeneratedTypesDir} = dboBuilder.prostgles.opts;
+  if(!watchSchema) return { watchType: "NONE" };
+  
+  if (watchSchema === "hotReloadMode" && !tsGeneratedTypesDir) {
+    throw "tsGeneratedTypesDir option is needed for watchSchema: hotReloadMode to work ";
+  }
+
+  const onChange = typeof watchSchema === "function"? watchSchema : undefined;
+
+  if(watchSchemaType === "DDL_trigger" || !watchSchemaType){
+    if(!dboBuilder.prostgles.isSuperUser){
+
+      if(watchSchemaType === "DDL_trigger"){
+        console.error(`watchSchemaType "DDL_trigger" cannot be used because db user is not a superuser. Will fallback to watchSchemaType "prostgles_queries" `)
+      } else {
+        console.warn(`watchSchema fallback to watchSchemaType "prostgles_queries" due to non-superuser`)
+      }
+      return {
+        watchType: "prostgles_queries",
+        onChange,
+        isFallbackFromDDL: true
+      }
+    }
+
+    return {
+      watchType: "DDL_trigger",
+      onChange
+    };
+  }
+  
+  return {
+    watchType: watchSchemaType,
+    isFallbackFromDDL: false,
+    onChange
+  }
+}

package/lib/SchemaWatch/getWatchSchemaTagList.ts

@@ -0,0 +1,27 @@
+import { getKeys, isObject } from "prostgles-types";
+import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
+import { ProstglesInitOptions } from "../Prostgles";
+
+export const getWatchSchemaTagList = (watchSchema: ProstglesInitOptions["watchSchema"]) => {
+  if(!watchSchema) return undefined;
+
+  if(watchSchema === "*"){
+    return EVENT_TRIGGER_TAGS.slice(0);
+  } 
+  if (isObject(watchSchema) && typeof watchSchema !== "function"){
+    const watchSchemaKeys = getKeys(watchSchema);
+    const isInclusive = Object.values(watchSchema).every(v => v);
+    return EVENT_TRIGGER_TAGS
+      .slice(0)
+      .filter(v => {
+        const matches = watchSchemaKeys.includes(v);
+        return isInclusive? matches : !matches;
+      });
+  }
+
+  const coreTags: typeof EVENT_TRIGGER_TAGS[number][] = [
+    'COMMENT', 'CREATE TABLE', 'ALTER TABLE', 'DROP TABLE', 'CREATE VIEW', 
+    'DROP VIEW', 'ALTER VIEW', 'CREATE TABLE AS', 'SELECT INTO', 'CREATE POLICY'
+  ];
+  return coreTags;
+}