prostgles-server 2.0.144 → 2.0.147

package/lib/FileManager.ts

@@ -8,7 +8,7 @@ import * as sharp from "sharp";
 
 import { DB, DbHandler, Prostgles } from './Prostgles';
 import { asName, AnyObject } from 'prostgles-types';
-import { TableHandler } from './DboBuilder';
+import { getKeys, TableHandler } from './DboBuilder';
 
 const HOUR = 3600 * 1000;
 
@@ -65,18 +65,24 @@ export type UploadedItem = {
 
 export default class FileManager {
   
-  s3Client: S3;
+  s3Client?: S3;
 
   config: S3Config | LocalConfig;
-  imageOptions: ImageOptions;
-
-  prostgles: Prostgles;
-  get dbo(): DbHandler { return this.prostgles.dbo };
-  get db(): DB { return this.prostgles.db };
+  imageOptions?: ImageOptions;
+
+  prostgles?: Prostgles;
+  get dbo(): DbHandler { 
+    if(!this.prostgles?.dbo) throw "this.prostgles.dbo missing"
+    return this.prostgles.dbo 
+  };
+  get db(): DB { 
+    if(!this.prostgles?.db) throw "this.prostgles.db missing"
+    return this.prostgles.db 
+  };
   
-  tableName: string;
+  tableName?: string;
 
-  private fileRoute: string;
+  private fileRoute?: string;
 
   constructor(config: FileManager["config"], imageOptions?: ImageOptions){
     this.config = config;
@@ -106,7 +112,7 @@ export default class FileManager {
     const nameParts = fileName.split(".");
     
     const nameExt = nameParts[nameParts.length - 1].toLowerCase(),
-      mime = Object.keys(CONTENT_TYPE_TO_EXT).find(k => CONTENT_TYPE_TO_EXT[k].includes(nameExt));
+      mime = getKeys(CONTENT_TYPE_TO_EXT).find(k => (CONTENT_TYPE_TO_EXT[k] as readonly string[]).includes(nameExt));
 
     let type = {
       fileName,
@@ -119,17 +125,17 @@ export default class FileManager {
     if(!mime){
       /* Set correct/missing extension */
       if(["xml", "txt", "csv", "tsv", "doc"].includes(nameExt)){
-        type = { ...type, mime: "text/" + nameExt, ext: nameExt };
+        type = { ...type, mime: ("text/" + nameExt) as any, ext: nameExt };
       } else if(["svg"].includes(nameExt)){
         type = { ...type, mime: "image/svg+xml", ext: nameExt };
       } else if(Buffer.isBuffer(file)){
-        const res = await FileType.fromBuffer(file);
+        const res: any = await FileType.fromBuffer(file);
         type = {
           ...res,
           fileName,
         }
       } else if(typeof file === "string"){
-        const res = await FileType.fromFile(file);
+        const res: any = await FileType.fromFile(file);
         type = {
           ...res,
           fileName,
@@ -158,10 +164,12 @@ export default class FileManager {
       if(nameExt !== ext) fileName = nameParts.slice(0, -1).join('') + "." + ext;
     }
 
-    return {
+    const res = {
       ...type,
       fileName
     }
+    if(!res.mime) throw "Could not find mime"
+    return res as any;
   }
 
   // async getUploadURL(fileName: string): Promise<string> {
@@ -227,7 +235,7 @@ export default class FileManager {
               ContentType: mime,
               Body: file
             };
-            this.s3Client.upload(params, (err, res: ManagedUpload.SendData) => {
+            this.s3Client.upload(params, (err: any, res: ManagedUpload.SendData) => {
               
               if(err){
                 reject("Something went wrong");
@@ -279,8 +287,8 @@ export default class FileManager {
           }
         }
         _data = await sharp(data)
-          .resize(opts)
-          .withMetadata(Boolean(imageOptions.keepMetadata))
+          .resize(opts as any)
+          .withMetadata(Boolean(imageOptions?.keepMetadata) as any)
           // .jpeg({ quality: 80 })
           .toBuffer()
       } else if(!imageOptions?.keepMetadata) {
@@ -304,10 +312,10 @@ export default class FileManager {
       Key: fileName,
       Expires: expiresInSeconds || 30 * 60
     };
-    return await this.s3Client.getSignedUrlPromise("getObject", params);
+    return await this.s3Client?.getSignedUrlPromise("getObject", params);
   }
 
-  private parseSQLIdentifier = async (name: string ) => asSQLIdentifier(name, this.prostgles.db);//  this.prostgles.dbo.sql<"value">("select format('%I', $1)", [name], { returnType: "value" } )
+  private parseSQLIdentifier = async (name: string ) => asSQLIdentifier(name, this.prostgles!.db!);//  this.prostgles.dbo.sql<"value">("select format('%I', $1)", [name], { returnType: "value" } )
 
   init = async (prg: Prostgles) => {
     this.prostgles = prg;
@@ -315,6 +323,7 @@ export default class FileManager {
     // const { dbo, db, opts } = prg;
     
     const { fileTable } = prg.opts;
+    if(!fileTable) throw "fileTable missing";
     const { tableName = "media", referencedTables = {} } = fileTable;
     this.tableName = tableName;
 
@@ -376,7 +385,7 @@ export default class FileManager {
         console.log(`Created ${action}`);
 
       } else {
-        const cols = await this.dbo[lookupTableName].getColumns();
+        const cols = await this.dbo[lookupTableName].getColumns!();
         const badCols = cols.filter(c => !c.references);
         await Promise.all(badCols.map(async badCol => {
           console.error(
@@ -436,7 +445,7 @@ export default class FileManager {
           const { name } = req.params;
           if(typeof name !== "string" || !name) throw "Invalid media name";
     
-          const media = await mediaTable.findOne({ name }, { select: { id: 1, name: 1, signed_url: 1, signed_url_expires: 1, content_type: 1 } }, { httpReq: req });
+          const media = await mediaTable.findOne({ name }, { select: { id: 1, name: 1, signed_url: 1, signed_url_expires: 1, content_type: 1 } }, { httpReq: req } as any);
     
           if(!media) {
             /**

package/lib/Filtering.ts

@@ -2,7 +2,7 @@
 
 import { SelectItem } from "./QueryBuilder";
 import { isEmpty, FullFilter, EXISTS_KEYS, FilterDataType, GeomFilterKeys, GeomFilter_Funcs, TextFilter_FullTextSearchFilterKeys } from "prostgles-types";
-import { isPlainObject } from "./DboBuilder";
+import { getKeys, isPlainObject } from "./DboBuilder";
 
 /**
 * Parse a single filter
@@ -17,9 +17,9 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
   const mErr = (msg: string) => {
       throw `${msg}: ${JSON.stringify(_f, null, 2)}`
     }, 
-    asValue = (v) => pgp.as.format("$1", [v]);
+    asValue = (v: any) => pgp.as.format("$1", [v]);
 
-  const fKeys = Object.keys(_f)
+  const fKeys = getKeys(_f)
   if(fKeys.length === 0){
       return "";
   } else if(fKeys.length > 1){
@@ -33,7 +33,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
     .join(" AND ")
   }
 
-  const fKey = fKeys[0];
+  const fKey: string = fKeys[0];
 
   /* Exists filter */
   if(EXISTS_KEYS.find(k => k in _f)){
@@ -42,17 +42,17 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
 
   let selItem: SelectItem | undefined;
   if(select) selItem = select.find(s => fKey === s.alias);
-  let rightF: FilterDataType = _f[fKey];
+  let rightF: FilterDataType = (_f as any)[fKey];
 
   const getLeftQ = (selItm: SelectItem) => {
-    if(selItm.type === "function") return selItem.getQuery();
-    return selItem.getQuery(tableAlias);
+    if(selItm.type === "function") return selItm.getQuery();
+    return selItm.getQuery(tableAlias);
   }
 
   /**
     * Parsed left side of the query
     */
-  let leftQ: string;// = asName(selItem.alias);
+  let leftQ: string | undefined;// = asName(selItem.alias);
 
   /* Check if string notation. Build obj if necessary */
   const dot_notation_delims = ["->", "."];
@@ -65,7 +65,10 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
         dot_notation_delims.find(dn => fKey.slice(s.alias.length).startsWith(dn)) 
       );
     }
-    if(!selItem) mErr("Bad filter. Could not match to a column or alias: ");
+    if(!selItem) {
+      mErr("Bad filter. Could not match to a column or alias: ");
+      throw " "
+    }
     const remainingStr = fKey.slice(selItem.alias.length);
 
     /* Is json path spec */
@@ -135,7 +138,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
         }
 
         const key = remainingStr.slice(currIdx + 1, nIdx);
-        curObj[key] = nextIdx > -1? {} : _f[fKey];
+        curObj[key] = nextIdx > -1? {} : (_f as any)[fKey];
         curObj = curObj[key];
 
         currIdx = nextIdx;
@@ -155,7 +158,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
 
   /* Matching sel item */
   if(isPlainObject(rightF)){
-    const parseRightVal = (val, expect: "csv" | "array" | null = null) => {
+    const parseRightVal = (val: any, expect: "csv" | "array" | null = null) => {
       const checkIfArr = () => {
         if(!Array.isArray(val)) return mErr("This type of filter/column expects an Array of items");
       }
@@ -177,7 +180,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
 
     const fOpType = filterKeys[0];
     const fVal = rightF[fOpType];
-    let sOpType: string;
+    let sOpType: string | undefined;
     let sVal: any;
 
     if(fVal && isPlainObject(fVal)){
@@ -227,7 +230,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
         return " FALSE ";
       }
 
-      let _fVal: any[] = fVal.filter(v => v !== null);
+      let _fVal: any[] = fVal.filter((v: any) => v !== null);
       let c1 = "", c2 = "";
       if(_fVal.length) c1 = leftQ + " IN " + parseRightVal(_fVal, "csv");
       if(fVal.includes(null)) c2 = ` ${leftQ} IS NULL `;
@@ -238,7 +241,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
         return " TRUE ";
       }
 
-      let _fVal: any[] = fVal.filter(v => v !== null);
+      let _fVal: any[] = fVal.filter((v: any) => v !== null);
       let c1 = "", c2 = "";
       if(_fVal.length) c1 = leftQ + " NOT IN " + parseRightVal(_fVal, "csv");
       if(fVal.includes(null)) c2 = ` ${leftQ} IS NOT NULL `;
@@ -274,9 +277,9 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
         return leftQ + operand + parseRightVal(fVal, "array");
           
       /* FTSQuery */
-      } else if(["@@"].includes(fOpType) && TextFilter_FullTextSearchFilterKeys.includes(sOpType)) {
+      } else if(["@@"].includes(fOpType) && TextFilter_FullTextSearchFilterKeys.includes(sOpType!)) {
         let lq = `to_tsvector(${leftQ}::text)`;
-        if(selItem && selItem.columnPGDataType === "tsvector") lq = leftQ;
+        if(selItem && selItem.columnPGDataType === "tsvector") lq = leftQ!;
 
         let res = `${lq} ${operand} ` + `${sOpType}${parseRightVal(sVal, "csv")}`;
 

package/lib/PostgresNotifListenManager.ts

@@ -9,14 +9,14 @@ 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>;
+    connection?: pgPromise.IConnected<{}, pg.IClient>;
     db_pg: DB;
     notifListener: PrglNotifListener;
     db_channel_name: string;
     isListening: any;
     client: any;
 
-    static create = (db_pg, notifListener: PrglNotifListener, db_channel_name: string): Promise<PostgresNotifListenManager> => {
+    static create = (db_pg: DB, notifListener: PrglNotifListener, db_channel_name: string): Promise<PostgresNotifListenManager> => {
         let res = new PostgresNotifListenManager(db_pg, notifListener, db_channel_name, true);
         return res.init();
     }
@@ -32,7 +32,7 @@ export class PostgresNotifListenManager {
 
     async init(): Promise<PostgresNotifListenManager> {
 
-        this.connection = null;
+        this.connection = undefined;
 
         this.isListening = await this.startListening();
         return this;
@@ -84,26 +84,27 @@ export class PostgresNotifListenManager {
         }
     }
 
-    reconnect(delay = null, maxAttempts = null) {
+    reconnect(delay: number | undefined = 0, maxAttempts: number | undefined = 0) {
         if(!this.db_pg || !this.notifListener) throw "db_pg OR notifListener missing";
 
-        delay = delay > 0 ? parseInt(delay) : 0;
-        maxAttempts = maxAttempts > 0 ? parseInt(maxAttempts) : 1;
+        delay = delay > 0 ? parseInt(delay + "") : 0;
+        maxAttempts = maxAttempts > 0 ? parseInt(maxAttempts + "") : 1;
 
-        const setListeners = (client, notifListener, db_channel_name) => {
+        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('LISTEN $1~', db_channel_name)
                     .catch(error => {
                         console.log("PostgresNotifListenManager: unexpected error: ", error); // unlikely to ever happen
                     });
             },    
-            removeListeners = (client) => {
+            removeListeners = (client: pg.IClient) => {
                 client.removeListener('notification', this.notifListener);
             },
-            onConnectionLost = (err, e) => {
+            onConnectionLost = (err: any, e: pgPromise.ILostContext<pg.IClient>) => {
                 console.log('PostgresNotifListenManager: Connectivity Problem:', err);
-                this.connection = null; // prevent use of the broken connection
+                this.connection = undefined; // prevent use of the broken connection
                 removeListeners(e.client);
                 this.reconnect(5000, 10) // retry 10 times, with 5-second intervals
                     .then(() => {