prostgles-server 4.2.183 → 4.2.185

package/lib/PostgresNotifListenManager.ts

@@ -23,22 +23,36 @@ export class PostgresNotifListenManager {
   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);
+  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";
+  };
+
+  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()
+    if (!noInit) this.init();
   }
 
   async init(): Promise<PostgresNotifListenManager> {
-
     this.connection = undefined;
 
     this.isListening = await this.startListening();
@@ -50,12 +64,15 @@ export class PostgresNotifListenManager {
   }
 
   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);
-      });
+    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;
@@ -64,75 +81,91 @@ export class PostgresNotifListenManager {
     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){
-
-      }
+        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";
+  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")
+      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
-        });
-    }
+    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.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);
+            return setListeners(
+              obj.client,
+              this.notifListener,
+              this.db_channel_name,
+            );
           })
-          .catch(error => {
+          .catch((error) => {
             /** Database was destroyed */
-            if(this.destroyed || error && error.code === "3D000") return;
-            console.log('PostgresNotifListenManager: Error Connecting:', error);
+            if (this.destroyed || (error && error.code === "3D000")) return;
+            console.log("PostgresNotifListenManager: Error Connecting:", error);
             if (--maxAttempts) {
-              this.reconnect(delay, maxAttempts)
-                .then(resolve)
-                .catch(reject);
+              this.reconnect(delay, maxAttempts).then(resolve).catch(reject);
             } else {
               reject(error);
             }
@@ -140,4 +173,4 @@ export class PostgresNotifListenManager {
       }, delay);
     });
   }
-}
+}

package/lib/Prostgles.ts

@@ -9,7 +9,10 @@ import { FileManager } from "./FileManager/FileManager";
 import { SchemaWatch } from "./SchemaWatch/SchemaWatch";
 import { OnInitReason, initProstgles } from "./initProstgles";
 import { makeSocketError, onSocketConnected } from "./onSocketConnected";
-import { clientCanRunSqlRequest, runClientSqlRequest } from "./runClientRequest";
+import {
+  clientCanRunSqlRequest,
+  runClientSqlRequest,
+} from "./runClientRequest";
 import pg = require("pg-promise/typescript/pg-subset");
 const { version } = require("../package.json");
 
@@ -27,15 +30,33 @@ import {
 export { DBHandlerServer };
 export type PGP = pgPromise.IMain<{}, pg.IClient>;
 
-import { CHANNELS, ClientSchema, SQLRequest, isObject, omitKeys, tryCatch } from "prostgles-types";
+import {
+  CHANNELS,
+  ClientSchema,
+  SQLRequest,
+  isObject,
+  omitKeys,
+  tryCatch,
+} from "prostgles-types";
 import { DBEventsManager } from "./DBEventsManager";
 import { PublishParser } from "./PublishParser/PublishParser";
-export { getOrSetTransporter, sendEmail, verifySMTPConfig } from "./Auth/sendEmail";
+export {
+  getOrSetTransporter,
+  sendEmail,
+  verifySMTPConfig,
+} from "./Auth/sendEmail";
 
 export type DB = pgPromise.IDatabase<{}, pg.IClient>;
 export type DBorTx = DB | pgPromise.ITask<{}>;
 
-export const TABLE_METHODS = ["update", "find", "findOne", "insert", "delete", "upsert"] as const;
+export const TABLE_METHODS = [
+  "update",
+  "find",
+  "findOne",
+  "insert",
+  "delete",
+  "upsert",
+] as const;
 
 /*
     1. Connect to db
@@ -146,10 +167,12 @@ export class Prostgles {
       testRulesOnConnect: 1,
     };
     const unknownParams = Object.keys(params).filter(
-      (key: string) => !Object.keys(config).includes(key)
+      (key: string) => !Object.keys(config).includes(key),
     );
     if (unknownParams.length) {
-      console.error(`Unrecognised ProstglesInitOptions params: ${unknownParams.join()}`);
+      console.error(
+        `Unrecognised ProstglesInitOptions params: ${unknownParams.join()}`,
+      );
     }
 
     Object.assign(this.opts, params);
@@ -168,7 +191,8 @@ export class Prostgles {
   destroyed = false;
 
   checkDb() {
-    if (!this.db || !this.db.connect) throw "something went wrong getting a db connection";
+    if (!this.db || !this.db.connect)
+      throw "something went wrong getting a db connection";
   }
 
   getTSFileName() {
@@ -206,11 +230,16 @@ export class Prostgles {
       fs.readFile(fullPath, "utf8", function (err, data) {
         if (err || force || data !== fileContent) {
           fs.writeFileSync(fullPath, fileContent);
-          console.log("Prostgles: Created typescript schema definition file: \n " + fileName);
+          console.log(
+            "Prostgles: Created typescript schema definition file: \n " +
+              fileName,
+          );
         }
       });
     } else if (force) {
-      console.error("Schema changed. tsGeneratedTypesDir needs to be set to reload server");
+      console.error(
+        "Schema changed. tsGeneratedTypesDir needs to be set to reload server",
+      );
     }
   }
 
@@ -283,7 +312,11 @@ export class Prostgles {
         }
       }
     });
-    await this.opts.onLog?.({ type: "debug", command: "initTableConfig", ...res });
+    await this.opts.onLog?.({
+      type: "debug",
+      command: "initTableConfig",
+      ...res,
+    });
     if (res.hasError) throw res.error;
     return res.data;
   };
@@ -297,7 +330,10 @@ export class Prostgles {
         if (!cloudClient && !localConfig)
           throw "fileTable missing param: Must provide awsS3Config OR localConfig";
 
-        this.fileManager = new FileManager(cloudClient || localConfig!, imageOptions);
+        this.fileManager = new FileManager(
+          cloudClient || localConfig!,
+          imageOptions,
+        );
 
         try {
           await this.fileManager.init(this);
@@ -332,7 +368,9 @@ export class Prostgles {
       const result = await this.db
         ?.multi(fileContent)
         .then((data) => {
-          console.log("Prostgles: SQL file executed successfuly \n    -> " + filePath);
+          console.log(
+            "Prostgles: SQL file executed successfuly \n    -> " + filePath,
+          );
           return data;
         })
         .catch((err) => {
@@ -343,14 +381,17 @@ export class Prostgles {
           if (position && length && fileContent) {
             const startLine = Math.max(
                 0,
-                fileContent.substring(0, position).split("\n").length - 2
+                fileContent.substring(0, position).split("\n").length - 2,
               ),
               endLine = startLine + 3;
 
             errMsg += "\n\n";
             errMsg += lines
               .slice(startLine, endLine)
-              .map((txt, i) => `${startLine + i + 1} ${i === 1 ? "->" : "  "} ${txt}`)
+              .map(
+                (txt, i) =>
+                  `${startLine + i + 1} ${i === 1 ? "->" : "  "} ${txt}`,
+              )
               .join("\n");
             errMsg += "\n\n";
           }
@@ -377,7 +418,7 @@ export class Prostgles {
       this.opts.publishRawSQL,
       this.dbo,
       this.db!,
-      this
+      this,
     );
     this.publishParser = publishParser;
 
@@ -396,33 +437,49 @@ export class Prostgles {
     this.opts.io.removeAllListeners("connection");
     this.opts.io.on("connection", this.onSocketConnected);
     /** In some cases io will re-init with already connected sockets */
-    this.opts.io?.sockets.sockets.forEach((socket) => this.onSocketConnected(socket));
+    this.opts.io?.sockets.sockets.forEach((socket) =>
+      this.onSocketConnected(socket),
+    );
   }
 
   onSocketConnected = onSocketConnected.bind(this);
 
-  getClientSchema = async (clientReq: Pick<LocalParams, "socket" | "httpReq">) => {
+  getClientSchema = async (
+    clientReq: Pick<LocalParams, "socket" | "httpReq">,
+  ) => {
     const result = await tryCatch(async () => {
-      const clientInfo =
-        clientReq.socket ? { type: "socket" as const, socket: clientReq.socket }
-        : clientReq.httpReq ? { type: "http" as const, httpReq: clientReq.httpReq }
-        : undefined;
+      const clientInfo = clientReq.socket
+        ? { type: "socket" as const, socket: clientReq.socket }
+        : clientReq.httpReq
+          ? { type: "http" as const, httpReq: clientReq.httpReq }
+          : undefined;
       if (!clientInfo) throw "Invalid client";
       if (!this.authHandler) throw "this.authHandler missing";
       const userData = await this.authHandler.getClientInfo(clientInfo);
       const { publishParser } = this;
-      let fullSchema: Awaited<ReturnType<PublishParser["getSchemaFromPublish"]>> | undefined;
+      let fullSchema:
+        | Awaited<ReturnType<PublishParser["getSchemaFromPublish"]>>
+        | undefined;
       let publishValidationError;
 
       try {
         if (!publishParser) throw "publishParser undefined";
-        fullSchema = await publishParser.getSchemaFromPublish({ ...clientInfo, userData });
+        fullSchema = await publishParser.getSchemaFromPublish({
+          ...clientInfo,
+          userData,
+        });
       } catch (e) {
         publishValidationError = e;
-        console.error(`\nProstgles Publish validation failed (after socket connected):\n    ->`, e);
+        console.error(
+          `\nProstgles Publish validation failed (after socket connected):\n    ->`,
+          e,
+        );
       }
       let rawSQL = false;
-      if (this.opts.publishRawSQL && typeof this.opts.publishRawSQL === "function") {
+      if (
+        this.opts.publishRawSQL &&
+        typeof this.opts.publishRawSQL === "function"
+      ) {
         const { allowed } = await clientCanRunSqlRequest.bind(this)(clientInfo);
         rawSQL = allowed;
       }
@@ -436,7 +493,10 @@ export class Prostgles {
       if (this.opts.joins) {
         const _joinTables2 = this.dboBuilder
           .getAllJoinPaths()
-          .filter((jp) => ![jp.t1, jp.t2].find((t) => !schema[t] || !schema[t]?.findOne))
+          .filter(
+            (jp) =>
+              ![jp.t1, jp.t2].find((t) => !schema[t] || !schema[t]?.findOne),
+          )
           .map((jp) => [jp.t1, jp.t2].sort());
         _joinTables2.map((jt) => {
           if (!joinTables2.find((_jt) => _jt.join() === jt.join())) {
@@ -445,11 +505,13 @@ export class Prostgles {
         });
       }
 
-      const methods = await publishParser?.getAllowedMethods(clientInfo, userData);
+      const methods = await publishParser?.getAllowedMethods(
+        clientInfo,
+        userData,
+      );
 
-      const methodSchema: ClientSchema["methods"] =
-        !methods ?
-          []
+      const methodSchema: ClientSchema["methods"] = !methods
+        ? []
         : Object.entries(methods)
             .map(([methodName, method]) => {
               if (isObject(method) && "run" in method) {
@@ -477,7 +539,9 @@ export class Prostgles {
         tableSchemaErrors,
         auth,
         version,
-        err: publishValidationError ? "Server Error: User publish validation failed." : undefined,
+        err: publishValidationError
+          ? "Server Error: User publish validation failed."
+          : undefined,
       };
 
       return {
@@ -486,7 +550,8 @@ export class Prostgles {
         userData,
       };
     });
-    const sid = result.userData?.sid ?? this.authHandler?.getSIDNoError(clientReq);
+    const sid =
+      result.userData?.sid ?? this.authHandler?.getSIDNoError(clientReq);
     await this.opts.onLog?.({
       type: "connect.getClientSchema",
       duration: result.duration,
@@ -510,17 +575,23 @@ export class Prostgles {
             { query, params, options }: SQLRequest,
             cb = (..._callback: any) => {
               /* Empty */
-            }
+            },
           ) => {
             runClientSqlRequest
-              .bind(this)({ type: "socket", socket, query, args: params, options })
+              .bind(this)({
+                type: "socket",
+                socket,
+                query,
+                args: params,
+                options,
+              })
               .then((res) => {
                 cb(null, res);
               })
               .catch((err) => {
                 makeSocketError(cb, err);
               });
-          }
+          },
         );
       }
       await this.dboBuilder.prostgles.opts.onLog?.({

package/lib/ProstglesTypes.ts

@@ -1,7 +1,11 @@
 import { FileColumnConfig } from "prostgles-types";
 import { Auth, AuthRequestParams, SessionUser } from "./Auth/AuthTypes";
 import { EventTriggerTagFilter } from "./Event_Trigger_Tags";
-import { CloudClient, ImageOptions, LocalConfig } from "./FileManager/FileManager";
+import {
+  CloudClient,
+  ImageOptions,
+  LocalConfig,
+} from "./FileManager/FileManager";
 import { DbConnection, OnReadyCallback } from "./initProstgles";
 import { EventInfo } from "./Logging";
 import { ExpressApp, RestApiConfig } from "./RestApi";
@@ -16,7 +20,11 @@ import pg from "pg-promise/typescript/pg-subset";
 import { AnyObject } from "prostgles-types";
 import type { Server } from "socket.io";
 import { DB } from "./Prostgles";
-import { Publish, PublishMethods, PublishParams } from "./PublishParser/PublishParser";
+import {
+  Publish,
+  PublishMethods,
+  PublishParams,
+} from "./PublishParser/PublishParser";
 
 /**
  * Allows uploading and downloading files.
@@ -94,7 +102,12 @@ export type FileTableConfig = {
   localConfig?: LocalConfig;
 };
 
-export const JOIN_TYPES = ["one-many", "many-one", "one-one", "many-many"] as const;
+export const JOIN_TYPES = [
+  "one-many",
+  "many-one",
+  "one-one",
+  "many-many",
+] as const;
 export type Join = {
   tables: [string, string];
   on: { [key: string]: string }[]; // Allow multi references to table
@@ -102,7 +115,10 @@ export type Join = {
 };
 type Joins = Join[] | "inferred";
 
-export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUser> = {
+export type ProstglesInitOptions<
+  S = void,
+  SUser extends SessionUser = SessionUser,
+> = {
   /**
    * Database connection details and options
    */
@@ -171,7 +187,9 @@ export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUs
   /**
    * If defined and resolves to true then the connected client can run SQL queries
    */
-  publishRawSQL?(params: PublishParams<S, SUser>): (boolean | "*") | Promise<boolean | "*">;
+  publishRawSQL?(
+    params: PublishParams<S, SUser>,
+  ): (boolean | "*") | Promise<boolean | "*">;
 
   /**
    * Server-side functions that can be invoked by the client
@@ -218,14 +236,14 @@ export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUs
    * Use for connection verification. Will disconnect socket on any errors
    */
   onSocketConnect?: (
-    args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket }
+    args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket },
   ) => void | Promise<void>;
 
   /**
    * Called when a socket disconnects
    */
   onSocketDisconnect?: (
-    args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket }
+    args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket },
   ) => void | Promise<void>;
 
   /**
@@ -263,7 +281,11 @@ export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUs
    * - `OnSchemaChangeCallback` - custom callback to be fired. Nothing else triggered
    * Useful for development
    */
-  watchSchema?: boolean | EventTriggerTagFilter | "hotReloadMode" | OnSchemaChangeCallback;
+  watchSchema?:
+    | boolean
+    | EventTriggerTagFilter
+    | "hotReloadMode"
+    | OnSchemaChangeCallback;
 
   /**
    * Called when a notice is received from the database
@@ -335,6 +357,6 @@ type OnMigrate = (args: {
   getConstraints: (
     table: string,
     column?: string,
-    types?: ColConstraint["type"][]
+    types?: ColConstraint["type"][],
   ) => Promise<ColConstraint[]>;
 }) => void;