prostgles-server 2.0.144 → 2.0.147

package/lib/QueryBuilder.ts

@@ -5,9 +5,9 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { pgp, Filter, LocalParams, isPlainObject, TableHandler, ViewHandler, postgresToTsType } from "./DboBuilder";
-import { TableRule, flat } from "./Prostgles";
+import { TableRule } from "./Prostgles";
 import { SelectParamsBasic as SelectParams, isEmpty, FieldFilter, asName, TextFilter_FullTextSearchFilterKeys, TS_PG_Types, ColumnInfo, PG_COLUMN_UDT_DATA_TYPE } from "prostgles-types";
-import { get } from "./utils";
+import { get, isObject } from "./utils";
 
 
 export type SelectItem = {
@@ -47,6 +47,65 @@ export const asNameAlias = (field: string, tableAlias?: string) => {
   return result;
 }
 
+export const parseFunctionObject = (funcData: any): { funcName: string; args: any[] } => {
+  const makeErr = (msg: string) => `Function not specified correctly. Expecting { $funcName: ["columnName",...] } object but got: ${JSON.stringify(funcData)} \n ${msg}`
+  if(!isObject(funcData)) throw makeErr("");
+  const keys = Object.keys(funcData);
+  if(keys.length !== 1) throw makeErr("");
+  const funcName = keys[0];
+  const args = funcData[funcName];
+  if(!args || !Array.isArray(args)){
+    throw makeErr("Arguments missing or invalid");
+  }
+
+  return { funcName, args };
+}
+
+export const parseFunction = (funcData: { func: string | FunctionSpec, args: any[],  functions: FunctionSpec[]; allowedFields: string[]; }): FunctionSpec => {
+  const { func, args, functions, allowedFields } = funcData;
+
+  /* Function is computed column. No checks needed */
+  if(typeof func !== "string"){
+    const computedCol = COMPUTED_FIELDS.find(c => c.name === func.name);
+    if(!computedCol) throw `Unexpected function: computed column spec not found for ${JSON.stringify(func.name)}`;
+    return func;
+  }
+
+  const funcName = func;
+  const makeErr = (msg: string): string => {
+    return `Issue with function ${JSON.stringify({ [funcName]: args })}: \n${msg}`
+  }
+
+  /* Find function */
+  const funcDef = functions.find(f => f.name === funcName);
+
+  if(!funcDef) {
+    const sf = functions.filter(f => f.name.toLowerCase().slice(1).startsWith(funcName.toLowerCase())).sort((a, b) => (a.name.length - b.name.length));
+    const hint = (sf.length? `. \n Maybe you meant: \n | ${sf.map(s => s.name + " " + (s.description || "")).join("    \n | ")}  ?` : "");
+    throw "\n Function " + funcName + " does not exist or is not allowed " + hint;
+  }
+  
+  /* Validate fields */
+  const fields = funcDef.getFields(args);
+  if(fields !== "*"){
+    fields.forEach(fieldKey => {
+      if(typeof fieldKey !== "string" || !allowedFields.includes(fieldKey)) {
+        throw makeErr(`getFields() => field name ${JSON.stringify(fieldKey)} is invalid or disallowed`)
+      }
+    });
+    if((funcDef.minCols ?? 0) > fields.length){
+      throw makeErr(`Less columns provided than necessary (minCols=${funcDef.minCols})`)
+    }
+  }
+
+  if(funcDef.numArgs && funcDef.minCols !== 0 && fields !== "*" && Array.isArray(fields) && !fields.length) {
+    throw `\n Function "${funcDef.name}" expects at least a field name but has not been provided with one`;
+  }
+
+  return funcDef;
+}
+
+
 type GetQueryArgs = { 
   allColumns: ColumnInfo[];
   allowedFields: string[];
@@ -84,17 +143,29 @@ export type FunctionSpec = {
    */
   // returnsBoolean?: boolean;
 
+  /**
+   * Number of arguments expected
+   */
   numArgs: number;
+
+  /**
+   * If provided then the number of column names provided to the function (from getFields()) must not be less than this
+   * By default every function is checked against numArgs
+   */
+  minCols?: number;
+
   type: "function" | "aggregation" | "computed";
   /**
    * getFields: string[] -> used to validate user supplied field names. It will be fired before querying to validate against allowed columns
    *      if not field names are used from arguments then return an empty array
    */
-  getFields: (args: any[], allowedFields: string[]) => "*" | string[];
+  getFields: (args: any[]) => "*" | string[];
   /**
    * allowedFields passed for multicol functions (e.g.: $rowhash)
    */
   getQuery: (params: GetQueryArgs) => string;
+
+  returnType?: PG_COLUMN_UDT_DATA_TYPE;
 };
 
 const MAX_COL_NUM = 1600;
@@ -187,8 +258,10 @@ let PostGIS_Funcs: FunctionSpec[] = [
       
       if(!isPlainObject(arg2)) mErr();
       const col = allColumns.find(c => c.name === args[0]);
+      if(!col) throw new Error("Col not found: " + args[0])
 
-      const { lat, lng, srid = 4326, 
+      const { 
+        lat, lng, srid = 4326, 
         geojson, text, use_spheroid, 
         distance, spheroid = 'SPHEROID["WGS 84",6378137,298.257223563]',
         debug
@@ -528,7 +601,7 @@ export const FUNCTIONS: FunctionSpec[] = [
         second: "minute" 
       };
 
-      let res = `(date_trunc(${asValue(prevInt[unit] || "hour")}, ${col}) + date_part(${asValue(unit, "::text")}, ${col})::int / ${val} * interval ${asValue(val + " " + unit)})`;
+      let res = `(date_trunc(${asValue(prevInt[unit as "month"] || "hour")}, ${col}) + date_part(${asValue(unit, "::text")}, ${col})::int / ${val} * interval ${asValue(val + " " + unit)})`;
       // console.log(res);
       return res;
     }
@@ -595,7 +668,7 @@ export const FUNCTIONS: FunctionSpec[] = [
   } as FunctionSpec)),
 
   /* Basic 1 arg col funcs */
-  ...["upper", "lower", "length", "reverse", "trim", "initcap", "round", "ceil", "floor", "sign", "age", "md5"].map(funcName => ({
+  ...["upper", "lower", "length", "reverse", "trim", "initcap", "round", "ceil", "floor", "sign", "md5"].map(funcName => ({
     name: "$" + funcName,
     type: "function",
     numArgs: 1,
@@ -606,6 +679,27 @@ export const FUNCTIONS: FunctionSpec[] = [
     }
   } as FunctionSpec)),
 
+  /* Interval funcs */
+  ...["age", "difference"].map(funcName => ({
+    name: "$" + funcName,
+    type: "function",
+    numArgs: 1,
+    singleColArg: true,
+    getFields: (args: any[]) => args,
+    getQuery: ({ allowedFields, args, tableAlias }) => {
+      const validCols = args.filter(a => typeof a === "string").length
+      if(funcName === "difference" && validCols !== 2) throw new Error("Must have two column names")
+      if(![1,2].includes(validCols)) throw new Error("Must have one or two column names")
+      const [leftField, rightField] = args;
+      const leftQ = asNameAlias(leftField, tableAlias);
+      const rightQ = rightField? ("," + asNameAlias(rightField, tableAlias)) : "";
+      if(funcName === "age"){
+        return `${funcName}(${leftQ}, ${rightQ})`;
+      } else {
+        return `${leftQ} - ${rightQ}`;
+      }
+    }
+  } as FunctionSpec)),
 
   /* pgcrypto funcs */
   ...["crypt"].map(funcName => ({
@@ -643,8 +737,9 @@ export const FUNCTIONS: FunctionSpec[] = [
     name: "$" + funcName,
     type: "function",
     numArgs: 1,
+    minCols: 0,
     singleColArg: false,
-    getFields: (args: any[], allowedFields) => allowedFields.filter(fName => args?.[0]?.includes(`{${fName}}`)),
+    getFields: (args: any[]) => [] as string[], // Fields not validated because we'll use the allowed ones anyway
     getQuery: ({ allowedFields, args, tableAlias }) => {
       let value = asValue(args[0]);
       if(typeof value !== "string") throw "expecting string argument";
@@ -761,7 +856,7 @@ export const FUNCTIONS: FunctionSpec[] = [
         let _cols = validCols.filter(c => 
           /** Exclude numeric columns when the search tern contains a character */
           !hasChars ||  
-          postgresToTsType(c.colInfo.udt_name) !== "number"
+          postgresToTsType(c.colInfo!.udt_name) !== "number"
         );
 
         /** This will break GROUP BY (non-integer constant in GROUP BY) */
@@ -947,28 +1042,16 @@ export class SelectItemBuilder {
     this.select.push(item);
   }
 
-  private addFunctionByName = (funcName: string, args: any[], alias: string) => {
-    const funcDef = this.functions.find(f => f.name === funcName);
-    if(!funcDef) {
-      const sf = this.functions.filter(f => f.name.toLowerCase().slice(1).startsWith(funcName.toLowerCase())).sort((a, b) => (a.name.length - b.name.length));
-      const hint = (sf.length? `. \n Maybe you meant: \n | ${sf.map(s => s.name + " " + (s.description || "")).join("    \n | ")}  ?` : "");
-      throw "\n Function " + funcName + " does not exist or is not allowed " + hint;
-    }
-    this.addFunction(funcDef, args, alias);
-  }
+  private addFunction = (func: FunctionSpec | string, args: any[], alias: string) => {
+    const funcDef = parseFunction({
+      func, args, functions: this.functions,
+      allowedFields: this.allowedFieldsIncludingComputed,
+    });
 
-  private addFunction = (funcDef: FunctionSpec, args: any[], alias: string) => {
-    if(funcDef.numArgs) {
-      const fields = funcDef.getFields(args, this.allowedFields);//  && (! || !funcDef.getFields(args) !== "*" !funcDef.getFields(args).filter(f => f).length
-      if(fields !== "*" && Array.isArray(fields) && !fields.length ){
-        console.log(fields)
-        throw `\n Function "${funcDef.name}" is missing a field name argument`;
-      }
-    }
     this.addItem({
       type: funcDef.type,
       alias,
-      getFields: () => funcDef.getFields(args, this.allowedFields),
+      getFields: () => funcDef.getFields(args),
       getQuery: (tableAlias?: string) => funcDef.getQuery({ allColumns: this.columns, allowedFields: this.allowedFields, args, tableAlias, 
         ctidField: undefined,
 
@@ -1046,7 +1129,7 @@ export class SelectItemBuilder {
           
       } else {
         await Promise.all(selectKeys.map(async key => {
-          const val = userSelect[key],
+          const val: any = userSelect[key as keyof typeof userSelect],
             throwErr = (extraErr: string = "") => {
               console.trace(extraErr)
               throw "Unexpected select -> " + JSON.stringify({ [key]: val }) + "\n" + extraErr;
@@ -1084,14 +1167,13 @@ export class SelectItemBuilder {
                 }
                 funcName = val;
                 args = [key];
+
+              /** Function full notation { $funcName: ["colName", ...args] } */
               } else {
-                const callKeys = Object.keys(val);
-                if(callKeys.length !== 1 || !Array.isArray(val[callKeys[0]])) throw "\nIssue with select. \nUnexpected function definition. \nExpecting { field_name: func_name } OR { result_key: { func_name: [arg1, arg2 ...] } } \nBut got -> " + JSON.stringify({ [key]: val });
-                funcName = callKeys[0];
-                args = val[funcName];
+                ({ funcName, args } = parseFunctionObject(val));
               }
               
-              this.addFunctionByName(funcName, args, key);
+              this.addFunction(funcName, args, key);
   
             /* Join */
             } else {
@@ -1114,10 +1196,10 @@ export class SelectItemBuilder {
 export async function getNewQuery(
   _this: TableHandler,
   filter: Filter, 
-  selectParams: SelectParams & { alias?: string }, 
+  selectParams: (SelectParams & { alias?: string })  = {}, 
   param3_unused = null, 
-  tableRules: TableRule, 
-  localParams: LocalParams,
+  tableRules: TableRule | undefined, 
+  localParams: LocalParams | undefined,
   columns: ColumnInfo[],
 ): Promise<NewQuery> {
 
@@ -1145,7 +1227,6 @@ export async function getNewQuery(
 
     // const all_colnames = _this.column_names.slice(0).concat(COMPUTED_FIELDS.map(c => c.name));
 
-  selectParams = selectParams || {};
   const { select: userSelect = "*" } = selectParams,
     // allCols = _this.column_names.slice(0),
     // allFieldsIncludingComputed = allCols.concat(COMPUTED_FIELDS.map(c => c.name)),
@@ -1160,10 +1241,10 @@ export async function getNewQuery(
     // console.log({ key, val })
     let j_filter: Filter = {},
         j_selectParams: SelectParams = {},
-        j_path: string[],
-        j_alias: string,
-        j_tableRules: TableRule,
-        j_table: string,
+        j_path: string[] | undefined,
+        j_alias: string | undefined,
+        j_tableRules: TableRule | undefined,
+        j_table: string | undefined,
         j_isLeftJoin: boolean = true;
 
     if(val === "*"){
@@ -1199,7 +1280,7 @@ export async function getNewQuery(
         j_table = key;
       }
     }
-
+    if(!j_table) throw "j_table missing"
     const _thisJoinedTable: any = _this.dboBuilder.dbo[j_table];
     if(!_thisJoinedTable) {
       throw `Joined table ${JSON.stringify(j_table)} is disallowed or inexistent \nOr you've forgot to put the function arguments into an array`;
@@ -1208,7 +1289,7 @@ export async function getNewQuery(
     let isLocal = true;
     if(localParams && (localParams.socket || localParams.httpReq)){
       isLocal = false;
-      j_tableRules = await _this.dboBuilder.publishParser.getValidatedRequestRuleWusr({ tableName: j_table, command: "find", localParams });
+      j_tableRules = await _this.dboBuilder.publishParser?.getValidatedRequestRuleWusr({ tableName: j_table, command: "find", localParams });
     }
     
     if(isLocal || j_tableRules){
@@ -1262,7 +1343,7 @@ export async function getNewQuery(
     where,
     // having: cond.having,
     limit: _this.prepareLimitQuery(selectParams.limit, p),
-    orderBy: [_this.prepareSort(selectParams.orderBy, allowedFields, selectParams.alias, null, select)],
+    orderBy: [_this.prepareSort(selectParams.orderBy, allowedFields, selectParams.alias, undefined, select)],
     offset: _this.prepareOffsetQuery(selectParams.offset)
   } as NewQuery;
 
@@ -1279,19 +1360,19 @@ export function makeQuery(
   q: NewQuery, 
   depth: number = 0, 
   joinFields: string[] = [],
-  selectParams: SelectParams,
+  selectParams: SelectParams = {},
 ): string {
   const PREF = `prostgles`,
       joins = q.joins || [],
       // aggs = q.aggs || [],
       makePref = (q: NewQuery) => !q.tableAlias? q.table : `${q.tableAlias || ""}_${q.table}`,
-      makePrefANON = (joinAlias, table) => asName(!joinAlias? table : `${joinAlias || ""}_${table}`),
+      makePrefANON = (joinAlias: string | undefined, table: string) => asName(!joinAlias? table : `${joinAlias || ""}_${table}`),
       makePrefAN = (q: NewQuery) => asName(makePref(q));
 
-  const indentLine = (numInd, str, indentStr = "    ") => new Array(numInd).fill(indentStr).join("") + str;
-  const indStr = (numInd, str: string) => str.split("\n").map(s => indentLine(numInd, s)).join("\n");
-  const indjArr = (numInd, strArr: string[], indentStr = "    "): string[] => strArr.map(str => indentLine(numInd, str) );
-  const indJ = (numInd, strArr: string[], separator = " \n ", indentStr = "    ") => indjArr(numInd, strArr, indentStr).join(separator);
+  const indentLine = (numInd: number, str: string, indentStr = "    ") => new Array(numInd).fill(indentStr).join("") + str;
+  const indStr = (numInd: number, str: string) => str.split("\n").map(s => indentLine(numInd, s)).join("\n");
+  const indjArr = (numInd: number, strArr: string[], indentStr = "    "): string[] => strArr.map(str => indentLine(numInd, str) );
+  const indJ = (numInd: number, strArr: string[], separator = " \n ", indentStr = "    ") => indjArr(numInd, strArr, indentStr).join(separator);
   const selectArrComma = (strArr: string[]): string[] => strArr.map((s, i, arr)=> s + (i < arr.length - 1? " , " : " "));
   const prefJCAN = (q: NewQuery, str: string) => asName(`${q.tableAlias || q.table}_${PREF}_${str}`);
 
@@ -1300,7 +1381,7 @@ export function makeQuery(
     const joinInfo = _this.getJoins(q1.table, q2.table, q2.$path, true);
     const paths = joinInfo.paths;
 
-    return flat(paths.map(({ table, on }, i) => {
+    return paths.flatMap(({ table, on }, i) => {
       const getColName = (col: string, q: NewQuery) => {
         if(table === q.table){
           const colFromSelect = q.select.find(s => s.getQuery() === asName(col));
@@ -1347,7 +1428,7 @@ export function makeQuery(
               /* Rename aggs to avoid collision with join cols */
               if(s.type === "aggregation") return asName(`agg_${s.alias}`) + " AS " + asName(s.alias);
               return asName(s.alias);
-            }).concat(q2.joins.map(j => asName(j.table))).join(", ");
+            }).concat(q2.joins?.map(j => asName(j.table)) ?? []).join(", ");
 
           const _iiQ = makeQuery(
             _this, 
@@ -1384,7 +1465,7 @@ export function makeQuery(
           }`
       ];
       return jres;
-    }))
+    });
   }
 
   const getGroupBy = (rootSelectItems: SelectItem[], groupByItems: SelectItem[]): string => {
@@ -1464,7 +1545,7 @@ export function makeQuery(
   
   const rootSelectItems = q.select.filter(s => depth || s.selected)
 
-  let rootGroupBy: string;
+  let rootGroupBy: string | undefined;
   if((selectParams.groupBy || aggs.length || q.joins && q.joins.length) && nonAggs.length){
     // console.log({ aggs, nonAggs, joins: q.joins })
     // rootGroupBy = getGroupBy(rootSelectItems, depth? rootSelectItems : nonAggs) + (aggs?.length? "" : ", ctid")
@@ -1528,7 +1609,7 @@ export function makeQuery(
               ,   `${q.where} `
               ])
           ,   `) ${makePrefAN(q)} `
-          ,   ...flat(joins.map((j, i)=> joinTables(q, j)))
+          ,   ...joins.flatMap((j, i)=> joinTables(q, j))
           ])
       ,   ") t1"
       ])

package/lib/SyncReplication.ts

@@ -82,10 +82,10 @@ export const syncData = async (_this: PubSubManager, sync: SyncParams, clientDat
                 throw `dbo.${table_name}.find or .count are missing or not allowed`;
             }
 
-            const first_rows = await _this.dbo?.[table_name]?.find?.(_filter, { orderBy: (orderByAsc as OrderBy), select: sync_fields, limit, offset }, null, table_rules);
-            const last_rows = first_rows.slice(-1);
+            const first_rows = await _this.dbo?.[table_name]?.find?.(_filter, { orderBy: (orderByAsc as OrderBy), select: sync_fields, limit, offset }, undefined, table_rules);
+            const last_rows = first_rows?.slice(-1);
             // const last_rows = await _this?.dbo[table_name]?.find?.(_filter, { orderBy: (orderByDesc as OrderBy), select: sync_fields, limit: 1, offset: -offset || 0 }, null, table_rules);
-            const count = await _this.dbo?.[table_name]?.count?.(_filter, null, null, table_rules);
+            const count = await _this.dbo?.[table_name]?.count?.(_filter, undefined, undefined, table_rules);
 
             return { s_fr: first_rows?.[0] || null, s_lr: last_rows?.[0] || null, s_count: count }
         },
@@ -146,7 +146,7 @@ export const syncData = async (_this: PubSubManager, sync: SyncParams, clientDat
                         offset: offset || 0, 
                         limit: batch_size 
                     }, 
-                    null, 
+                    undefined, 
                     table_rules
                 );
 
@@ -164,7 +164,7 @@ export const syncData = async (_this: PubSubManager, sync: SyncParams, clientDat
                 return Promise.all(deleted.map(async d => {
                     const id_filter = filterObj(d, id_fields);
                     try {
-                        await (_this.dbo[table_name] as TableHandler).delete(id_filter, undefined, null, table_rules);
+                        await (_this.dbo[table_name] as TableHandler).delete(id_filter, undefined, undefined, table_rules);
                         return 1;
                     } catch (e){
                         console.error(e)
@@ -195,7 +195,7 @@ export const syncData = async (_this: PubSubManager, sync: SyncParams, clientDat
                         select: [synced_field, ...id_fields] , 
                         orderBy: (orderByAsc as OrderBy), 
                     }, 
-                    null, 
+                    undefined, 
                     table_rules
                 );
                 const inserts = data.filter(d => !existingData.find(ed => rowsIdsMatch(ed, d)));
@@ -216,7 +216,7 @@ export const syncData = async (_this: PubSubManager, sync: SyncParams, clientDat
                     if(table_rules.insert && inserts.length){
                         // const qs = await tbl.insert(inserts, { fixIssues: true }, null, table_rules, { returnQuery: true });
                         // console.log("inserts", qs)
-                        await tbl.insert(inserts, { fixIssues: true }, null, table_rules);
+                        await tbl.insert(inserts, { fixIssues: true }, undefined, table_rules);
                         inserted = inserts.length;                       
                     }
                     
@@ -308,7 +308,7 @@ export const syncData = async (_this: PubSubManager, sync: SyncParams, clientDat
                         sync_fields.map(key => {
                             _filter[key] = c_lr[key];
                         });
-                        server_row = await _this?.dbo?.[table_name]?.find?.(_filter, { select: sync_fields, limit: 1 }, null, table_rules);
+                        server_row = await _this?.dbo?.[table_name]?.find?.(_filter, { select: sync_fields, limit: 1 }, undefined, table_rules);
                     }
 
                     // if(rowsFullyMatch(c_lr, s_lr)){ //c_count === s_count && 
@@ -337,7 +337,7 @@ export const syncData = async (_this: PubSubManager, sync: SyncParams, clientDat
                     console.error({ syncIssue: "sync.lr[synced_field] is greater than lastRow[synced_field]"})
                 }
                 sync.lr = lastRow;
-                sync.last_synced = +sync.lr[synced_field];
+                sync.last_synced = +sync.lr?.[synced_field];
             }
         },
 
@@ -381,7 +381,7 @@ export const syncData = async (_this: PubSubManager, sync: SyncParams, clientDat
                     });
                     await Promise.all(to_delete.map(d => {
                         deleted++;
-                        return (_this.dbo[table_name] as TableHandler).delete(filterObj(d, id_fields), { }, null, table_rules);
+                        return (_this.dbo[table_name] as TableHandler).delete(filterObj(d, id_fields), { }, undefined, table_rules);
                     }));
                     sData = await getServerData(min_synced, offset);
                 }

package/lib/TableConfig.ts

@@ -1,5 +1,5 @@
 import { AnyObject, asName } from "prostgles-types";
-import { DboBuilder, JoinInfo, LocalParams } from "./DboBuilder";
+import { DboBuilder, getKeys, JoinInfo, LocalParams } from "./DboBuilder";
 import { asSQLIdentifier, ALLOWED_EXTENSION, ALLOWED_CONTENT_TYPE } from "./FileManager";
 import { DB, DbHandler, Prostgles } from "./Prostgles";
 import { asValue } from "./PubSubManager";
@@ -184,9 +184,15 @@ export type TableConfig<LANG_IDS = { en: 1 }> = {
 export default class TableConfigurator {
 
     config?: TableConfig;
-    get dbo(): DbHandler { return this.prostgles.dbo };
-    get db(): DB { return this.prostgles.db };
-    sidKeyName: string;
+    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 
+    };
+    // sidKeyName: string;
     prostgles: Prostgles
 
     constructor(prostgles: Prostgles){
@@ -203,7 +209,7 @@ export default class TableConfigurator {
     }
 
     getColInfo = (params: {col: string, table: string}): ColExtraInfo | undefined => {
-        return this.config[params.table]?.[params.col]?.info;
+        return (this.config as any)[params.table]?.[params.col]?.info;
     }
 
     checkColVal = (params: {col: string, table: string, value: any }): void => {
@@ -218,6 +224,7 @@ export default class TableConfigurator {
 
     getJoinInfo = (sourceTable: string, targetTable: string): JoinInfo | undefined => {
         if(
+            this.config &&
             sourceTable in this.config &&
             this.config[sourceTable] &&
             "columns" in this.config[sourceTable]
@@ -247,9 +254,10 @@ export default class TableConfigurator {
     async init(){
         let queries: string[] = [];
         
+        if(!this.config || !this.prostgles.pgp) throw "config or pgp missing"
         /* Create lookup tables */
         Object.keys(this.config).map(tableName => {
-            const tableConf = this.config[tableName];
+            const tableConf = this.config![tableName];
             const { dropIfExists = false, dropIfExistsCascade = false } = tableConf;
             if(dropIfExistsCascade){
                 queries.push(`DROP TABLE IF EXISTS ${tableName} CASCADE;`);
@@ -266,8 +274,8 @@ export default class TableConfigurator {
                     );`);
 
                     rows.map(row => {
-                        const values = this.prostgles.pgp.helpers.values(row)
-                        queries.push(this.prostgles.pgp.as.format(`INSERT INTO ${tableName}  (${["id", ...keys].map(t => asName(t)).join(", ")})  ` + " VALUES ${values:raw} ;", { values} ))
+                        const values = this.prostgles.pgp!.helpers.values(row)
+                        queries.push(this.prostgles.pgp!.as.format(`INSERT INTO ${tableName}  (${["id", ...keys].map(t => asName(t)).join(", ")})  ` + " VALUES ${values:raw} ;", { values} ))
                     });
                     // console.log("Created lookup table " + tableName)
                 }
@@ -284,7 +292,7 @@ export default class TableConfigurator {
 
         /* Create referenced columns */
         await Promise.all(Object.keys(this.config).map(async tableName => {
-            const tableConf = this.config[tableName];
+            const tableConf = this.config![tableName];
             if("columns" in tableConf){
                 const getColDef = (name: string, colConf: ColumnConfig): string => {
                     const colNameEsc = asName(name);
@@ -318,13 +326,13 @@ export default class TableConfigurator {
                     }
                 }
                 
-                const colDefs = [];
+                const colDefs: string[] = [];
                 Object.keys(tableConf.columns).filter(c => !("joinDef" in tableConf.columns[c])).map(colName => {
                     const colConf = tableConf.columns[colName];
                     
                     if(!this.dbo[tableName]){
                         colDefs.push(getColDef(colName, colConf))
-                    } else if(!colDefs.length && !this.dbo[tableName].columns.find(c => colName === c.name)) {
+                    } else if(!colDefs.length && !this.dbo[tableName].columns?.find(c => colName === c.name)) {
 
                         if("references" in colConf && colConf.references){
 
@@ -354,13 +362,13 @@ export default class TableConfigurator {
                 } 
             }
             if("constraints" in tableConf && tableConf.constraints){
-                Object.keys(tableConf.constraints).map(constraintName => {
-                    queries.push(`ALTER TABLE ${asName(tableName)} ADD CONSTRAINT ${asName(constraintName)} ${tableConf.constraints[constraintName]} ;`);
+                getKeys(tableConf.constraints).map(constraintName => {
+                    queries.push(`ALTER TABLE ${asName(tableName)} ADD CONSTRAINT ${asName(constraintName)} ${tableConf.constraints![constraintName]} ;`);
                 });
             }
             if("indexes" in tableConf && tableConf.indexes){
-                Object.keys(tableConf.indexes).map(indexName => {
-                    const { concurrently, unique, using, definition, replace } = tableConf.indexes[indexName];
+                getKeys(tableConf.indexes).map(indexName => {
+                    const { concurrently, unique, using, definition, replace } = tableConf.indexes![indexName];
                     if(replace || typeof replace !== "boolean" && tableConf.replaceUniqueIndexes){
                         queries.push(`DROP INDEX IF EXISTS ${asName(indexName)}  ;`);
                     }

package/lib/shortestPath.ts

@@ -1,4 +1,6 @@
-const shortestDistanceNode = (distances, visited) => {
+import { AnyObject } from "prostgles-types";
+
+const shortestDistanceNode = (distances: AnyObject, visited: AnyObject) => {
 	let shortest = null;
 
 	for (let node in distances) {
@@ -16,18 +18,18 @@ export type Graph = {
 
 export const findShortestPath = (graph: Graph, startNode: string, endNode: string): { distance: number, path: string[] } => {
 	// establish object for recording distances from the start node
-	let distances = {};
+	let distances: AnyObject = {};
 	distances[endNode] = "Infinity";
 	distances = Object.assign(distances, graph[startNode]);
 
 	// track paths
-	let parents = { endNode: null };
+	let parents: AnyObject = { endNode: null };
 	for (let child in graph[startNode]) {
 		parents[child] = startNode;
 	}
 
 	// track nodes that have already been visited
-	let visited = [];
+	let visited: AnyObject = [];
 
 	// find the nearest node
 	let node = shortestDistanceNode(distances, visited);

package/lib/utils.ts

@@ -1 +1,7 @@
-export { get } from "prostgles-types";
+export { get } from "prostgles-types";
+
+
+export function isObject(obj: any): obj is Record<string, any> {
+    return Boolean(obj && typeof obj === "object" && !Array.isArray(obj) );
+}
+export const isDefined = <T>(v: T | undefined | void): v is T => v !== undefined && v !== null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "2.0.144",
+  "version": "2.0.147",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,20 +24,19 @@
   },
   "homepage": "https://github.com/prostgles/prostgles-server-js#readme",
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.86.0",
-    "aws-sdk": "^2.1134.0",
+    "@aws-sdk/client-s3": "^3.95.0",
+    "aws-sdk": "^2.1141.0",
     "bluebird": "^3.7.2",
     "file-type": "^16.5.3",
-    "i": "^0.3.7",
-    "npm": "^8.1.4",
-    "pg-promise": "^10.9.5",
-    "prostgles-types": "^1.5.123",
-    "sharp": "^0.30.4"
+    "pg-promise": "^10.11.1",
+    "prostgles-types": "^1.5.124",
+    "sharp": "^0.30.5"
   },
   "devDependencies": {
     "@aws-sdk/types": "^3.34.0",
     "@types/bluebird": "^3.5.36",
     "@types/node": "^14.14.35",
+    "@types/sharp": "^0.30.2",
     "typescript": "^3.9.7"
   }
 }

package/tests/client/PID.txt

@@ -1 +1 @@
-23745
+57757