prostgles-server 2.0.185 → 2.0.188

package/lib/DboBuilder.ts

@@ -49,8 +49,8 @@ export type TX = {
     (t: TxCB): Promise<(any | void)>;
 }
 
-type TableHandlers = {
-    [key: string]: Partial<TableHandler>;
+export type TableHandlers = {
+    [key: string]: Partial<TableHandler> | TableHandler;
 }
 
 export type DBHandlerServer = 
@@ -76,12 +76,14 @@ export const getUpdateFilter = (args: { filter?: AnyObject; forcedFilter?: AnyOb
 import { get } from "./utils";
 import { getNewQuery, makeQuery, COMPUTED_FIELDS, SelectItem, FieldSpec, asNameAlias, SelectItemBuilder, FUNCTIONS, parseFunction, parseFunctionObject } from "./QueryBuilder";
 import { 
-    Join, Prostgles, DB
+    Join, Prostgles, DB, isSuperUser
 } from "./Prostgles";
 import { 
  TableRule, UpdateRule, SyncRule, PublishParser, ValidateRow, ValidateUpdateRow, PublishAllOrNothing, PublishParams, DeleteRule 
 } from "./PublishParser";
 import { PubSubManager, asValue, BasicCallback, pickKeys, omitKeys } from "./PubSubManager";
+import { insertDataParse } from "./DboBuilder/insertDataParse";
+import { insert } from "./DboBuilder/insert";
 
 import { parseFilterItem } from "./Filtering";
 
@@ -242,9 +244,10 @@ export type JoinInfo = {
 
         /**
          * Source and target JOIN ON columns
-         * e.g.:    [source_table_column: string, table_column: string][]
+         * Each inner array group will be combined with AND and outer arrays with OR to allow multiple references to the same table  
+         * e.g.:    [[source_table_column: string, table_column: string]]
          */
-        on: [string, string][],
+        on: [string, string][][],
 
         /**
          * Source table name
@@ -335,7 +338,7 @@ export type ValidatedTableRules = CommonTableRules & {
 }
 
 /* DEBUG CLIENT ERRORS HERE */
-function makeErr(err: any, localParams?: LocalParams, view?: ViewHandler, allowedKeys?: string[]){
+export function makeErr(err: any, localParams?: LocalParams, view?: ViewHandler, allowedKeys?: string[]){
     // console.trace(err)
     if(process.env.TEST_TYPE || process.env.PRGL_DEBUG) {
         console.trace(err)
@@ -367,10 +370,10 @@ export type EXISTS_KEY = typeof EXISTS_KEYS[number];
 
 const FILTER_FUNCS = FUNCTIONS.filter(f => f.canBeUsedForFilter);
 
-function parseError(e: any){
+export function parseError(e: any){
     
     // console.trace("INTERNAL ERROR: ", e);
-    let res = (!Object.keys(e || {}).length? e : (e && e.toString)? e.toString() : e);
+    let res = e instanceof Error? e.message : (!Object.keys(e || {}).length? e : (e && e.toString)? e.toString() : e);
     if(isPlainObject(e)) res = JSON.stringify(e, null, 2)
     return res;
 }
@@ -627,6 +630,10 @@ export class ViewHandler {
         // while (!result && searchedTables.length <= this.joins.length * 2){
 
         // }
+
+        const getJoinCondition = (on: Record<string, string>[], leftTable: string, rightTable: string) => {
+            return on.map(cond => Object.keys(cond).map(lKey => `${leftTable}.${lKey} = ${rightTable}.${cond[lKey]}`).join("\nAND ")).join(" OR ") 
+        }
  
         let toOne = true,
             query = this.joins.map(({ tables, on, type }, i) => {
@@ -635,7 +642,7 @@ export class ViewHandler {
                 }
                 const tl = `tl${startAlias + i}`,
                     tr = `tr${startAlias + i}`;
-                return `FROM ${tables[0]} ${tl} ${isInner? "INNER" : "LEFT"} JOIN ${tables[1]} ${tr} ON ${Object.keys(on).map(lKey => `${tl}.${lKey} = ${tr}.${on[lKey]}`).join("\nAND ")}`;
+                return `FROM ${tables[0]} ${tl} ${isInner? "INNER" : "LEFT"} JOIN ${tables[1]} ${tr} ON ${getJoinCondition(on, tl, tr)}`;
             }).join("\n");
         return { query, toOne: false }
     }
@@ -675,21 +682,26 @@ export class ViewHandler {
             const jo = this.joins.find(j => j.tables.includes(t1) && j.tables.includes(t2));
             if(!jo) throw `Joining ${t1} <-> ${t2} dissallowed or missing`;;
 
-            let on: [string, string][] = [];
-
-            Object.keys(jo.on).map(leftKey => {
-                const rightKey = jo.on[leftKey];
-
-                /* Left table is joining on keys */
-                if(jo.tables[0] === t1){
-                    on.push([leftKey, rightKey])
-
-                /* Left table is joining on values */
-                } else {
-                    on.push([rightKey, leftKey])
+            let on: [string, string][][] = [];
 
-                }
-            });
+            jo.on.map(cond => {
+                let condArr: [string, string][] = [];
+                Object.keys(cond).map(leftKey => {
+                    const rightKey = cond[leftKey];
+    
+                    /* Left table is joining on keys */
+                    if(jo.tables[0] === t1){
+                        condArr.push([leftKey, rightKey])
+    
+                    /* Left table is joining on values */
+                    } else {
+                        condArr.push([rightKey, leftKey])
+    
+                    }
+                });
+                on.push(condArr);
+            })
+            
 
             return {
                 source,
@@ -1065,7 +1077,8 @@ export class ViewHandler {
         } catch(e){
             // console.trace(e)
             if(localParams && localParams.testRule) throw e;
-            throw { err: parseError(e), msg: `Issue with dbo.${this.name}.find(${JSON.stringify(filter || {}, null, 2)}, ${JSON.stringify(selectParams || {}, null, 2)})` };
+            // ${JSON.stringify(filter || {}, null, 2)}, ${JSON.stringify(selectParams || {}, null, 2)}
+            throw { err: parseError(e), msg: `Issue with dbo.${this.name}.find()`, args: { filter, selectParams} };
         }                             
     }
 
@@ -1295,8 +1308,9 @@ export class ViewHandler {
                 let tableAlias = asName(ji < paths.length - 1? `jd${ji}` : table);
                 let prevTableAlias = asName(ji? `jd${ji - 1}` : thisTable);
 
-                let cond = `${jp.on.map(([c1, c2]) => 
-                    `${prevTableAlias}.${asName(c1)} = ${tableAlias}.${asName(c2)}`).join("\n AND ")
+                let cond = `${jp.on.map(c => {
+                        return c.map(([c1, c2]) => `${prevTableAlias}.${asName(c1)} = ${tableAlias}.${asName(c2)}` ).join(" AND ")
+                    }).join("\n OR ")
                 }`;
     
                 let j = `SELECT 1 \n` +
@@ -1907,7 +1921,7 @@ export class ViewHandler {
     }
 }
 
-function isPojoObject<T>(obj: T): obj is Record<string, any> {
+export function isPojoObject<T>(obj: T): obj is Record<string, any> {
     if(obj && (typeof obj !== "object" || Array.isArray(obj) || obj instanceof Date)){
         return false;
     }
@@ -2305,380 +2319,10 @@ export class TableHandler extends ViewHandler {
         return { data, allowedCols: this.columns.filter(c => dataKeys.includes(c.name)).map(c => c.name) }
     }
     
-
-    private async insertDataParse(data: (AnyObject | AnyObject[]), param2?: InsertParams, param3_unused?: undefined, tableRules?: TableRule, _localParams?: LocalParams): Promise<{
-        data?: AnyObject | AnyObject[];
-        insertResult?: AnyObject | AnyObject[];
-    }>{
-        const localParams = _localParams || {};
-        let dbTX = localParams?.dbTX || this.dbTX;
-
-        const isMultiInsert = Array.isArray(data);
-        const getExtraKeys = (d: AnyObject)=> Object.keys(d).filter(k => !this.columns.find(c => c.name === k));
-
-        /* Nested insert is not allowed for the file table */
-        const isNestedInsert = this.is_media? false : (Array.isArray(data)? data : [data]).some(d => getExtraKeys(d).length);
-
-        /**
-         * Make sure nested insert uses a transaction
-         */
-        if(isNestedInsert && !dbTX){
-            return {
-                insertResult: await this.dboBuilder.getTX((dbTX) => 
-                    (dbTX[this.name] as TableHandler).insert(
-                        data, 
-                        param2, 
-                        param3_unused, 
-                        tableRules, 
-                        {dbTX, ...localParams}
-                    )
-                )
-            }
-        }
-        // if(!dbTX && this.t) dbTX = this.d;
-        
-        const preValidate = tableRules?.insert?.preValidate,
-            validate = tableRules?.insert?.validate;
-
-        let _data = await Promise.all((Array.isArray(data)? data : [data]).map(async row => {
-            if(preValidate){
-                row = await preValidate(row);
-            }
-
-            const dataKeys = Object.keys(row);
-            const extraKeys = getExtraKeys(row);
-
-            /* Upload file then continue insert */
-            if(this.is_media){
-                if(!this.dboBuilder.prostgles?.fileManager) throw "fileManager not set up";
-                const { data, name } = row;
-                
-                if(dataKeys.length !== 2) throw "Expecting only two properties: { name: string; data: File }";
-
-                // if(!Buffer.isBuffer(data)) throw "data is not of type Buffer"
-                if(!data) throw "data not provided"
-                if(typeof name !== "string"){
-                    throw "name is not of type string"
-                }
-
-                const media_id = (await this.db.oneOrNone("SELECT gen_random_uuid() as name")).name;
-                const type = await this.dboBuilder.prostgles.fileManager.getMIME(data, name)
-                const media_name = `${media_id}.${type.ext}`;
-                let media: Media = {
-                    id: media_id,
-                    name: media_name,
-                    original_name: name,
-                    extension: type.ext,
-                    content_type: type.mime
-                }
-
-                if(validate){
-                    media = await validate(media);
-                }
-
-                const _media: Media = await this.dboBuilder.prostgles.fileManager.uploadAsMedia({
-                    item: {
-                        data,
-                        name: media.name ?? "????",
-                        content_type: media.content_type as any
-                    },
-                    // imageCompression: {
-                    //     inside: {
-                    //         width: 1100,
-                    //         height: 630
-                    //     }
-                    // }
-                });
-
-                return {
-                    ...media,
-                    ..._media,
-                };
-
-            /* Potentially a nested join */ 
-            } else if(extraKeys.length){
-
-                /* Ensure we're using the same transaction */
-                const _this = this.t? this : dbTX![this.name] as TableHandler;
-
-                let rootData = Array.isArray(data)? data.map(d => omitKeys(d, extraKeys)) :  omitKeys(data, extraKeys);
-
-                let insertedChildren: AnyObject[];
-                let targetTableRules: TableRule;
-
-                const fullRootResult = await _this.insert(rootData, { returning: "*" }, undefined, tableRules, localParams);
-                let returnData: AnyObject | undefined;
-                const returning = param2?.returning;
-                if(returning){
-                    returnData = {}
-                    const returningItems = await this.prepareReturning(returning, this.parseFieldFilter(tableRules?.insert?.returningFields));
-                    returningItems.filter(s => s.selected).map(rs => {
-                        returnData![rs.alias] = fullRootResult[rs.alias];
-                    })
-                }
-                
-                await Promise.all(extraKeys.map(async targetTable => {
-                    const childDataItems = Array.isArray(row[targetTable])? row[targetTable] : [row[targetTable]];
-
-                    /* Must be allowed to insert into media table */
-                    const canInsert = async (tbl: string) => {
-                        const childRules = await this.dboBuilder.publishParser?.getValidatedRequestRuleWusr({ tableName: tbl, command: "insert", localParams });
-                        if(!childRules || !childRules.insert) throw "Dissallowed nested insert into table " + childRules;
-                        return childRules;
-                    }
-
-                    // console.log(JSON.stringify(this.dboBuilder.joinPaths, null, 2))
-                    const jp = this.dboBuilder.joinPaths.find(jp => jp.t1 === this.name && jp.t2 === targetTable);
-                    if(!jp) throw `Could not find a valid table for the nested data { ${targetTable} } `;
-
-                    const thisInfo = await this.getInfo();
-                    const childInsert = async (cdata: AnyObject | AnyObject[], tableName: string) => {
-                        // console.log("childInsert", {data, tableName})
-                        if(!cdata || !dbTX?.[tableName] || !("insert" in dbTX[tableName])) throw "childInsertErr: Child table handler missing for: " + tableName;
-
-                        const tableRules = await canInsert(tableName);
-
-                        if(thisInfo.has_media === "one" && thisInfo.media_table_name === tableName && Array.isArray(cdata) && cdata.length > 1){
-                            throw "Constraint check fail: Cannot insert more than one record into " + JSON.stringify(tableName);
-                        }
-                        return Promise.all(
-                            (Array.isArray(cdata)? cdata : [cdata])
-                                .map(m => (dbTX![tableName] as TableHandler)
-                                .insert(m, { returning: "*" }, undefined, tableRules, localParams)
-                                .catch(e => {
-                                    console.trace({ childInsertErr: e })
-                                    return Promise.reject({ childInsertErr: e });
-                                })
-                            )
-                        );
-                    }
-                    
-                    const { path } = jp;
-                    const [tbl1, tbl2, tbl3] = path; 
-                    targetTableRules = await canInsert(targetTable);   //  tbl3
-
-                    const cols2 = this.dboBuilder.dbo[tbl2].columns || [];
-                    if(!this.dboBuilder.dbo[tbl2]) throw "Invalid/disallowed table: " + tbl2;
-                    const colsRefT1 = cols2?.filter(c => c.references?.cols.length === 1 && c.references?.ftable === tbl1);
-
-
-                    if(!path.length) {
-                        throw "Nested inserts join path not found for " + [this.name, targetTable];
-                    } else if(path.length === 2){
-                        if(targetTable !== tbl2) throw "Did not expect this";
-
-                        if(!colsRefT1.length) throw `Target table ${tbl2} does not reference any columns from the root table ${this.name}. Cannot do nested insert`;
-
-                        // console.log(childDataItems, JSON.stringify(colsRefT1, null, 2))
-                        insertedChildren = await childInsert(
-                            childDataItems.map((d: AnyObject) => {
-                                let result = {...d};
-                                colsRefT1.map(col => {
-                                    result[col.references!.cols[0]] = fullRootResult[col.references!.fcols[0]]
-                                })
-                                return result;
-                            }), 
-                            targetTable
-                        );
-                        // console.log({ insertedChildren })
-
-                    } else if(path.length === 3){ 
-                        if(targetTable !== tbl3) throw "Did not expect this";
-                        const colsRefT3 = cols2?.filter(c => c.references?.cols.length === 1 && c.references?.ftable === tbl3);
-                        if(!colsRefT1.length || !colsRefT3.length) throw "Incorrectly referenced or missing columns for nested insert";
-
-                        if(targetTable !== this.dboBuilder.prostgles.fileManager?.tableName){
-                            throw "Only media allowed to have nested inserts more than 2 tables apart"
-                        }
-
-                        /* We expect tbl2 to have only 2 columns (media_id and foreign_id) */
-                        if(!cols2 || cols2.find(c => !["media_id", "foreign_id"].includes(c.name))){
-                            throw "Second joining table not of expected format";
-                        }
-
-                        insertedChildren = await childInsert(childDataItems, targetTable);
-                        
-                        /* Insert in key_lookup table */
-                        await Promise.all(insertedChildren.map(async t3Child => {
-                            let tbl2Row: AnyObject = {};
-
-                            colsRefT3.map(col => {
-                                tbl2Row[col.name] = t3Child[col.references!.fcols[0]];
-                            })
-                            colsRefT1.map(col => {
-                                tbl2Row[col.name] = fullRootResult[col.references!.fcols[0]];
-                            })
-                            // console.log({ rootResult, tbl2Row, t3Child, colsRefT3, colsRefT1, t: this.t?.ctx?.start });
-                            
-                            await childInsert(tbl2Row, tbl2);//.then(() => {});
-                        }));
-
-                    } else {
-                        console.error(JSON.stringify({ path, thisTable: this.name, targetTable }, null, 2));
-                        throw "Unexpected path for Nested inserts";
-                    }
-
-                    /* Return also the nested inserted data */
-                    if(targetTableRules && insertedChildren?.length && returning){
-                        const targetTableHandler = dbTX![targetTable] as TableHandler;
-                        const targetReturning = await targetTableHandler.prepareReturning("*", targetTableHandler.parseFieldFilter(targetTableRules?.insert?.returningFields));
-                        let clientTargetInserts = insertedChildren.map(d => {
-                            let _d = { ...d };
-                            let res: AnyObject = {};
-                            targetReturning.map(r => {
-                                res[r.alias] = _d[r.alias]
-                            });
-                            return res;
-                        });
-    
-                        returnData![targetTable] = clientTargetInserts.length === 1? clientTargetInserts[0] : clientTargetInserts;
-                    }
-                }));
-
-                return returnData
-            }
-
-            return row;
-        }));
-
-        let result = isMultiInsert? _data : _data[0];
-        // if(validate && !isNestedInsert){
-        //     result = isMultiInsert? await Promise.all(_data.map(async d => await validate({ ...d }))) : await validate({ ..._data[0] });
-        // }
-        let res = isNestedInsert? 
-            { insertResult: result } : 
-            { data: result };
-            
-        return res;
-    }
-
+    insertDataParse = insertDataParse;
     async insert(rowOrRows: (AnyObject | AnyObject[]), param2?: InsertParams, param3_unused?: undefined, tableRules?: TableRule, _localParams?: LocalParams): Promise<any | any[] | boolean>{
-        const localParams = _localParams || {};
-        const {dbTX} = localParams
-        try {
-
-            const { returning, onConflictDoNothing, fixIssues = false } = param2 || {};
-            const { testRule = false, returnQuery = false } = localParams || {};
-
-            let returningFields: FieldFilter | undefined,
-                forcedData: AnyObject | undefined,
-                fields: FieldFilter | undefined;
-    
-            if(tableRules){
-                if(!tableRules.insert) throw "insert rules missing for " + this.name;
-                returningFields = tableRules.insert.returningFields;
-                forcedData = tableRules.insert.forcedData;
-                fields = tableRules.insert.fields;
-    
-                /* If no returning fields specified then take select fields as returning */
-                if(!returningFields) returningFields = get(tableRules, "select.fields") || get(tableRules, "insert.fields");
-
-                if(!fields) throw ` invalid insert rule for ${this.name} -> fields missing `;
-
-                /* Safely test publish rules */
-                if(testRule){
-                    // if(this.is_media && tableRules.insert.preValidate) throw "Media table cannot have a preValidate. It already is used internally by prostgles for file upload";
-                    await this.validateViewRules({ fields, returningFields, forcedFilter: forcedData, rule: "insert"});
-                    if(forcedData) {
-                        const keys = Object.keys(forcedData);
-                        if(keys.length){
-                            try {
-                                const colset = new pgp.helpers.ColumnSet(this.columns.filter(c => keys.includes(c.name)).map(c => ({ name: c.name, cast: c.udt_name === "uuid"? c.udt_name : undefined }))),
-                                    values = pgp.helpers.values(forcedData, colset),
-                                    colNames = this.prepareSelect(keys, this.column_names);
-                                await this.db.any("EXPLAIN INSERT INTO " + this.escapedName + " (${colNames:raw}) SELECT * FROM ( VALUES ${values:raw} ) t WHERE FALSE;", { colNames, values })
-                            } catch(e){
-                                throw "\nissue with forcedData: \nVALUE: " + JSON.stringify(forcedData, null, 2) + "\nERROR: " + e;
-                            }
-                        }
-                    }
-
-                    return true;
-                }
-            }
-
-            let conflict_query = "";
-            if(typeof onConflictDoNothing === "boolean" && onConflictDoNothing){
-                conflict_query = " ON CONFLICT DO NOTHING ";
-            }
-
-            if(param2){
-                const good_params = ["returning", "multi", "onConflictDoNothing", "fixIssues"];
-                const bad_params = Object.keys(param2).filter(k => !good_params.includes(k));
-                if(bad_params && bad_params.length) throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
-            }
-            
-            if(!rowOrRows) rowOrRows = {}; //throw "Provide data in param1";
-            let returningSelect = this.makeReturnQuery(await this.prepareReturning(returning, this.parseFieldFilter(returningFields)));
-            const makeQuery = async (_row: AnyObject | undefined, isOne = false) => {
-                let row = { ..._row };
-                
-                if(!isPojoObject(row)) {
-                    console.trace(row)
-                    throw "\ninvalid insert data provided -> " + JSON.stringify(row);
-                }
-
-                const { data, allowedCols } = this.validateNewData({ row, forcedData, allowedFields: fields, tableRules, fixIssues });
-                let _data = { ...data };
-
-                let insertQ = "";
-                if(!Object.keys(_data).length) insertQ = `INSERT INTO ${asName(this.name)} DEFAULT VALUES `;
-                else insertQ = await this.colSet.getInsertQuery(_data, allowedCols, tableRules?.insert?.validate) // pgp.helpers.insert(_data, columnSet); 
-                return insertQ + conflict_query + returningSelect;
-            };
-    
-            let query = "";
-            let queryType: keyof pgPromise.ITask<{}> = "none";
-            
-            /**
-             * If media it will: upload file and continue insert
-             * If nested insert it will: make separate inserts and not continue main insert
-             */
-            const insRes = await this.insertDataParse(rowOrRows, param2, param3_unused, tableRules, localParams);
-            const { data, insertResult } = insRes;
-            if("insertResult" in insRes){
-                return insertResult;
-            }
-            
-            if(Array.isArray(data)){
-                // if(returning) throw "Sorry but [returning] is dissalowed for multi insert";
-                let queries = await Promise.all(data.map(async p => {
-                    const q = await makeQuery(p);
-                    return q;
-                }));
-                
-                query = pgp.helpers.concat(queries);
-                if(returning) queryType = "many";
-            } else {
-                query = await makeQuery(data, true);
-                if(returning) queryType = "one";
-            }
-            
-            if(returnQuery)  return query;
-            let result;
-
-            if(this.dboBuilder.prostgles.opts.DEBUG_MODE){
-                console.log(this.t?.ctx?.start, "insert in " + this.name, data);
-            }
-
-            const tx = dbTX?.[this.name]?.t || this.t;
-
-            const allowedFieldKeys = this.parseFieldFilter(fields);
-            if(tx) {
-                result = (tx as any)[queryType](query).catch((err: any) => makeErr(err, localParams, this, allowedFieldKeys));
-            } else {
-                result = this.db.tx(t => (t as any)[queryType](query)).catch(err => makeErr(err, localParams, this, allowedFieldKeys));
-            }
-            
-            return result;
-        } catch(e){
-            if(localParams && localParams.testRule) throw e;
-            throw { err: parseError(e), msg: `Issue with dbo.${this.name}.insert(
-                ${JSON.stringify(rowOrRows || {}, null, 2)}, 
-                ${JSON.stringify(param2 || {}, null, 2)}
-            )` };
-        } 
-    };
+        return insert.bind(this)(rowOrRows, param2, param3_unused, tableRules, _localParams)
+    }
 
     prepareReturning = async (returning: Select | undefined, allowedFields: string[]): Promise<SelectItem[]> => {
         let result: SelectItem[] = [];
@@ -2928,9 +2572,9 @@ export class DboBuilder {
         if(!this._pubSubManager){
             let onSchemaChange;
             
-            if(this.prostgles.opts.watchSchema && this.prostgles.opts.watchSchemaType === "events"){
+            if(this.prostgles.opts.watchSchema && this.prostgles.opts.watchSchemaType === "DDL_trigger"){
                 if(!this.prostgles.isSuperUser){
-                    console.warn(`watchSchemaType "events" cannot be used because db user is not a superuser. Will fallback to watchSchemaType "queries" `)
+                    console.warn(`watchSchemaType "events" cannot be used because db user is not a superuser. Will fallback to watchSchemaType "prostgles_queries" `)
                 } else {
                     onSchemaChange = (event: { command: string; query: string }) => { 
                         this.prostgles.onSchemaChange(event)
@@ -2949,7 +2593,10 @@ export class DboBuilder {
                 console.warn(`subscribe and sync cannot be used because db user is not a superuser `)
             }
         }
-        if(!this._pubSubManager) throw "Could not create this._pubSubManager";
+        if(!this._pubSubManager) {
+            console.trace("Could not create this._pubSubManager")
+            throw "Could not create this._pubSubManager";
+        }
         return this._pubSubManager;
     }
 
@@ -2981,7 +2628,7 @@ export class DboBuilder {
         
         /* If watchSchema then PubSubManager must be created */
         await this.build();
-        if(this.prostgles.opts.watchSchema){
+        if(this.prostgles.opts.watchSchema && (this.prostgles.opts.watchSchemaType === "DDL_trigger" || !this.prostgles.opts.watchSchemaType) && this.prostgles.isSuperUser){
             await this.getPubSubManager()
         }
 
@@ -3008,13 +2655,16 @@ export class DboBuilder {
     async parseJoins(): Promise<JoinPaths> {
         if(this.prostgles.opts.joins){
             let _joins = await this.prostgles.opts.joins;
-            let inferredJoins = await getInferredJoins(this.db, this.prostgles.opts.schema);
-            if(typeof _joins === "string" && _joins === "inferred"){
+            if(!this.tablesOrViews) throw new Error("Could not create join config. this.tablesOrViews missing");
+            let inferredJoins = await getInferredJoins2(this.tablesOrViews);
+            if(_joins === "inferred"){
                 _joins = inferredJoins
             /* If joins are specified then include inferred joins except the explicit tables */
             } else if(Array.isArray(_joins)){
                 const joinTables = _joins.map(j => j.tables).flat();
                 _joins = _joins.concat(inferredJoins.filter(j => !j.tables.find(t => joinTables.includes(t))))
+            } else if(_joins){
+                throw new Error("Unexpected joins init param. Expecting 'inferred' OR joinConfig but got: " + JSON.stringify(_joins))
             }
             let joins = JSON.parse(JSON.stringify(_joins)) as Join[];
             this.joins = joins;
@@ -3221,7 +2871,7 @@ export class DboBuilder {
             if(typeof this.prostgles.opts.transactions === "string") txKey = this.prostgles.opts.transactions;
             this.dboDefinition += ` ${txKey}: (t: TxCB) => Promise<any | void> ;\n`;
 
-            (this.dbo[txKey] as TX) = (cb: TxCB) => this.getTX(cb);
+            (this.dbo[txKey] as unknown as TX) = (cb: TxCB) => this.getTX(cb);
         }
 
         if(!this.dbo.sql){
@@ -3272,15 +2922,16 @@ export class DboBuilder {
 
                     if(
                         watchSchema &&
-                        (!this.prostgles.isSuperUser || watchSchemaType === "queries") && 
-                        (
-                            ["CREATE", "ALTER", "DROP"].includes(command) ||
-
-                            //  Cover this case: `CREATE TABLE mytable AS SELECT` 
-                            query && query.toLowerCase().replace(/\s\s+/g, ' ').includes("create table")
-                        )
+                        (!this.prostgles.isSuperUser || watchSchemaType === "prostgles_queries")
                     ){
-                        this.prostgles.onSchemaChange({ command, query })
+                        if(["CREATE", "ALTER", "DROP"].includes(command)){
+                            this.prostgles.onSchemaChange({ command, query })
+                        } else if(query) {
+                            const cleanedQuery = query.toLowerCase().replace(/\s\s+/g, ' ');
+                            if(PubSubManager.SCHEMA_ALTERING_QUERIES.some(q => cleanedQuery.includes(q.toLowerCase()))){
+                                this.prostgles.onSchemaChange({ command, query })
+                            }
+                        }
                     }
 
                     if(command === "LISTEN"){
@@ -3870,50 +3521,84 @@ function sqlErrCodeToMsg(code: string){
         JSON.stringify([...THE_table_$0.rows].map(t => [...t.children].map(u => u.innerText)).filter((d, i) => i && d.length > 1).reduce((a, v)=>({ ...a, [v[0]]: v[1] }), {}))
       */
 }
-async function getInferredJoins(db: DB, schema: string = "public"): Promise<Join[]>{
+
+
+async function getInferredJoins2(schema: TableSchema[]): Promise<Join[]>{
     let joins: Join[] = [];
-    let res = await db.any(`SELECT
-            tc.table_schema, 
-            tc.constraint_name, 
-            tc.table_name, 
-            kcu.column_name, 
-            ccu.table_schema AS foreign_table_schema,
-            ccu.table_name AS foreign_table_name,
-            ccu.column_name AS foreign_column_name,
-            tc.constraint_type IN ('UNIQUE', 'PRIMARY KEY') as foreign_is_unique
-        FROM 
-            information_schema.table_constraints AS tc 
-            JOIN information_schema.key_column_usage AS kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-            JOIN information_schema.constraint_column_usage AS ccu
-            ON ccu.constraint_name = tc.constraint_name
-            AND ccu.table_schema = tc.table_schema
-        WHERE tc.table_schema=` + "${schema}" + ` 
-        AND tc.constraint_type = 'FOREIGN KEY' 
-        AND tc.table_name <> ccu.table_name -- Exclude self-referencing tables
-    `, { schema });
-        
-    res.map((d: any) => {
-        let eIdx = joins.findIndex(j => j.tables.includes(d.table_name) && j.tables.includes(d.foreign_table_name));
-        let existing = joins[eIdx];
+    const upsertJoin = (t1: string, t2: string, cols: { col1: string; col2: string }[]) => {
+        let existingIdx = joins.findIndex(j => j.tables.slice(0).sort().join() === [t1, t2].sort().join());
+        let existing = joins[existingIdx];
+        const normalCond = cols.reduce((a, v) => ({ ...a, [v.col1]: v.col2 }), {});
+        const revertedCond = cols.reduce((a, v) => ({ ...a, [v.col2]: v.col1 }), {});
         if(existing){
-            if(existing.tables[0] === d.table_name){
-                existing.on = { ...existing.on,  [d.column_name]:  d.foreign_column_name }
-            } else {
-                existing.on = { ...existing.on,  [d.foreign_column_name]:  d.column_name }
+            const cond = existing.tables[0] === t1? normalCond : revertedCond;
+            /** Avoid duplicates */
+            if(!existing.on.some(_cond => JSON.stringify(_cond) === JSON.stringify(cond))){
+                existing.on.push(cond);
+                joins[existingIdx] = existing;
             }
-            joins[eIdx] = existing;
         } else {
             joins.push({
-                tables: [d.table_name, d.foreign_table_name],
-                on: {
-                    [d.column_name]:  d.foreign_column_name 
-                },
+                tables: [t1, t2],
+                on: [normalCond],
                 type: "many-many"
             })
         }
-    });
-    
+    }
+    schema.map(tov => {
+        tov.columns.map(col => {
+            if(col.references){
+                const r = col.references;
+                upsertJoin(tov.name, r.ftable, r.cols.map((c, i) => ({ col1: c, col2: r.fcols[i] })))
+            }
+        })
+    })
     return joins;
-}
+}
+// async function getInferredJoins(db: DB, schema: string = "public"): Promise<Join[]>{
+//     let joins: Join[] = [];
+//     let res = await db.any(`SELECT
+//             tc.table_schema, 
+//             tc.constraint_name, 
+//             tc.table_name, 
+//             kcu.column_name, 
+//             ccu.table_schema AS foreign_table_schema,
+//             ccu.table_name AS foreign_table_name,
+//             ccu.column_name AS foreign_column_name,
+//             tc.constraint_type IN ('UNIQUE', 'PRIMARY KEY') as foreign_is_unique
+//         FROM 
+//             information_schema.table_constraints AS tc 
+//             JOIN information_schema.key_column_usage AS kcu
+//             ON tc.constraint_name = kcu.constraint_name
+//             AND tc.table_schema = kcu.table_schema
+//             JOIN information_schema.constraint_column_usage AS ccu
+//             ON ccu.constraint_name = tc.constraint_name
+//             AND ccu.table_schema = tc.table_schema
+//         WHERE tc.table_schema=` + "${schema}" + ` 
+//         AND tc.constraint_type = 'FOREIGN KEY' 
+//         AND tc.table_name <> ccu.table_name -- Exclude self-referencing tables
+//     `, { schema });
+        
+//     res.map((d: any) => {
+//         let eIdx = joins.findIndex(j => j.tables.includes(d.table_name) && j.tables.includes(d.foreign_table_name));
+//         let existing = joins[eIdx];
+//         if(existing){
+//             if(existing.tables[0] === d.table_name){
+//                 existing.on = { ...existing.on,  [d.column_name]:  d.foreign_column_name }
+//             } else {
+//                 existing.on = { ...existing.on,  [d.foreign_column_name]:  d.column_name }
+//             }
+//             joins[eIdx] = existing;
+//         } else {
+//             joins.push({
+//                 tables: [d.table_name, d.foreign_table_name],
+//                 on: {
+//                     [d.column_name]:  d.foreign_column_name 
+//                 },
+//                 type: "many-many"
+//             })
+//         }
+//     });
+    
+//     return joins;
+// }