prostgles-server 4.2.179 → 4.2.181

package/lib/Prostgles.ts

@@ -3,37 +3,37 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as pgPromise from 'pg-promise';
+import * as pgPromise from "pg-promise";
 import { AuthHandler } from "./Auth/AuthHandler";
 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 pg = require('pg-promise/typescript/pg-subset');
-const { version } = require('../package.json');
+import pg = require("pg-promise/typescript/pg-subset");
+const { version } = require("../package.json");
 
 import type { ProstglesInitOptions } from "./ProstglesTypes";
 import { RestApi } from "./RestApi";
 import TableConfigurator from "./TableConfig/TableConfig";
- 
-import { DBHandlerServer, DboBuilder, LocalParams, PRGLIOSocket, getErrorAsObject } from "./DboBuilder/DboBuilder";
+
+import {
+  DBHandlerServer,
+  DboBuilder,
+  LocalParams,
+  PRGLIOSocket,
+  getErrorAsObject,
+} from "./DboBuilder/DboBuilder";
 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 type DB = pgPromise.IDatabase<{}, pg.IClient>;
-export type DBorTx = DB | pgPromise.ITask<{}>
-
+export type DBorTx = DB | pgPromise.ITask<{}>;
 
 export const TABLE_METHODS = ["update", "find", "findOne", "insert", "delete", "upsert"] as const;
 
@@ -48,17 +48,17 @@ export const TABLE_METHODS = ["update", "find", "findOne", "insert", "delete", "
 export type OnReady = {
   dbo: DBHandlerServer;
   db: DB;
-}
+};
 
 const DEFAULT_KEYWORDS = {
   $filter: "$filter",
   $and: "$and",
   $or: "$or",
-  $not: "$not"
+  $not: "$not",
 };
 
 import { randomUUID } from "crypto";
-import * as fs from 'fs';
+import * as fs from "fs";
 
 export class Prostgles {
   /**
@@ -70,22 +70,22 @@ export class Prostgles {
     dbConnection: {
       host: "localhost",
       port: 5432,
-      application_name: "prostgles_app"
+      application_name: "prostgles_app",
     },
-    onReady: () => { 
-      //empty 
+    onReady: () => {
+      //empty
     },
     watchSchema: false,
     watchSchemaType: "DDL_trigger",
   };
- 
+
   db?: DB;
   pgp?: PGP;
   dbo?: DBHandlerServer;
   _dboBuilder?: DboBuilder;
   get dboBuilder(): DboBuilder {
     if (!this._dboBuilder) {
-      console.trace(1)
+      console.trace(1);
       throw "get dboBuilder: it's undefined";
     }
     return this._dboBuilder;
@@ -118,14 +118,38 @@ export class Prostgles {
     if (!params) throw "ProstglesInitOptions missing";
 
     const config: Record<keyof ProstglesInitOptions, 1> = {
-      transactions: 1, joins: 1, tsGeneratedTypesDir: 1, disableRealtime: 1,
-      onReady: 1, dbConnection: 1, dbOptions: 1, publishMethods: 1, 
-      io: 1, publish: 1, schema: 1, publishRawSQL: 1, wsChannelNamePrefix: 1, 
-      onSocketConnect: 1, onSocketDisconnect: 1, sqlFilePath: 1, auth: 1, 
-      DEBUG_MODE: 1, watchSchema: 1, watchSchemaType: 1, fileTable: 1, onQuery: 1,
-      tableConfig: 1, tableConfigMigrations: 1, keywords: 1, onNotice: 1, onLog: 1, restApi: 1, testRulesOnConnect: 1
+      transactions: 1,
+      joins: 1,
+      tsGeneratedTypesDir: 1,
+      disableRealtime: 1,
+      onReady: 1,
+      dbConnection: 1,
+      publishMethods: 1,
+      io: 1,
+      publish: 1,
+      schema: 1,
+      publishRawSQL: 1,
+      wsChannelNamePrefix: 1,
+      onSocketConnect: 1,
+      onSocketDisconnect: 1,
+      sqlFilePath: 1,
+      auth: 1,
+      DEBUG_MODE: 1,
+      watchSchema: 1,
+      watchSchemaType: 1,
+      fileTable: 1,
+      onQuery: 1,
+      tableConfig: 1,
+      tableConfigMigrations: 1,
+      keywords: 1,
+      onNotice: 1,
+      onLog: 1,
+      restApi: 1,
+      testRulesOnConnect: 1,
     };
-    const unknownParams = Object.keys(params).filter((key: string) => !Object.keys(config).includes(key))
+    const unknownParams = Object.keys(params).filter(
+      (key: string) => !Object.keys(config).includes(key)
+    );
     if (unknownParams.length) {
       console.error(`Unrecognised ProstglesInitOptions params: ${unknownParams.join()}`);
     }
@@ -136,12 +160,12 @@ export class Prostgles {
     if (this.opts?.fileTable) {
       this.opts.fileTable.tableName ??= "media";
     }
-    this.opts.schema ??= { "public": 1 };
+    this.opts.schema ??= { public: 1 };
 
     this.keywords = {
       ...DEFAULT_KEYWORDS,
       ...params.keywords,
-    }
+    };
   }
 
   destroyed = false;
@@ -151,45 +175,45 @@ export class Prostgles {
   }
 
   getTSFileName() {
-    const fileName = "DBoGenerated.d.ts" //`dbo_${this.schema}_types.ts`;
-    const _dir = (this.opts.tsGeneratedTypesDir || "");
-    const dir = _dir.endsWith("/")? _dir : `${_dir}/`;
+    const fileName = "DBGeneratedSchema.d.ts"; //`dbo_${this.schema}_types.ts`;
+    const _dir = this.opts.tsGeneratedTypesDir || "";
+    const dir = _dir.endsWith("/") ? _dir : `${_dir}/`;
     const fullPath = dir + fileName;
-    return { fileName, fullPath }
+    return { fileName, fullPath };
   }
 
   private getFileText(fullPath: string, _format = "utf8"): Promise<string> {
     return new Promise((resolve, reject) => {
-      fs.readFile(fullPath, 'utf8', function (err, data) {
+      fs.readFile(fullPath, "utf8", function (err, data) {
         if (err) reject(err);
         else resolve(data);
       });
-    })
+    });
   }
 
   getTSFileContent = () => {
-    const header = `/* This file was generated by Prostgles \n` +
-    // `* ${(new Date).toUTCString()} \n` 
-    `*/ \n\n `;
+    const header =
+      `/* This file was generated by Prostgles \n` +
+      // `* ${(new Date).toUTCString()} \n`
+      `*/ \n\n `;
     return header + this.dboBuilder.tsTypesDefinition;
-  }
+  };
 
   /**
    * Will write the Schema Typescript definitions to file (tsGeneratedTypesDir)
    */
   writeDBSchema(force = false) {
-
     if (this.opts.tsGeneratedTypesDir) {
       const { fullPath, fileName } = this.getTSFileName();
       const fileContent = this.getTSFileContent();
-      fs.readFile(fullPath, 'utf8', function (err, data) {
-        if (err || (force || data !== fileContent)) {
+      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");
     }
   }
 
@@ -197,11 +221,11 @@ export class Prostgles {
    * Will re-create the dbo object
    */
   refreshDBO = async () => {
-    await this.opts.onLog?.({ 
-      type: "debug", 
-      command: "refreshDBO.start", 
-      duration: -1, 
-      data: { } 
+    await this.opts.onLog?.({
+      type: "debug",
+      command: "refreshDBO.start",
+      duration: -1,
+      data: {},
     });
     const start = Date.now();
     if (this._dboBuilder) {
@@ -211,9 +235,13 @@ export class Prostgles {
     }
     if (!this.dboBuilder) throw "this.dboBuilder";
     this.dbo = this.dboBuilder.dbo;
-    await this.opts.onLog?.({ type: "debug", command: "refreshDBO.end", duration: Date.now() - start })
+    await this.opts.onLog?.({
+      type: "debug",
+      command: "refreshDBO.end",
+      duration: Date.now() - start,
+    });
     return this.dbo;
-  }
+  };
 
   initRestApi = async () => {
     if (this.opts.restApi) {
@@ -222,29 +250,36 @@ export class Prostgles {
       this.restApi?.destroy();
       this.restApi = undefined;
     }
-  }
+  };
 
   initAuthHandler = async () => {
     this.authHandler?.destroy();
     this.authHandler = new AuthHandler(this as any);
     await this.authHandler.init();
-  }
+  };
 
   initTableConfig = async (reason: OnInitReason) => {
     const res = await tryCatch(async () => {
-
-      if(this.tableConfigurator?.initialising){
+      if (this.tableConfigurator?.initialising) {
         console.error("TableConfigurator WILL deadlock", { reason });
       }
       await this.tableConfigurator?.destroy();
       this.tableConfigurator = new TableConfigurator(this);
       try {
         const now = Date.now();
-        await this.opts.onLog?.({ type: "debug", command: "tableConfigurator.init.start", duration: -1 });
+        await this.opts.onLog?.({
+          type: "debug",
+          command: "tableConfigurator.init.start",
+          duration: -1,
+        });
         await this.tableConfigurator.init();
-        await this.opts.onLog?.({ type: "debug", command: "tableConfigurator.init.end", duration: Date.now() - now });
+        await this.opts.onLog?.({
+          type: "debug",
+          command: "tableConfigurator.init.end",
+          duration: Date.now() - now,
+        });
       } catch (e) {
-        if(this.opts.tableConfigMigrations?.silentFail === false){
+        if (this.opts.tableConfigMigrations?.silentFail === false) {
           console.error("TableConfigurator silentFail: ", e);
         } else {
           throw e;
@@ -252,21 +287,21 @@ export class Prostgles {
       }
     });
     await this.opts.onLog?.({ type: "debug", command: "initTableConfig", ...res });
-    if(res.hasError) throw res.error;
+    if (res.hasError) throw res.error;
     return res.data;
-  }
+  };
 
   /* Create media table if required */
   initFileTable = async () => {
     const res = await tryCatch(async () => {
-
       if (this.opts.fileTable) {
         const { cloudClient, localConfig, imageOptions } = this.opts.fileTable;
         await this.refreshDBO();
-        if (!cloudClient && !localConfig) throw "fileTable missing param: Must provide awsS3Config OR localConfig";
-  
+        if (!cloudClient && !localConfig)
+          throw "fileTable missing param: Must provide awsS3Config OR localConfig";
+
         this.fileManager = new FileManager(cloudClient || localConfig!, imageOptions);
-  
+
         try {
           await this.fileManager.init(this);
         } catch (e) {
@@ -278,55 +313,61 @@ export class Prostgles {
         this.fileManager = undefined;
       }
       await this.refreshDBO();
-      return { data: {} }
+      return { data: {} };
     });
-    await this.opts.onLog?.({ 
-      type: "debug", 
-      command: "initFileTable", 
+    await this.opts.onLog?.({
+      type: "debug",
+      command: "initFileTable",
       ...res,
     });
-    if(res.error !== undefined) throw res.error;
+    if (res.error !== undefined) throw res.error;
     return res.data;
-  }
+  };
 
   isSuperUser = false;
 
   init = initProstgles.bind(this);
 
   async runSQLFile(filePath: string) {
-
     const res = await tryCatch(async () => {
-      const fileContent = await this.getFileText(filePath);//.then(console.log);
-  
-      const result = await this.db?.multi(fileContent)
+      const fileContent = await this.getFileText(filePath); //.then(console.log);
+
+      const result = await this.db
+        ?.multi(fileContent)
         .then((data) => {
           console.log("Prostgles: SQL file executed successfuly \n    -> " + filePath);
           return data;
-        }).catch((err) => {
+        })
+        .catch((err) => {
           const { position, length } = err,
             lines = fileContent.split("\n");
           let errMsg = filePath + " error: ";
-    
+
           if (position && length && fileContent) {
-            const startLine = Math.max(0, fileContent.substring(0, position).split("\n").length - 2),
+            const startLine = Math.max(
+                0,
+                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}`).join("\n");
+            errMsg += lines
+              .slice(startLine, endLine)
+              .map((txt, i) => `${startLine + i + 1} ${i === 1 ? "->" : "  "} ${txt}`)
+              .join("\n");
             errMsg += "\n\n";
           }
           console.error(errMsg, err);
           return Promise.reject(err);
         });
-      return { success: result?.length }
+      return { success: result?.length };
     });
 
     await this.opts.onLog?.({ type: "debug", command: "runSQLFile", ...res });
-    if(res.error !== undefined) throw res.error;
+    if (res.error !== undefined) throw res.error;
     return res.success;
   }
 
-
   connectedSockets: PRGLIOSocket[] = [];
   async setSocketEvents() {
     this.checkDb();
@@ -334,11 +375,11 @@ export class Prostgles {
     if (!this.dbo) throw "dbo missing";
 
     const publishParser = new PublishParser(
-      this.opts.publish, 
-      this.opts.publishMethods, 
-      this.opts.publishRawSQL, 
-      this.dbo, 
-      this.db!, 
+      this.opts.publish,
+      this.opts.publishMethods,
+      this.opts.publishRawSQL,
+      this.dbo,
+      this.db!,
       this
     );
     this.publishParser = publishParser;
@@ -347,7 +388,7 @@ export class Prostgles {
 
     /* Already initialised. Only reconnect sockets */
     if (this.connectedSockets.length) {
-      this.connectedSockets.forEach(s => {
+      this.connectedSockets.forEach((s) => {
         s.emit(CHANNELS.SCHEMA_CHANGED);
         this.pushSocketSchema(s);
       });
@@ -355,22 +396,23 @@ export class Prostgles {
     }
 
     /* Initialise */
-    this.opts.io.removeAllListeners('connection');
-    this.opts.io.on('connection', this.onSocketConnected);
+    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">) => {
-
     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;
-      if(!clientInfo) throw "Invalid client";
-      if(!this.authHandler) throw "this.authHandler missing";
-      const userData = await this.authHandler.getClientInfo(clientInfo); 
+      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 publishValidationError;
@@ -388,15 +430,19 @@ export class Prostgles {
         rawSQL = allowed;
       }
 
-      const { schema, tables, tableSchemaErrors } = fullSchema ?? { schema: {}, tables: [], tableSchemaErrors: {} };
+      const { schema, tables, tableSchemaErrors } = fullSchema ?? {
+        schema: {},
+        tables: [],
+        tableSchemaErrors: {},
+      };
       const joinTables2: string[][] = [];
       if (this.opts.joins) {
-        const _joinTables2 = this.dboBuilder.getAllJoinPaths()
-          .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())) {
+        const _joinTables2 = this.dboBuilder
+          .getAllJoinPaths()
+          .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())) {
             joinTables2.push(jt);
           }
         });
@@ -404,78 +450,97 @@ export class Prostgles {
 
       const methods = await publishParser?.getAllowedMethods(clientInfo, userData);
 
-      const methodSchema: ClientSchema["methods"] = !methods? [] : Object.entries(methods).map(([methodName, method]) => {
-        if(isObject(method) && "run" in method){
-          return {
-            name: methodName,
-            ...omitKeys(method, ["run"]),
-          }
-        }
-        return methodName;
-      }).sort((a, b) => {
-        const aName = isObject(a)? a.name : a;
-        const bName = isObject(b)? b.name : b;
-        return aName.localeCompare(bName);        
-      });
+      const methodSchema: ClientSchema["methods"] =
+        !methods ?
+          []
+        : Object.entries(methods)
+            .map(([methodName, method]) => {
+              if (isObject(method) && "run" in method) {
+                return {
+                  name: methodName,
+                  ...omitKeys(method, ["run"]),
+                };
+              }
+              return methodName;
+            })
+            .sort((a, b) => {
+              const aName = isObject(a) ? a.name : a;
+              const bName = isObject(b) ? b.name : b;
+              return aName.localeCompare(bName);
+            });
 
       const { auth } = await this.authHandler.getClientAuth(clientReq);
-      
+
       const clientSchema: ClientSchema = {
         schema,
-        methods: methodSchema, 
+        methods: methodSchema,
         tableSchema: tables,
         rawSQL,
         joinTables: joinTables2,
         tableSchemaErrors,
         auth,
         version,
-        err: publishValidationError? "Server Error: User publish validation failed." : undefined
+        err: publishValidationError ? "Server Error: User publish validation failed." : undefined,
       };
-      
+
       return {
         publishValidationError,
         clientSchema,
-        userData
-      }
+        userData,
+      };
     });
     const sid = result.userData?.sid ?? this.authHandler?.getSIDNoError(clientReq);
-    await this.opts.onLog?.({ 
+    await this.opts.onLog?.({
       type: "connect.getClientSchema",
       duration: result.duration,
       sid,
       socketId: clientReq.socket?.id,
       error: result.error || result.publishValidationError,
     });
-    if(result.hasError) throw result.error;
+    if (result.hasError) throw result.error;
     return result.clientSchema;
-  }
+  };
 
   pushSocketSchema = async (socket: PRGLIOSocket) => {
-
     try {
       const clientSchema = await this.getClientSchema({ socket });
       socket.prostgles = clientSchema;
       if (clientSchema.rawSQL) {
-        socket.removeAllListeners(CHANNELS.SQL)
-        socket.on(CHANNELS.SQL, async ({ query, params, options }: SQLRequest, cb = (..._callback: any) => { /* Empty */ }) => {
-
-          runClientSqlRequest.bind(this)({ type: "socket", socket, query, args: params, options }).then(res => {
-            cb(null, res);
-          }).catch(err => {
-            makeSocketError(cb, err);
-          });
-        });
+        socket.removeAllListeners(CHANNELS.SQL);
+        socket.on(
+          CHANNELS.SQL,
+          async (
+            { query, params, options }: SQLRequest,
+            cb = (..._callback: any) => {
+              /* Empty */
+            }
+          ) => {
+            runClientSqlRequest
+              .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?.({ type: "debug", command: "pushSocketSchema", duration: -1, data: { socketId: socket.id, clientSchema } });
+      await this.dboBuilder.prostgles.opts.onLog?.({
+        type: "debug",
+        command: "pushSocketSchema",
+        duration: -1,
+        data: { socketId: socket.id, clientSchema },
+      });
       socket.emit(CHANNELS.SCHEMA, clientSchema);
-
     } catch (err) {
       socket.emit(CHANNELS.SCHEMA, { err: getErrorAsObject(err) });
     }
-  }
+  };
 }
 
-
 export async function getIsSuperUser(db: DB): Promise<boolean> {
-  return db.oneOrNone("select usesuper from pg_user where usename = CURRENT_USER;").then(r => r.usesuper);
-}
+  return db
+    .oneOrNone("select usesuper from pg_user where usename = CURRENT_USER;")
+    .then((r) => r.usesuper);
+}