prostgles-server 4.2.160 → 4.2.162

package/lib/Logging.ts

@@ -0,0 +1,127 @@
+import { AnyObject } from "prostgles-types";
+import { LocalParams } from "./DboBuilder/DboBuilder";
+import { TableHandler } from "./DboBuilder/TableHandler/TableHandler";
+
+type ClientInfo = {
+  socketId: string | undefined;
+  sid: string | undefined;
+}
+
+export namespace EventTypes {
+  type DebugInfo = {
+    duration: number;
+    error?: any;
+  }
+
+  export type Table = ClientInfo & DebugInfo & {
+    type: "table";
+    tableName: string;
+    command: keyof TableHandler;
+    txInfo: AnyObject | undefined;
+    data: AnyObject;
+    localParams: LocalParams | undefined;
+  };
+
+  type SyncOneClient = ClientInfo & DebugInfo & {
+    type: "sync";
+    tableName: string;
+    localParams?: LocalParams;
+    connectedSocketIds: string[];
+  } & (
+    {
+      command: "syncData";
+      source: "client" | "trigger";
+      connectedSocketIds: string[];
+      lr: string;
+    } | {
+      command: "upsertData" | "pushData";
+      rows: number;
+      socketId: string;
+    } | {
+      command: "addTrigger";
+      state: "ok" | "fail";
+      /** If no socket id then it's a local subscribe */
+      socketId: string | undefined;
+      condition: string;
+    } | {
+      command: "addSync" | "unsync";
+      socketId: string;
+      condition: string;
+    } | {
+      command: "upsertSocket.disconnect";
+      socketId: string;
+      remainingSyncs: string;
+      remainingSubs: string;
+      connectedSocketIds: string[];
+    }
+  );
+  export type SyncMultiClient = {
+    type: "sync";
+    tableName: string;
+    localParams?: LocalParams;
+    connectedSocketIds: string[];
+  } & (
+    {
+      command: "notifListener";
+      op_name: string | undefined;
+      condition_ids_str: string | undefined;
+      tableTriggers: string[] | undefined;
+      tableSyncs: string;
+      state: "ok" | "error" | "no-triggers" | "invalid_condition_ids";
+    }
+  );
+
+  export type Sync = SyncOneClient | SyncMultiClient;
+
+  export type Connection = (ClientInfo & {
+    type: "connect" | "disconnect";
+    socketId: string;
+    connectedSocketIds: string[];
+  }) | (ClientInfo & DebugInfo & {
+    type: "connect.getClientSchema";
+  });
+
+  export type Method = ClientInfo & DebugInfo & {
+    type: "method";
+    args: any[];
+    localParams: LocalParams;
+  };
+  export type Auth = ClientInfo & DebugInfo & {
+    type: "auth";
+  } & (
+  | { command: "getClientInfo"; } 
+  | { command: "login"; } 
+  );
+
+  export type Debug = DebugInfo & {
+    type: "debug";
+    command: 
+    | "initFileTable" 
+    | "initTableConfig"
+    | "runSQLFile" 
+    | "schemaChangeNotif" 
+    | "TableConfig.runQueries.start" 
+    | "TableConfig.runQueries.end" 
+    | "refreshDBO.start" 
+    | "refreshDBO.end"
+    | "tableConfigurator.init.start"
+    | "tableConfigurator.init.end"
+    | "initFileTable.start"
+    | "initFileTable.end"
+    | "initFileManager.runQuery"
+    | "DboBuilder.getTablesForSchemaPostgresSQL"
+    | "PubSubManager.create"
+    data?: AnyObject;
+  }
+}
+
+export type EventInfo =
+  | EventTypes.Auth
+  | EventTypes.Table
+  | EventTypes.Method
+  | EventTypes.Sync 
+  | EventTypes.SyncMultiClient 
+  | EventTypes.Connection
+  | EventTypes.Debug;
+
+export type TableEvent = EventTypes.Table;

package/lib/PostgresNotifListenManager.ts

@@ -0,0 +1,143 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Stefan L. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DB } from "./Prostgles";
+import pg from "pg-promise/typescript/pg-subset";
+import pgPromise from "pg-promise";
+
+export type PrglNotifListener = (args: {
+  length: number;
+  processId: number;
+  channel: string;
+  payload: string;
+  name: string;
+}) => void;
+
+export class PostgresNotifListenManager {
+  connection?: pgPromise.IConnected<{}, pg.IClient>;
+  db_pg: DB;
+  notifListener: PrglNotifListener;
+  db_channel_name: string;
+  isListening: any;
+  client?: pg.IClient;
+
+  static create = (db_pg: DB, notifListener: PrglNotifListener, db_channel_name: string): Promise<PostgresNotifListenManager> => {
+    const res = new PostgresNotifListenManager(db_pg, notifListener, db_channel_name, true);
+    return res.init();
+  }
+
+  constructor(db_pg: DB, notifListener: PrglNotifListener, db_channel_name: string, noInit = false) {
+    if (!db_pg || !notifListener || !db_channel_name) throw "PostgresNotifListenManager: db_pg OR notifListener OR db_channel_name MISSING";
+    this.db_pg = db_pg;
+    this.notifListener = notifListener;
+    this.db_channel_name = db_channel_name;
+
+    if (!noInit) this.init()
+  }
+
+  async init(): Promise<PostgresNotifListenManager> {
+
+    this.connection = undefined;
+
+    this.isListening = await this.startListening();
+    return this;
+  }
+
+  get isReady() {
+    return this.isListening;
+  }
+
+  startListening() {
+    if (!this.db_pg || !this.notifListener) throw "PostgresNotifListenManager: db_pg OR notifListener missing";
+
+    return this.reconnect()
+      .catch(error => {
+        console.log('PostgresNotifListenManager: Failed Initial Connection:', error);
+      });
+  }
+
+  destroyed = false;
+  destroy = async () => {
+    this.destroyed = true;
+    await this.stopListening();
+    this.connection?.done();
+    this.connection = undefined;
+  }
+
+  stopListening = async () => {
+    if (this.db_channel_name) {
+      try {
+        await this.connection?.none('UNLISTEN $1~', [this.db_channel_name])
+        await this.client?.query('UNLISTEN $1~', [this.db_channel_name])
+      } catch(error){
+
+      }
+    }
+  }
+
+  reconnect(delay: number | undefined = 0, maxAttempts: number | undefined = 0) {
+    if (!this.db_pg || !this.notifListener) throw "db_pg OR notifListener missing";
+
+    if (this.destroyed) {
+      return Promise.reject("Destroyed")
+    }
+
+    delay = delay > 0 ? parseInt(delay + "") : 0;
+    maxAttempts = maxAttempts > 0 ? parseInt(maxAttempts + "") : 1;
+
+    const setListeners = (client: pg.IClient, notifListener: PrglNotifListener, db_channel_name: string) => {
+      client.on('notification', notifListener);
+      this.client = client;
+      if (!this.connection) throw "Connection missing";
+      return this.connection.none(
+        `/* prostgles-server internal query used for subscriptions and schema hot reload */ \nLISTEN $1~`, db_channel_name)
+        .catch(error => {
+          console.log("PostgresNotifListenManager: unexpected error: ", error); // unlikely to ever happen
+        });
+    },
+    removeListeners = (client: pg.IClient) => {
+      client.removeListener('notification', this.notifListener);
+    },
+    onConnectionLost = (err: any, e: pgPromise.ILostContext<pg.IClient>) => {
+
+      console.log('PostgresNotifListenManager: Connectivity Problem:', err);
+      this.connection = undefined; // prevent use of the broken connection
+      removeListeners(e.client);
+
+      this.reconnect(5000, 10) // retry 10 times, with 5-second intervals
+        .then(() => {
+          console.log('PostgresNotifListenManager: Successfully Reconnected');
+        })
+        .catch(() => {
+          // failed after 10 attempts
+          console.log('PostgresNotifListenManager: Connection Lost Permanently. No more retryies');
+          // process.exit(); // exiting the process
+        });
+    }
+
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        this.db_pg.connect({ direct: true, onLost: onConnectionLost })
+          .then(obj => {
+            this.connection = obj; // global connection is now available
+            resolve(obj);
+            return setListeners(obj.client, this.notifListener, this.db_channel_name);
+          })
+          .catch(error => {
+            /** Database was destroyed */
+            if(this.destroyed || error && error.code === "3D000") return;
+            console.log('PostgresNotifListenManager: Error Connecting:', error);
+            if (--maxAttempts) {
+              this.reconnect(delay, maxAttempts)
+                .then(resolve)
+                .catch(reject);
+            } else {
+              reject(error);
+            }
+          });
+      }, delay);
+    });
+  }
+}