prostgles-server 3.0.38 → 3.0.40

package/dist/DboBuilder.js

@@ -5,9 +5,8 @@
  *--------------------------------------------------------------------------------------------*/
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.canEXECUTE = exports.prepareSort = exports.postgresToTsType = exports.isPlainObject = exports.DboBuilder = exports.TableHandler = exports.isPojoObject = exports.ViewHandler = exports.parseError = exports.EXISTS_KEYS = exports.makeErr = exports.escapeTSNames = exports.pgp = void 0;
+exports.canEXECUTE = exports.prepareSort = exports.postgresToTsType = exports.isPlainObject = exports.DboBuilder = exports.parseError = exports.EXISTS_KEYS = exports.makeErr = exports.escapeTSNames = exports.pgp = void 0;
 const Bluebird = require("bluebird");
-const makeSelectQuery_1 = require("./DboBuilder/QueryBuilder/makeSelectQuery");
 const pgPromise = require("pg-promise");
 const runSQL_1 = require("./DboBuilder/runSQL");
 const prostgles_types_1 = require("prostgles-types");
@@ -25,24 +24,12 @@ const prostgles_types_1 = require("prostgles-types");
 //     return []
 // }
 const utils_1 = require("./utils");
-const QueryBuilder_1 = require("./DboBuilder/QueryBuilder/QueryBuilder");
 const PubSubManager_1 = require("./PubSubManager");
-const insertDataParse_1 = require("./DboBuilder/insertDataParse");
-const insert_1 = require("./DboBuilder/insert");
-const update_1 = require("./DboBuilder/update");
-const delete_1 = require("./DboBuilder/delete");
-const Filtering_1 = require("./Filtering");
+const ViewHandler_1 = require("./DboBuilder/ViewHandler");
 exports.pgp = pgPromise({
     promiseLib: Bluebird
     // ,query: function (e) { console.log({psql: e.query, params: e.params}); }
 });
-function replaceNonAlphaNumeric(string, replacement = "_") {
-    return string.replace(/[\W_]+/g, replacement);
-}
-function capitalizeFirstLetter(string, nonalpha_replacement) {
-    const str = replaceNonAlphaNumeric(string, nonalpha_replacement);
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
 function snakify(str, capitalize = false) {
     return str.split("").map((c, i) => {
         if (!i) {
@@ -104,7 +91,6 @@ function makeErr(err, localParams, view, allowedKeys) {
 }
 exports.makeErr = makeErr;
 exports.EXISTS_KEYS = ["$exists", "$notExists", "$existsJoined", "$notExistsJoined"];
-const FILTER_FUNCS = QueryBuilder_1.FUNCTIONS.filter(f => f.canBeUsedForFilter);
 /**
  * Ensure the error is an Object and has
  */
@@ -124,1749 +110,9 @@ function parseError(e, caller) {
     return result;
 }
 exports.parseError = parseError;
-class ColSet {
-    constructor(columns, tableName) {
-        this.opts = { columns, tableName, colNames: columns.map(c => c.name) };
-    }
-    async getRow(data, allowedCols, dbTx, validate) {
-        const badCol = allowedCols.find(c => !this.opts.colNames.includes(c));
-        if (!allowedCols || badCol) {
-            throw "Missing or unexpected columns: " + badCol;
-        }
-        if ((0, prostgles_types_1.isEmpty)(data))
-            throw "No data";
-        let row = (0, PubSubManager_1.pickKeys)(data, allowedCols);
-        if (validate) {
-            row = await validate(row, dbTx);
-        }
-        const rowKeys = Object.keys(row);
-        return rowKeys.map(key => {
-            const col = this.opts.columns.find(c => c.name === key);
-            if (!col)
-                throw "Unexpected missing col name";
-            /**
-             * Add utility functions for PostGIS data
-             */
-            let escapedVal = "";
-            if (["geometry", "geography"].includes(col.udt_name) && row[key] && isPlainObject(row[key])) {
-                const basicFunc = (args) => {
-                    return args.map(arg => (0, PubSubManager_1.asValue)(arg)).join(", ");
-                };
-                const basicFuncNames = ["ST_GeomFromText", "ST_Point", "ST_MakePoint", "ST_MakePointM", "ST_PointFromText", "ST_GeomFromEWKT", "ST_GeomFromGeoJSON"];
-                const dataKeys = Object.keys(row[key]);
-                const funcName = dataKeys[0];
-                const funcExists = basicFuncNames.includes(funcName);
-                const funcArgs = row[key]?.[funcName];
-                if (dataKeys.length !== 1 || !funcExists || !Array.isArray(funcArgs)) {
-                    throw `Expecting only one function key (${basicFuncNames.join(", ")}) \nwith an array of arguments \n within column (${key}) data but got: ${JSON.stringify(row[key])} \nExample: { geo_col: { ST_GeomFromText: ["POINT(-71.064544 42.28787)", 4326] } }`;
-                }
-                escapedVal = `${funcName}(${basicFunc(funcArgs)})`;
-            }
-            else {
-                /** Prevent pg-promise formatting jsonb */
-                const colIsJSON = ["json", "jsonb"].includes(col.data_type);
-                escapedVal = exports.pgp.as.format(colIsJSON ? "$1:json" : "$1", [row[key]]);
-            }
-            /**
-             * Cast to type to avoid array errors (they do not cast automatically)
-             */
-            escapedVal += `::${col.udt_name}`;
-            return {
-                escapedCol: (0, prostgles_types_1.asName)(key),
-                escapedVal,
-            };
-        });
-    }
-    async getInsertQuery(data, allowedCols, dbTx, validate) {
-        const res = (await Promise.all((Array.isArray(data) ? data : [data]).map(async (d) => {
-            const rowParts = await this.getRow(d, allowedCols, dbTx, validate);
-            const select = rowParts.map(r => r.escapedCol).join(", "), values = rowParts.map(r => r.escapedVal).join(", ");
-            return `INSERT INTO ${(0, prostgles_types_1.asName)(this.opts.tableName)} (${select}) VALUES (${values})`;
-        }))).join(";\n") + " ";
-        return res;
-    }
-    async getUpdateQuery(data, allowedCols, dbTx, validate) {
-        const res = (await Promise.all((Array.isArray(data) ? data : [data]).map(async (d) => {
-            const rowParts = await this.getRow(d, allowedCols, dbTx, validate);
-            return `UPDATE ${(0, prostgles_types_1.asName)(this.opts.tableName)} SET ` + rowParts.map(r => `${r.escapedCol} = ${r.escapedVal} `).join(",\n");
-        }))).join(";\n") + " ";
-        return res;
-    }
-}
-class ViewHandler {
-    constructor(db, tableOrViewInfo, dboBuilder, t, dbTX, joinPaths) {
-        this.tsColumnDefs = [];
-        this.is_view = true;
-        this.filterDef = "";
-        // pubSubManager: PubSubManager;
-        this.is_media = false;
-        if (!db || !tableOrViewInfo)
-            throw "";
-        this.db = db;
-        this.t = t;
-        this.dbTX = dbTX;
-        this.joinPaths = joinPaths;
-        this.tableOrViewInfo = tableOrViewInfo;
-        this.name = tableOrViewInfo.name;
-        this.escapedName = (0, prostgles_types_1.asName)(this.name);
-        this.columns = tableOrViewInfo.columns;
-        /* cols are sorted by name to reduce .d.ts schema rewrites */
-        this.columnsForTypes = tableOrViewInfo.columns.slice(0).sort((a, b) => a.name.localeCompare(b.name));
-        this.column_names = tableOrViewInfo.columns.map(c => c.name);
-        // this.pubSubManager = pubSubManager;
-        this.dboBuilder = dboBuilder;
-        this.joins = this.dboBuilder.joins ?? [];
-        // fix this
-        // and also make hot schema reload over ws 
-        this.colSet = new ColSet(this.columns, this.name);
-        const { $and: $and_key, $or: $or_key } = this.dboBuilder.prostgles.keywords;
-        // this.tsDataName = snakify(this.name, true);
-        // if(this.tsDataName === "T") this.tsDataName = this.tsDataName + "_";
-        // this.tsDataDef = `export type ${this.tsDataName} = {\n`;
-        this.columnsForTypes.map(({ name, udt_name, is_nullable }) => {
-            this.tsColumnDefs.push(`${escapeTSNames(name)}?: ${postgresToTsType(udt_name)} ${is_nullable ? " | null " : ""};`);
-        });
-        // this.tsDataDef += "};";
-        // this.tsDataDef += "\n";
-        // this.tsDataDef += `export type ${this.tsDataName}_Filter = ${this.tsDataName} | object | { ${JSON.stringify($and_key)}: (${this.tsDataName} | object)[] } | { ${JSON.stringify($or_key)}: (${this.tsDataName} | object)[] } `;
-        // this.filterDef = ` ${this.tsDataName}_Filter `;
-        // const filterDef = this.filterDef;
-        // this.tsDboDefs = [
-        //     `   getColumns: () => Promise<any[]>;`,
-        //     `   find: (filter?: ${filterDef}, selectParams?: SelectParams) => Promise<Partial<${this.tsDataName} & { [x: string]: any }>[]>;`,
-        //     `   findOne: (filter?: ${filterDef}, selectParams?: SelectParams) => Promise<Partial<${this.tsDataName} & { [x: string]: any }>>;`,
-        //     `   subscribe: (filter: ${filterDef}, params: SelectParams, onData: (items: Partial<${this.tsDataName} & { [x: string]: any }>[]) => any) => Promise<{ unsubscribe: () => any }>;`,
-        //     `   subscribeOne: (filter: ${filterDef}, params: SelectParams, onData: (item: Partial<${this.tsDataName} & { [x: string]: any }>) => any) => Promise<{ unsubscribe: () => any }>;`,
-        //     `   count: (filter?: ${filterDef}) => Promise<number>;`
-        // ];
-        // this.makeDef();
-    }
-    // makeDef(){
-    //     this.tsDboName = `DBO_${snakify(this.name)}`;
-    //     this.tsDboDef = `export type ${this.tsDboName} = {\n ${this.tsDboDefs.join("\n")} \n};\n`;
-    // }
-    getRowHashSelect(allowedFields, alias, tableAlias) {
-        let allowed_cols = this.column_names;
-        if (allowedFields)
-            allowed_cols = this.parseFieldFilter(allowedFields);
-        return "md5(" +
-            allowed_cols
-                /* CTID not available in AFTER trigger */
-                // .concat(this.is_view? [] : ["ctid"])
-                .sort()
-                .map(f => (tableAlias ? ((0, prostgles_types_1.asName)(tableAlias) + ".") : "") + (0, prostgles_types_1.asName)(f))
-                .map(f => `md5(coalesce(${f}::text, 'dd'))`)
-                .join(" || ") +
-            `)` + (alias ? ` as ${(0, prostgles_types_1.asName)(alias)}` : "");
-    }
-    async validateViewRules(args) {
-        const { fields, filterFields, returningFields, forcedFilter, dynamicFields, rule, } = args;
-        /* Safely test publish rules */
-        if (fields) {
-            try {
-                const _fields = this.parseFieldFilter(fields);
-                if (this.is_media && rule === "insert" && !_fields.includes("id")) {
-                    throw "Must allow id insert for media table";
-                }
-            }
-            catch (e) {
-                throw ` issue with publish.${this.name}.${rule}.fields: \nVALUE: ` + JSON.stringify(fields, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
-            }
-        }
-        if (filterFields) {
-            try {
-                this.parseFieldFilter(filterFields);
-            }
-            catch (e) {
-                throw ` issue with publish.${this.name}.${rule}.filterFields: \nVALUE: ` + JSON.stringify(filterFields, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
-            }
-        }
-        if (returningFields) {
-            try {
-                this.parseFieldFilter(returningFields);
-            }
-            catch (e) {
-                throw ` issue with publish.${this.name}.${rule}.returningFields: \nVALUE: ` + JSON.stringify(returningFields, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
-            }
-        }
-        if (forcedFilter) {
-            try {
-                await this.find(forcedFilter, { limit: 0 });
-            }
-            catch (e) {
-                throw ` issue with publish.${this.name}.${rule}.forcedFilter: \nVALUE: ` + JSON.stringify(forcedFilter, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
-            }
-        }
-        if (dynamicFields) {
-            for await (const dfieldRule of dynamicFields) {
-                try {
-                    const { fields, filter } = dfieldRule;
-                    this.parseFieldFilter(fields);
-                    await this.find(filter, { limit: 0 });
-                }
-                catch (e) {
-                    throw ` issue with publish.${this.name}.${rule}.dynamicFields: \nVALUE: ` + JSON.stringify(dfieldRule, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
-                }
-            }
-        }
-        return true;
-    }
-    getShortestJoin(table1, table2, startAlias, isInner = false) {
-        // let searchedTables = [], result; 
-        // while (!result && searchedTables.length <= this.joins.length * 2){
-        // }
-        const getJoinCondition = (on, leftTable, rightTable) => {
-            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) => {
-            if (type.split("-")[1] === "many") {
-                toOne = false;
-            }
-            const tl = `tl${startAlias + i}`, tr = `tr${startAlias + i}`;
-            return `FROM ${tables[0]} ${tl} ${isInner ? "INNER" : "LEFT"} JOIN ${tables[1]} ${tr} ON ${getJoinCondition(on, tl, tr)}`;
-        }).join("\n");
-        return { query, toOne: false };
-    }
-    getJoins(source, target, path, checkTableConfig) {
-        let paths = [];
-        if (!this.joinPaths)
-            throw `${source} - ${target} Join info missing or dissallowed`;
-        if (path && !path.length)
-            throw `Empty join path ( $path ) specified for ${source} <-> ${target}`;
-        /* Find the join path between tables */
-        if (checkTableConfig) {
-            const tableConfigJoinInfo = this.dboBuilder?.prostgles?.tableConfigurator?.getJoinInfo(source, target);
-            if (tableConfigJoinInfo)
-                return tableConfigJoinInfo;
-        }
-        let jp;
-        if (!path) {
-            jp = this.joinPaths.find(j => j.t1 === source && j.t2 === target);
-        }
-        else {
-            jp = {
-                t1: source,
-                t2: target,
-                path
-            };
-        }
-        /* Self join */
-        if (source === target) {
-            const tableHandler = this.dboBuilder.tablesOrViews?.find(t => t.name === source);
-            if (!tableHandler)
-                throw `Table not found for joining ${source}`;
-            const fcols = tableHandler.columns.filter(c => c.references?.some(({ ftable }) => ftable === this.name));
-            if (fcols.length) {
-                throw "Self referencing not supported yet";
-                // return {
-                //     paths: [{
-                //         source,
-                //         target,
-                //         table: target,
-                //         on: fcols.map(fc => fc.references!.some(({ fcols }) => fcols.map(fcol => [fc.name,  fcol])))
-                //     }],
-                //     expectOne: false
-                // }
-            }
-        }
-        if (!jp || !this.joinPaths.find(j => path ? j.path.join() === path.join() : j.t1 === source && j.t2 === target)) {
-            throw `Joining ${source} <-...-> ${target} dissallowed or missing`;
-        }
-        /* Make the join chain info excluding root table */
-        paths = (path || jp.path).slice(1).map((t2, i, arr) => {
-            const t1 = i === 0 ? source : arr[i - 1];
-            this.joins ?? (this.joins = this.dboBuilder.joins);
-            /* Get join options */
-            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 = [];
-            jo.on.map(cond => {
-                let condArr = [];
-                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,
-                target,
-                table: t2,
-                on
-            };
-        });
-        let expectOne = false;
-        // paths.map(({ source, target, on }, i) => {
-        // if(expectOne && on.length === 1){
-        //     const sourceCol = on[0][1];
-        //     const targetCol = on[0][0];
-        //     const sCol = this.dboBuilder.dbo[source].columns.find(c => c.name === sourceCol)
-        //     const tCol = this.dboBuilder.dbo[target].columns.find(c => c.name === targetCol)
-        //     console.log({ sourceCol, targetCol, sCol, source, tCol, target, on})
-        //     expectOne = sCol.is_pkey && tCol.is_pkey
-        // }
-        // })
-        return {
-            paths,
-            expectOne
-        };
-    }
-    checkFilter(filter) {
-        if (filter === null || filter && !isPojoObject(filter))
-            throw `invalid filter -> ${JSON.stringify(filter)} \nExpecting:    undefined | {} | { field_name: "value" } | { field: { $gt: 22 } } ... `;
-    }
-    async getInfo(lang, param2, param3, tableRules, localParams) {
-        const p = this.getValidatedRules(tableRules, localParams);
-        if (!p.getInfo)
-            throw "Not allowed";
-        let has_media = undefined;
-        const mediaTable = this.dboBuilder.prostgles?.opts?.fileTable?.tableName;
-        if (!this.is_media && mediaTable) {
-            const joinConf = this.dboBuilder.prostgles?.opts?.fileTable?.referencedTables?.[this.name];
-            if (joinConf) {
-                has_media = typeof joinConf === "string" ? joinConf : "one";
-            }
-            else {
-                const jp = this.dboBuilder.joinPaths.find(jp => jp.t1 === this.name && jp.t2 === mediaTable);
-                if (jp && jp.path.length <= 3) {
-                    if (jp.path.length <= 2) {
-                        has_media = "one";
-                    }
-                    else {
-                        await Promise.all(jp.path.map(async (tableName) => {
-                            const pkeyFcols = this?.dboBuilder?.dbo?.[tableName]?.columns?.filter(c => c.is_pkey).map(c => c.name);
-                            const cols = this?.dboBuilder?.dbo?.[tableName]?.columns?.filter(c => c?.references?.some(({ ftable }) => jp.path.includes(ftable)));
-                            if (cols && cols.length && has_media !== "many") {
-                                if (cols.some(c => !pkeyFcols?.includes(c.name))) {
-                                    has_media = "many";
-                                }
-                                else {
-                                    has_media = "one";
-                                }
-                            }
-                        }));
-                    }
-                }
-            }
-        }
-        return {
-            oid: this.tableOrViewInfo.oid,
-            comment: this.tableOrViewInfo.comment,
-            info: this.dboBuilder.prostgles?.tableConfigurator?.getTableInfo({ tableName: this.name, lang }),
-            is_media: this.is_media,
-            is_view: this.is_view,
-            has_media,
-            media_table_name: mediaTable,
-            dynamicRules: {
-                update: Boolean(tableRules?.update?.dynamicFields?.length)
-            }
-        };
-    }
-    // TODO: fix renamed table trigger problem
-    async getColumns(lang, params, _param3, tableRules, localParams) {
-        try {
-            const p = this.getValidatedRules(tableRules, localParams);
-            if (!p.getColumns)
-                throw "Not allowed";
-            // console.log("getColumns", this.name, this.columns.map(c => c.name))
-            let dynamicUpdateFields;
-            if (params && "parseUpdateRules" in this && this.parseUpdateRules) {
-                if (!isPlainObject(params) || !isPlainObject(params.data) || !isPlainObject(params.filter) || params.rule !== "update") {
-                    throw "params must be { rule: 'update', data, filter } but got: " + JSON.stringify(params);
-                }
-                if (!tableRules?.update) {
-                    dynamicUpdateFields = [];
-                }
-                else {
-                    const { data, filter } = params;
-                    const updateRules = await this.parseUpdateRules(filter, data, undefined, tableRules, localParams);
-                    dynamicUpdateFields = updateRules.fields;
-                }
-            }
-            let columns = this.columns
-                .filter(c => {
-                const { insert, select, update } = p || {};
-                return [
-                    ...(insert?.fields || []),
-                    ...(select?.fields || []),
-                    ...(update?.fields || []),
-                ].includes(c.name);
-            })
-                .map(_c => {
-                let c = { ..._c };
-                let label = c.comment || capitalizeFirstLetter(c.name, " ");
-                let select = c.privileges.some(p => p.privilege_type === "SELECT"), insert = c.privileges.some(p => p.privilege_type === "INSERT"), update = c.privileges.some(p => p.privilege_type === "UPDATE"), _delete = this.tableOrViewInfo.privileges.delete; // c.privileges.some(p => p.privilege_type === "DELETE");
-                delete c.privileges;
-                const prostgles = this.dboBuilder?.prostgles;
-                const fileConfig = prostgles.fileManager?.getColInfo({ colName: c.name, tableName: this.name });
-                /** Do not allow updates to file table unless it's to delete fields */
-                if (prostgles.fileManager?.config && prostgles.fileManager.tableName === this.name) {
-                    update = false;
-                }
-                let result = {
-                    ...c,
-                    label,
-                    tsDataType: postgresToTsType(c.udt_name),
-                    insert: insert && Boolean(p.insert && p.insert.fields && p.insert.fields.includes(c.name)) && tableRules?.insert?.forcedData?.[c.name] === undefined,
-                    select: select && Boolean(p.select && p.select.fields && p.select.fields.includes(c.name)),
-                    orderBy: select && Boolean(p.select && p.select.fields && p.select.orderByFields.includes(c.name)),
-                    filter: Boolean(p.select && p.select.filterFields && p.select.filterFields.includes(c.name)),
-                    update: update && Boolean(p.update && p.update.fields && p.update.fields.includes(c.name)) && tableRules?.update?.forcedData?.[c.name] === undefined,
-                    delete: _delete && Boolean(p.delete && p.delete.filterFields && p.delete.filterFields.includes(c.name)),
-                    ...(prostgles?.tableConfigurator?.getColInfo({ table: this.name, col: c.name, lang }) || {}),
-                    ...(fileConfig && { file: fileConfig })
-                };
-                if (dynamicUpdateFields) {
-                    result.update = dynamicUpdateFields.includes(c.name);
-                }
-                return result;
-            }).filter(c => c.select || c.update || c.delete || c.insert);
-            //.sort((a, b) => a.ordinal_position - b.ordinal_position);
-            // const tblInfo = await this.getInfo();
-            // if(tblInfo && tblInfo.media_table_name && tblInfo.has_media){
-            //     const mediaRules = this.dboBuilder.dbo[tblInfo.media_table_name]?.
-            //     return columns.concat({
-            //         comment: "",
-            //         data_type: "file",
-            //         delete: false,
-            //     });
-            // }
-            return columns;
-        }
-        catch (e) {
-            throw parseError(e, `db.${this.name}.getColumns()`);
-            // throw "Something went wrong in " + `db.${this.name}.getColumns()`;
-        }
-    }
-    getValidatedRules(tableRules, localParams) {
-        if ((0, utils_1.get)(localParams, "socket") && !tableRules) {
-            throw "INTERNAL ERROR: Unexpected case -> localParams && !tableRules";
-        }
-        /* Computed fields are allowed only if select is allowed */
-        const allColumns = this.column_names.slice(0).map(fieldName => ({
-            type: "column",
-            name: fieldName,
-            getQuery: ({ tableAlias }) => (0, QueryBuilder_1.asNameAlias)(fieldName, tableAlias),
-            selected: false
-        })).concat(QueryBuilder_1.COMPUTED_FIELDS.map(c => ({
-            type: c.type,
-            name: c.name,
-            getQuery: ({ tableAlias, allowedFields }) => c.getQuery({
-                allowedFields,
-                ctidField: undefined,
-                allColumns: this.columns,
-                /* CTID not available in AFTER trigger */
-                // ctidField: this.is_view? undefined : "ctid",
-                tableAlias
-            }),
-            selected: false
-        })));
-        if (tableRules) {
-            if ((0, prostgles_types_1.isEmpty)(tableRules))
-                throw "INTERNAL ERROR: Unexpected case -> Empty table rules for " + this.name;
-            const throwFieldsErr = (command, fieldType = "fields") => {
-                throw `Invalid publish.${this.name}.${command} rule -> ${fieldType} setting is missing.\nPlease specify allowed ${fieldType} in this format: "*" | { col_name: false } | { col1: true, col2: true }`;
-            }, getFirstSpecified = (...fieldParams) => {
-                const firstValid = fieldParams.find(fp => fp !== undefined);
-                return this.parseFieldFilter(firstValid);
-            };
-            let res = {
-                allColumns,
-                getColumns: tableRules?.getColumns ?? true,
-                getInfo: tableRules?.getColumns ?? true,
-            };
-            /* SELECT */
-            if (tableRules.select) {
-                if (!tableRules.select.fields)
-                    return throwFieldsErr("select");
-                let maxLimit = null;
-                if (tableRules.select.maxLimit !== undefined && tableRules.select.maxLimit !== maxLimit) {
-                    const ml = tableRules.select.maxLimit;
-                    if (ml !== null && (!Number.isInteger(ml) || ml < 0))
-                        throw ` Invalid publish.${this.name}.select.maxLimit -> expecting   a positive integer OR null    but got ` + ml;
-                    maxLimit = ml;
-                }
-                const fields = this.parseFieldFilter(tableRules.select.fields);
-                res.select = {
-                    fields,
-                    orderByFields: tableRules.select.orderByFields ? this.parseFieldFilter(tableRules.select.orderByFields) : fields,
-                    forcedFilter: { ...tableRules.select.forcedFilter },
-                    filterFields: this.parseFieldFilter(tableRules.select.filterFields),
-                    maxLimit
-                };
-            }
-            /* UPDATE */
-            if (tableRules.update) {
-                if (!tableRules.update.fields)
-                    return throwFieldsErr("update");
-                res.update = {
-                    fields: this.parseFieldFilter(tableRules.update.fields),
-                    forcedData: { ...tableRules.update.forcedData },
-                    forcedFilter: { ...tableRules.update.forcedFilter },
-                    returningFields: getFirstSpecified(tableRules.update?.returningFields, tableRules?.select?.fields, tableRules.update.fields),
-                    filterFields: this.parseFieldFilter(tableRules.update.filterFields)
-                };
-            }
-            /* INSERT */
-            if (tableRules.insert) {
-                if (!tableRules.insert.fields)
-                    return throwFieldsErr("insert");
-                res.insert = {
-                    fields: this.parseFieldFilter(tableRules.insert.fields),
-                    forcedData: { ...tableRules.insert.forcedData },
-                    returningFields: getFirstSpecified(tableRules.insert.returningFields, tableRules?.select?.fields, tableRules.insert.fields)
-                };
-            }
-            /* DELETE */
-            if (tableRules.delete) {
-                if (!tableRules.delete.filterFields)
-                    return throwFieldsErr("delete", "filterFields");
-                res.delete = {
-                    forcedFilter: { ...tableRules.delete.forcedFilter },
-                    filterFields: this.parseFieldFilter(tableRules.delete.filterFields),
-                    returningFields: getFirstSpecified(tableRules.delete.returningFields, tableRules?.select?.fields, tableRules.delete.filterFields)
-                };
-            }
-            if (!tableRules.select && !tableRules.update && !tableRules.delete && !tableRules.insert) {
-                if ([null, false].includes(tableRules.getInfo))
-                    res.getInfo = false;
-                if ([null, false].includes(tableRules.getColumns))
-                    res.getColumns = false;
-            }
-            return res;
-        }
-        else {
-            const all_cols = this.column_names.slice(0);
-            return {
-                allColumns,
-                getColumns: true,
-                getInfo: true,
-                select: {
-                    fields: all_cols,
-                    filterFields: all_cols,
-                    orderByFields: all_cols,
-                    forcedFilter: {},
-                    maxLimit: null,
-                },
-                update: {
-                    fields: all_cols,
-                    filterFields: all_cols,
-                    forcedFilter: {},
-                    forcedData: {},
-                    returningFields: all_cols
-                },
-                insert: {
-                    fields: all_cols,
-                    forcedData: {},
-                    returningFields: all_cols
-                },
-                delete: {
-                    filterFields: all_cols,
-                    forcedFilter: {},
-                    returningFields: all_cols
-                }
-            };
-        }
-    }
-    async find(filter, selectParams, param3_unused, tableRules, localParams) {
-        try {
-            filter = filter || {};
-            const allowedReturnTypes = ["row", "value", "values", "statement"];
-            const { returnType } = selectParams || {};
-            if (returnType && !allowedReturnTypes.includes(returnType)) {
-                throw `returnType (${returnType}) can only be ${allowedReturnTypes.join(" OR ")}`;
-            }
-            const { testRule = false, returnQuery = false } = localParams || {};
-            if (testRule)
-                return [];
-            if (selectParams) {
-                const good_params = ["select", "orderBy", "offset", "limit", "returnType", "groupBy"];
-                const bad_params = Object.keys(selectParams).filter(k => !good_params.includes(k));
-                if (bad_params && bad_params.length)
-                    throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
-            }
-            /* Validate publish */
-            if (tableRules) {
-                let fields, filterFields, forcedFilter, maxLimit;
-                if (!tableRules.select)
-                    throw "select rules missing for " + this.name;
-                fields = tableRules.select.fields;
-                forcedFilter = tableRules.select.forcedFilter;
-                filterFields = tableRules.select.filterFields;
-                maxLimit = tableRules.select.maxLimit;
-                if (tableRules.select !== "*" && typeof tableRules.select !== "boolean" && !isPlainObject(tableRules.select))
-                    throw `\nINVALID publish.${this.name}.select\nExpecting any of: "*" | { fields: "*" } | true | false`;
-                if (!fields)
-                    throw ` invalid ${this.name}.select rule -> fields (required) setting missing.\nExpecting any of: "*" | { col_name: false } | { col1: true, col2: true }`;
-                if (maxLimit && !Number.isInteger(maxLimit))
-                    throw ` invalid publish.${this.name}.select.maxLimit -> expecting integer but got ` + maxLimit;
-            }
-            let q = await (0, QueryBuilder_1.getNewQuery)(this, filter, selectParams, param3_unused, tableRules, localParams, this.columns), _query = (0, makeSelectQuery_1.makeSelectQuery)(this, q, undefined, undefined, selectParams);
-            // console.log(_query, JSON.stringify(q, null, 2))
-            if (testRule) {
-                try {
-                    await this.db.any("EXPLAIN " + _query);
-                    return [];
-                }
-                catch (e) {
-                    console.error(e);
-                    throw `INTERNAL ERROR: Publish config is not valid for publish.${this.name}.select `;
-                }
-            }
-            if (returnQuery)
-                return _query;
-            if (returnType === "statement") {
-                if (!(await (0, runSQL_1.canRunSQL)(this.dboBuilder.prostgles, localParams))) {
-                    throw `Not allowed:  {returnType: "statement"} requires sql privileges `;
-                }
-                return _query;
-            }
-            if (["row", "value"].includes(returnType)) {
-                return (this.t || this.db).oneOrNone(_query).then(data => {
-                    return (data && returnType === "value") ? Object.values(data)[0] : data;
-                }).catch(err => makeErr(err, localParams, this));
-            }
-            else {
-                return (this.t || this.db).any(_query).then(data => {
-                    if (returnType === "values") {
-                        return data.map(d => Object.values(d)[0]);
-                    }
-                    return data;
-                }).catch(err => makeErr(err, localParams, this));
-            }
-        }
-        catch (e) {
-            // console.trace(e)
-            if (localParams && localParams.testRule)
-                throw e;
-            throw parseError(e, `dbo.${this.name}.find()`);
-            // throw { err: parseError(e), msg: `Issue with dbo.${this.name}.find()`, args: { filter, selectParams} };
-        }
-    }
-    findOne(filter, selectParams, param3_unused, table_rules, localParams) {
-        try {
-            const { select = "*", orderBy, offset = 0 } = selectParams || {};
-            if (selectParams) {
-                const good_params = ["select", "orderBy", "offset"];
-                const bad_params = Object.keys(selectParams).filter(k => !good_params.includes(k));
-                if (bad_params && bad_params.length)
-                    throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
-            }
-            return this.find(filter, { select, orderBy, limit: 1, offset, returnType: "row" }, undefined, table_rules, localParams);
-        }
-        catch (e) {
-            if (localParams && localParams.testRule)
-                throw e;
-            throw parseError(e, `Issue with dbo.${this.name}.findOne()`);
-        }
-    }
-    async count(filter, param2_unused, param3_unused, table_rules, localParams) {
-        filter = filter || {};
-        try {
-            return await this.find(filter, { select: "", limit: 0 }, undefined, table_rules, localParams)
-                .then(async (allowed) => {
-                const { filterFields, forcedFilter } = (0, utils_1.get)(table_rules, "select") || {};
-                const where = (await this.prepareWhere({ filter, forcedFilter, filterFields, addKeywords: true, localParams, tableRule: table_rules })).where;
-                let query = "SELECT COUNT(*) FROM " + this.escapedName + " " + where;
-                return (this.t || this.db).one(query, { _psqlWS_tableName: this.name }).then(({ count }) => +count);
-            });
-        }
-        catch (e) {
-            if (localParams && localParams.testRule)
-                throw e;
-            throw parseError(e, `dbo.${this.name}.count()`);
-        }
-    }
-    async size(filter, selectParams, param3_unused, table_rules, localParams) {
-        filter = filter || {};
-        try {
-            return await this.find(filter, { ...selectParams, limit: 2 }, undefined, table_rules, localParams)
-                .then(async (_allowed) => {
-                // let rules: TableRule = table_rules || {};
-                // rules.select.maxLimit = Number.MAX_SAFE_INTEGER;
-                // rules.select.fields = rules.select.fields || "*";
-                const q = await this.find(filter, { ...selectParams, limit: selectParams?.limit ?? Number.MAX_SAFE_INTEGER }, undefined, table_rules, { ...localParams, returnQuery: true });
-                const query = `
-                        SELECT sum(pg_column_size((prgl_size_query.*))) as size 
-                        FROM (
-                            ${q}
-                        ) prgl_size_query
-                    `;
-                return (this.t || this.db).one(query, { _psqlWS_tableName: this.name }).then(({ size }) => size || '0');
-            });
-        }
-        catch (e) {
-            if (localParams && localParams.testRule)
-                throw e;
-            throw parseError(e, `dbo.${this.name}.size()`);
-        }
-    }
-    getAllowedSelectFields(selectParams = "*", allowed_cols, allow_empty = true) {
-        let all_columns = this.column_names.slice(0), allowedFields = all_columns.slice(0), resultFields = [];
-        if (selectParams) {
-            resultFields = this.parseFieldFilter(selectParams, allow_empty);
-        }
-        if (allowed_cols) {
-            allowedFields = this.parseFieldFilter(allowed_cols, allow_empty);
-        }
-        let col_names = (resultFields || []).filter(f => !allowedFields || allowedFields.includes(f));
-        /* Maintain allowed cols order */
-        if (selectParams === "*" && allowedFields && allowedFields.length)
-            col_names = allowedFields;
-        return col_names;
-    }
-    prepareColumnSet(selectParams = "*", allowed_cols, allow_empty = true, onlyNames = true) {
-        let all_columns = this.column_names.slice(0);
-        let col_names = this.getAllowedSelectFields(selectParams, all_columns, allow_empty);
-        /** Ensure order is maintained */
-        if (selectParams && Array.isArray(selectParams) && typeof selectParams[0] === "string") {
-            col_names = col_names.sort((a, b) => selectParams.indexOf(a) - selectParams.indexOf(b));
-        }
-        try {
-            let colSet = new exports.pgp.helpers.ColumnSet(col_names);
-            return onlyNames ? colSet.names : colSet;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    prepareSelect(selectParams = "*", allowed_cols, allow_empty = true, tableAlias) {
-        if (tableAlias) {
-            let cs = this.prepareColumnSet(selectParams, allowed_cols, true, false);
-            return cs.columns.map(col => `${this.escapedName}.${(0, prostgles_types_1.asName)(col.name)}`).join(", ");
-        }
-        else {
-            return this.prepareColumnSet(selectParams, allowed_cols, true, true);
-        }
-    }
-    async prepareHaving(params) {
-        return "";
-    }
-    /**
-     * Parses group or simple filter
-     */
-    async prepareWhere(params) {
-        const { filter, select, forcedFilter, filterFields: ff, addKeywords = true, tableAlias, localParams, tableRule } = params;
-        const { $and: $and_key, $or: $or_key } = this.dboBuilder.prostgles.keywords;
-        let filterFields = ff;
-        /* Local update allow all. TODO -> FIX THIS */
-        if (!ff && !tableRule)
-            filterFields = "*";
-        const parseFullFilter = async (f, parentFilter = null, isForcedFilterBypass) => {
-            if (!f)
-                throw "Invalid/missing group filter provided";
-            let result = "";
-            let keys = (0, prostgles_types_1.getKeys)(f);
-            if (!keys.length)
-                return result;
-            if ((keys.includes($and_key) || keys.includes($or_key))) {
-                if (keys.length > 1)
-                    throw `\ngroup filter must contain only one array property. e.g.: { ${$and_key}: [...] } OR { ${$or_key}: [...] } `;
-                if (parentFilter && Object.keys(parentFilter).includes(""))
-                    throw "group filter ($and/$or) can only be placed at the root or within another group filter";
-            }
-            const { [$and_key]: $and, [$or_key]: $or } = f, group = $and || $or;
-            if (group && group.length) {
-                const operand = $and ? " AND " : " OR ";
-                let conditions = (await Promise.all(group.map(async (gf) => await parseFullFilter(gf, group, isForcedFilterBypass)))).filter(c => c);
-                if (conditions && conditions.length) {
-                    if (conditions.length === 1)
-                        return conditions.join(operand);
-                    else
-                        return ` ( ${conditions.sort().join(operand)} ) `;
-                }
-            }
-            else if (!group) {
-                /** forcedFilters do not get checked against publish and are treated as server-side requests */
-                result = await this.getCondition({
-                    filter: { ...f },
-                    select,
-                    allowed_colnames: isForcedFilterBypass ? this.column_names.slice(0) : this.parseFieldFilter(filterFields),
-                    tableAlias,
-                    localParams: isForcedFilterBypass ? undefined : localParams,
-                    tableRules: isForcedFilterBypass ? undefined : tableRule
-                });
-            }
-            return result;
-        };
-        if (!isPlainObject(filter))
-            throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(filter);
-        /* A forced filter condition will not check if the existsJoined filter tables have been published */
-        const forcedFilterCond = forcedFilter ? await parseFullFilter(forcedFilter, null, true) : undefined;
-        const filterCond = await parseFullFilter(filter, null, false);
-        let cond = [
-            forcedFilterCond, filterCond
-        ].filter(c => c).join(" AND ");
-        const finalFilter = forcedFilter ? {
-            [$and_key]: [forcedFilter, filter].filter(prostgles_types_1.isDefined)
-        } : { ...filter };
-        if (cond && addKeywords)
-            cond = "WHERE " + cond;
-        return { where: cond || "", filter: finalFilter };
-    }
-    async prepareExistCondition(eConfig, localParams) {
-        let res = "";
-        const thisTable = this.name;
-        const isNotExists = ["$notExists", "$notExistsJoined"].includes(eConfig.existType);
-        let { f2, tables, isJoined } = eConfig;
-        let t2 = tables[tables.length - 1];
-        tables.forEach(t => {
-            if (!this.dboBuilder.dbo[t])
-                throw { stack: ["prepareExistCondition()"], message: `Invalid or dissallowed table: ${t}` };
-        });
-        /* Nested $exists not allowed */
-        if (f2 && Object.keys(f2).find(fk => exports.EXISTS_KEYS.includes(fk))) {
-            throw { stack: ["prepareExistCondition()"], message: "Nested exists dissallowed" };
-        }
-        const makeTableChain = (finalFilter) => {
-            let joinPaths = [];
-            let expectOne = true;
-            tables.map((t2, depth) => {
-                let t1 = depth ? tables[depth - 1] : thisTable;
-                let exactPaths = [t1, t2];
-                if (!depth && eConfig.shortestJoin)
-                    exactPaths = undefined;
-                const jinf = this.getJoins(t1, t2, exactPaths, true);
-                expectOne = Boolean(expectOne && jinf.expectOne);
-                joinPaths = joinPaths.concat(jinf.paths);
-            });
-            let r = makeJoin({ paths: joinPaths, expectOne }, 0);
-            return r;
-            function makeJoin(joinInfo, ji) {
-                const { paths } = joinInfo;
-                const jp = paths[ji];
-                // let prevTable = ji? paths[ji - 1].table : jp.source;
-                let table = paths[ji].table;
-                let tableAlias = (0, prostgles_types_1.asName)(ji < paths.length - 1 ? `jd${ji}` : table);
-                let prevTableAlias = (0, prostgles_types_1.asName)(ji ? `jd${ji - 1}` : thisTable);
-                let cond = `${jp.on.map(c => {
-                    return c.map(([c1, c2]) => `${prevTableAlias}.${(0, prostgles_types_1.asName)(c1)} = ${tableAlias}.${(0, prostgles_types_1.asName)(c2)}`).join(" AND ");
-                }).join("\n OR ")}`;
-                let j = `SELECT 1 \n` +
-                    `FROM ${(0, prostgles_types_1.asName)(table)} ${tableAlias} \n` +
-                    `WHERE ${cond} \n`; //
-                if (ji === paths.length - 1 &&
-                    finalFilter) {
-                    j += `AND ${finalFilter} \n`;
-                }
-                const indent = (a, b) => a;
-                if (ji < paths.length - 1) {
-                    j += `AND ${makeJoin(joinInfo, ji + 1)} \n`;
-                }
-                j = indent(j, ji + 1);
-                let res = `${isNotExists ? " NOT " : " "} EXISTS ( \n` +
-                    j +
-                    `) \n`;
-                return indent(res, ji);
-            }
-        };
-        let finalWhere = "";
-        let t2Rules = undefined, forcedFilter, filterFields, tableAlias;
-        /* Check if allowed to view data - forcedFilters will bypass this check through isForcedFilterBypass */
-        if (localParams?.isRemoteRequest && (!localParams?.socket && !localParams?.httpReq))
-            throw "Unexpected: localParams isRemoteRequest and missing socket/httpReq: ";
-        if (localParams && (localParams.socket || localParams.httpReq) && this.dboBuilder.publishParser) {
-            t2Rules = await this.dboBuilder.publishParser.getValidatedRequestRuleWusr({ tableName: t2, command: "find", localParams });
-            if (!t2Rules || !t2Rules.select)
-                throw "Dissallowed";
-            ({ forcedFilter, filterFields } = t2Rules.select);
-        }
-        try {
-            finalWhere = (await this.dboBuilder.dbo[t2].prepareWhere({
-                filter: f2,
-                forcedFilter,
-                filterFields,
-                addKeywords: false,
-                tableAlias,
-                localParams,
-                tableRule: t2Rules
-            })).where;
-        }
-        catch (err) {
-            // console.trace(err)
-            throw err;
-        }
-        if (!isJoined) {
-            res = `${isNotExists ? " NOT " : " "} EXISTS (SELECT 1 \nFROM ${(0, prostgles_types_1.asName)(t2)} \n${finalWhere ? `WHERE ${finalWhere}` : ""}) `;
-        }
-        else {
-            res = makeTableChain(finalWhere);
-        }
-        return res;
-    }
-    /**
-     * parses a single filter
-     * @example
-     *  { fff: 2 } => "fff" = 2
-     *  { fff: { $ilike: 'abc' } } => "fff" ilike 'abc'
-     */
-    async getCondition(params) {
-        const { filter, select, allowed_colnames, tableAlias, localParams, tableRules } = params;
-        let data = { ...filter };
-        /* Exists join filter */
-        const ERR = "Invalid exists filter. \nExpecting somethibng like: { $exists: { tableName.tableName2: Filter } } | { $exists: { \"**.tableName3\": Filter } }\n";
-        const SP_WILDCARD = "**";
-        let existsKeys = Object.keys(data)
-            .filter(k => exports.EXISTS_KEYS.includes(k) && Object.keys(data[k] || {}).length)
-            .map(key => {
-            const isJoined = exports.EXISTS_KEYS.slice(-2).includes(key);
-            let firstKey = Object.keys(data[key])[0], tables = firstKey.split("."), f2 = data[key][firstKey], shortestJoin = false;
-            if (!isJoined) {
-                if (tables.length !== 1)
-                    throw "Expecting single table in exists filter. Example: { $exists: { tableName: Filter } }";
-            }
-            else {
-                /* First part can be the ** param meaning shortest join. Will be overriden by anything in tableConfig */
-                if (!tables.length)
-                    throw ERR + "\nBut got: " + data[key];
-                if (tables[0] === SP_WILDCARD) {
-                    tables = tables.slice(1);
-                    shortestJoin = true;
-                }
-            }
-            return {
-                key,
-                existType: key,
-                isJoined,
-                shortestJoin,
-                f2,
-                tables
-            };
-        });
-        /* Exists with exact path */
-        // Object.keys(data).map(k => {
-        //     let isthis = isPlainObject(data[k]) && !this.column_names.includes(k) && !k.split(".").find(kt => !this.dboBuilder.dbo[kt]);
-        //     if(isthis) {
-        //         existsKeys.push({
-        //             key: k,
-        //             notJoined: false,
-        //             exactPaths: k.split(".")
-        //         });
-        //     }
-        // });
-        let funcConds = [];
-        const funcFilterkeys = FILTER_FUNCS.filter(f => {
-            return f.name in data;
-        });
-        funcFilterkeys.map(f => {
-            const funcArgs = data[f.name];
-            if (!Array.isArray(funcArgs))
-                throw `A function filter must contain an array. E.g: { $funcFilterName: ["col1"] } \n but got: ${JSON.stringify((0, PubSubManager_1.pickKeys)(data, [f.name]))} `;
-            const fields = this.parseFieldFilter(f.getFields(funcArgs), true, allowed_colnames);
-            const dissallowedCols = fields.filter(fname => !allowed_colnames.includes(fname));
-            if (dissallowedCols.length) {
-                throw `Invalid/disallowed columns found in function filter: ${dissallowedCols}`;
-            }
-            funcConds.push(f.getQuery({ args: funcArgs, allColumns: this.columns, allowedFields: allowed_colnames, tableAlias }));
-        });
-        let existsCond = "";
-        if (existsKeys.length) {
-            existsCond = (await Promise.all(existsKeys.map(async (k) => await this.prepareExistCondition(k, localParams)))).join(" AND ");
-        }
-        /* Computed field queries */
-        const p = this.getValidatedRules(tableRules, localParams);
-        const computedFields = p.allColumns.filter(c => c.type === "computed");
-        let computedColConditions = [];
-        Object.keys(data || {}).map(key => {
-            const compCol = computedFields.find(cf => cf.name === key);
-            if (compCol) {
-                computedColConditions.push(compCol.getQuery({
-                    tableAlias,
-                    allowedFields: p.select.fields,
-                    allColumns: this.columns,
-                    /* CTID not available in AFTER trigger */
-                    // ctidField: this.is_view? undefined : "ctid"
-                    ctidField: undefined,
-                }) + ` = ${exports.pgp.as.format("$1", [data[key]])}`);
-                delete data[key];
-            }
-        });
-        let allowedSelect = [];
-        /* Select aliases take precedence over col names. This is to ensure filters work correctly and even on computed cols*/
-        if (select) {
-            /* Allow filtering by selected fields/funcs */
-            allowedSelect = select.filter(s => {
-                /*  */
-                if (["function", "computed", "column"].includes(s.type)) {
-                    if (s.type !== "column" || allowed_colnames.includes(s.alias)) {
-                        return true;
-                    }
-                }
-                return false;
-            });
-        }
-        /* Add remaining allowed fields */
-        allowedSelect = allowedSelect.concat(p.allColumns.filter(c => allowed_colnames.includes(c.name) &&
-            !allowedSelect.find(s => s.alias === c.name)).map(f => ({
-            type: f.type,
-            alias: f.name,
-            getQuery: (tableAlias) => f.getQuery({
-                tableAlias,
-                allColumns: this.columns,
-                allowedFields: allowed_colnames
-            }),
-            selected: false,
-            getFields: () => [f.name],
-            column_udt_type: f.type === "column" ? this.columns.find(c => c.name === f.name)?.udt_name : undefined
-        })));
-        /* Parse complex filters
-            { $filter: [{ $func: [...] }, "=", value | { $func: [..] }] }
-        */
-        const complexFilters = [];
-        const complexFilterKey = "$filter";
-        const allowedComparators = [">", "<", "=", "<=", ">=", "<>", "!="];
-        if (complexFilterKey in data) {
-            const getFuncQuery = (funcData) => {
-                const { funcName, args } = (0, QueryBuilder_1.parseFunctionObject)(funcData);
-                const funcDef = (0, QueryBuilder_1.parseFunction)({ func: funcName, args, functions: QueryBuilder_1.FUNCTIONS, allowedFields: allowed_colnames });
-                return funcDef.getQuery({ args, tableAlias, allColumns: this.columns, allowedFields: allowed_colnames });
-            };
-            const complexFilter = data[complexFilterKey];
-            if (!Array.isArray(complexFilter))
-                throw `Invalid $filter. Must contain an array of at least element but got: ${JSON.stringify(complexFilter)} `;
-            const leftFilter = complexFilter[0];
-            const comparator = complexFilter[1];
-            const rightFilterOrValue = complexFilter[2];
-            const leftVal = getFuncQuery(leftFilter);
-            let result = leftVal;
-            if (comparator) {
-                if (!allowedComparators.includes(comparator))
-                    throw `Invalid $filter. comparator ${JSON.stringify(comparator)} is not valid. Expecting one of: ${allowedComparators}`;
-                if (!rightFilterOrValue)
-                    throw "Invalid $filter. Expecting a value or function after the comparator";
-                const rightVal = (0, prostgles_types_1.isObject)(rightFilterOrValue) ? getFuncQuery(rightFilterOrValue) : (0, PubSubManager_1.asValue)(rightFilterOrValue);
-                if (leftVal === rightVal)
-                    throw "Invalid $filter. Cannot compare two identical function signatures: " + JSON.stringify(leftFilter);
-                result += ` ${comparator} ${rightVal}`;
-            }
-            complexFilters.push(result);
-        }
-        /* Parse join filters
-            { $joinFilter: { $ST_DWithin: [table.col, foreignTable.col, distance] }
-            will make an exists filter
-        */
-        let filterKeys = Object.keys(data).filter(k => k !== complexFilterKey && !funcFilterkeys.find(ek => ek.name === k) && !computedFields.find(cf => cf.name === k) && !existsKeys.find(ek => ek.key === k));
-        // if(allowed_colnames){
-        //     const aliasedColumns = (select || []).filter(s => 
-        //         ["function", "computed", "column"].includes(s.type) && allowed_colnames.includes(s.alias) ||  
-        //         s.getFields().find(f => allowed_colnames.includes(f))
-        //     ).map(s => s.alias);
-        //     const validCols = [...allowed_colnames, ...aliasedColumns];
-        // }
-        const validFieldNames = allowedSelect.map(s => s.alias);
-        const invalidColumn = filterKeys
-            .find(fName => !validFieldNames.find(c => c === fName ||
-            (fName.startsWith(c) && (fName.slice(c.length).includes("->") ||
-                fName.slice(c.length).includes(".")))));
-        if (invalidColumn) {
-            throw `Table: ${this.name} -> disallowed/inexistent columns in filter: ${invalidColumn} \n  Expecting one of: ${allowedSelect.map(s => s.type === "column" ? s.getQuery() : s.alias).join(", ")}`;
-        }
-        /* TODO: Allow filter funcs */
-        // const singleFuncs = FUNCTIONS.filter(f => f.singleColArg);
-        const f = (0, PubSubManager_1.pickKeys)(data, filterKeys);
-        const q = (0, Filtering_1.parseFilterItem)({
-            filter: f,
-            tableAlias,
-            pgp: exports.pgp,
-            select: allowedSelect
-        });
-        let templates = [q].filter(q => q);
-        if (existsCond)
-            templates.push(existsCond);
-        templates = templates.concat(funcConds);
-        templates = templates.concat(computedColConditions);
-        templates = templates.concat(complexFilters);
-        /*  sorted to ensure duplicate subscription channels are not created due to different condition order */
-        return templates.sort()
-            .join(" AND \n");
-    }
-    /* This relates only to SELECT */
-    prepareSortItems(orderBy, allowed_cols, tableAlias, select) {
-        const throwErr = () => {
-            throw "\nInvalid orderBy option -> " + JSON.stringify(orderBy) +
-                "Expecting: \
-                        { key2: false, key1: true } \
-                        { key1: 1, key2: -1 } \
-                        [{ key1: true }, { key2: false }] \
-                        [{ key: 'colName', asc: true, nulls: 'first', nullEmpty: true }]";
-        }, parseOrderObj = (orderBy, expectOne = false) => {
-            if (!isPlainObject(orderBy))
-                return throwErr();
-            const keys = Object.keys(orderBy);
-            if (keys.length && keys.find(k => ["key", "asc", "nulls", "nullEmpty"].includes(k))) {
-                const { key, asc, nulls, nullEmpty = false } = orderBy;
-                if (!["string"].includes(typeof key) ||
-                    !["boolean"].includes(typeof asc) ||
-                    !["first", "last", undefined, null].includes(nulls) ||
-                    !["boolean"].includes(typeof nullEmpty)) {
-                    throw `Invalid orderBy option (${JSON.stringify(orderBy, null, 2)}) \n 
-                            Expecting { key: string, asc?: boolean, nulls?: 'first' | 'last' | null | undefined, nullEmpty?: boolean } `;
-                }
-                return [{ key, asc, nulls, nullEmpty }];
-            }
-            if (expectOne && keys.length > 1) {
-                throw "\nInvalid orderBy " + JSON.stringify(orderBy) +
-                    "\nEach orderBy array element cannot have more than one key";
-            }
-            /* { key2: true, key1: false } */
-            if (!Object.values(orderBy).find(v => ![true, false].includes(v))) {
-                return keys.map(key => ({ key, asc: Boolean(orderBy[key]) }));
-                /* { key2: -1, key1: 1 } */
-            }
-            else if (!Object.values(orderBy).find(v => ![-1, 1].includes(v))) {
-                return keys.map(key => ({ key, asc: orderBy[key] === 1 }));
-                /* { key2: "asc", key1: "desc" } */
-            }
-            else if (!Object.values(orderBy).find(v => !["asc", "desc"].includes(v))) {
-                return keys.map(key => ({ key, asc: orderBy[key] === "asc" }));
-            }
-            else
-                return throwErr();
-        };
-        if (!orderBy)
-            return [];
-        let _ob = [];
-        if (isPlainObject(orderBy)) {
-            _ob = parseOrderObj(orderBy);
-        }
-        else if (typeof orderBy === "string") {
-            /* string */
-            _ob = [{ key: orderBy, asc: true }];
-        }
-        else if (Array.isArray(orderBy)) {
-            /* Order by is formed of a list of ascending field names */
-            let _orderBy = orderBy;
-            if (_orderBy && !_orderBy.find(v => typeof v !== "string")) {
-                /* [string] */
-                _ob = _orderBy.map(key => ({ key, asc: true }));
-            }
-            else if (_orderBy.find(v => isPlainObject(v) && Object.keys(v).length)) {
-                _ob = _orderBy.map(v => parseOrderObj(v, true)[0]);
-            }
-            else
-                return throwErr();
-        }
-        else
-            return throwErr();
-        if (!_ob || !_ob.length)
-            return [];
-        const validatedAggAliases = select.filter(s => s.type !== "joinedColumn" &&
-            (!s.fields.length || s.fields.every(f => allowed_cols.includes(f)))).map(s => s.alias);
-        let bad_param = _ob.find(({ key }) => !(validatedAggAliases || []).includes(key) &&
-            !allowed_cols.includes(key));
-        if (!bad_param) {
-            const selectedAliases = select.filter(s => s.selected).map(s => s.alias);
-            // return (excludeOrder? "" : " ORDER BY ") + (_ob.map(({ key, asc, nulls, nullEmpty = false }) => {
-            return _ob.map(({ key, asc, nulls, nullEmpty = false }) => {
-                /* Order by column index when possible to bypass name collision when ordering by a computed column.
-                    (Postgres will sort by existing columns wheundefined possible)
-                */
-                const orderType = asc ? " ASC " : " DESC ";
-                const index = selectedAliases.indexOf(key) + 1;
-                const nullOrder = nulls ? ` NULLS ${nulls === "first" ? " FIRST " : " LAST "}` : "";
-                let colKey = (index > 0 && !nullEmpty) ? index : [tableAlias, key].filter(prostgles_types_1.isDefined).map(prostgles_types_1.asName).join(".");
-                if (nullEmpty) {
-                    colKey = `nullif(trim(${colKey}::text), '')`;
-                }
-                const res = `${colKey} ${orderType} ${nullOrder}`;
-                if (typeof colKey === "number") {
-                    return {
-                        asc,
-                        fieldPosition: colKey
-                    };
-                }
-                return {
-                    fieldQuery: colKey,
-                    asc,
-                };
-            });
-        }
-        else {
-            throw "Invalid/disallowed orderBy fields or params: " + bad_param.key;
-        }
-    }
-    /* This relates only to SELECT */
-    prepareLimitQuery(limit = 1000, p) {
-        if (limit !== undefined && limit !== null && !Number.isInteger(limit)) {
-            throw "Unexpected LIMIT. Must be null or an integer";
-        }
-        let _limit = limit;
-        // if(_limit === undefined && p.select.maxLimit === null){
-        //     _limit = 1000;
-        /* If no limit then set as the lesser of (100, maxLimit) */
-        // } else 
-        if (_limit !== null && !Number.isInteger(_limit) && p.select.maxLimit !== null) {
-            _limit = [100, p.select.maxLimit].filter(Number.isInteger).sort((a, b) => a - b)[0];
-        }
-        else {
-            /* If a limit higher than maxLimit specified throw error */
-            if (Number.isInteger(p.select.maxLimit) && _limit > p.select.maxLimit) {
-                throw `Unexpected LIMIT ${_limit}. Must be less than the published maxLimit: ` + p.select.maxLimit;
-            }
-        }
-        return _limit;
-    }
-    /* This relates only to SELECT */
-    prepareOffsetQuery(offset) {
-        if (Number.isInteger(offset)) {
-            return offset;
-        }
-        return 0;
-    }
-    intersectColumns(allowedFields, dissallowedFields, fixIssues = false) {
-        let result = [];
-        if (allowedFields) {
-            result = this.parseFieldFilter(allowedFields);
-        }
-        if (dissallowedFields) {
-            const _dissalowed = this.parseFieldFilter(dissallowedFields);
-            if (!fixIssues) {
-                throw `dissallowed/invalid field found for ${this.name}: `;
-            }
-            result = result.filter(key => !_dissalowed.includes(key));
-        }
-        return result;
-    }
-    /**
-    * Prepare and validate field object:
-    * @example ({ item_id: 1 }, { user_id: 32 }) => { item_id: 1, user_id: 32 }
-    * OR
-    * ({ a: 1 }, { b: 32 }, ["c", "d"]) => throw "a field is not allowed"
-    * @param {Object} obj - initial data
-    * @param {Object} forcedData - set/override property
-    * @param {string[]} allowed_cols - allowed columns (excluding forcedData) from table rules
-    */
-    prepareFieldValues(obj = {}, forcedData = {}, allowed_cols, fixIssues = false) {
-        let column_names = this.column_names.slice(0);
-        if (!column_names || !column_names.length)
-            throw "table column_names mising";
-        let _allowed_cols = column_names.slice(0);
-        let _obj = { ...obj };
-        if (allowed_cols) {
-            _allowed_cols = this.parseFieldFilter(allowed_cols, false);
-        }
-        let final_filter = { ..._obj }, filter_keys = Object.keys(final_filter);
-        if (fixIssues && filter_keys.length) {
-            final_filter = {};
-            filter_keys
-                .filter(col => _allowed_cols.includes(col))
-                .map(col => {
-                final_filter[col] = _obj[col];
-            });
-        }
-        /* If has keys check against allowed_cols */
-        if (final_filter && Object.keys(final_filter).length && _allowed_cols) {
-            validateObj(final_filter, _allowed_cols);
-        }
-        if (forcedData && Object.keys(forcedData).length) {
-            final_filter = { ...final_filter, ...forcedData };
-        }
-        validateObj(final_filter, column_names.slice(0));
-        return final_filter;
-    }
-    parseFieldFilter(fieldParams = "*", allow_empty = true, allowed_cols) {
-        return ViewHandler._parseFieldFilter(fieldParams, allow_empty, allowed_cols || this.column_names.slice(0));
-    }
-    /**
-    * Filter string array
-    * @param {FieldFilter} fieldParams - { col1: 0, col2: 0 } | { col1: true, col2: true } | "*" | ["key1", "key2"] | []
-    * @param {boolean} allow_empty - allow empty select. defaults to true
-    */
-    static _parseFieldFilter(fieldParams = "*", allow_empty = true, all_cols) {
-        if (!all_cols)
-            throw "all_cols missing";
-        const all_fields = all_cols; // || this.column_names.slice(0);
-        let colNames = [], initialParams = JSON.stringify(fieldParams);
-        if (fieldParams) {
-            /*
-                "field1, field2, field4" | "*"
-            */
-            if (typeof fieldParams === "string") {
-                fieldParams = fieldParams.split(",").map(k => k.trim());
-            }
-            /* string[] */
-            if (Array.isArray(fieldParams) && !fieldParams.find(f => typeof f !== "string")) {
-                /*
-                    ["*"]
-                */
-                if (fieldParams[0] === "*") {
-                    return all_fields.slice(0);
-                    /*
-                        [""]
-                    */
-                }
-                else if (fieldParams[0] === "") {
-                    if (allow_empty) {
-                        return [""];
-                    }
-                    else {
-                        throw "Empty value not allowed";
-                    }
-                    /*
-                        ["field1", "field2", "field3"]
-                    */
-                }
-                else {
-                    colNames = fieldParams.slice(0);
-                }
-                /*
-                    { field1: true, field2: true } = only field1 and field2
-                    { field1: false, field2: false } = all fields except field1 and field2
-                */
-            }
-            else if (isPlainObject(fieldParams)) {
-                if (!(0, prostgles_types_1.getKeys)(fieldParams).length) {
-                    return []; //all_fields.slice(0) as typeof all_fields;
-                }
-                let keys = (0, prostgles_types_1.getKeys)(fieldParams);
-                if (keys[0] === "") {
-                    if (allow_empty) {
-                        return [""];
-                    }
-                    else {
-                        throw "Empty value not allowed";
-                    }
-                }
-                validate(keys);
-                keys.forEach(key => {
-                    const allowedVals = [true, false, 0, 1];
-                    if (!allowedVals.includes(fieldParams[key]))
-                        throw `Invalid field selection value for: { ${key}: ${fieldParams[key]} }. \n Allowed values: ${allowedVals.join(" OR ")}`;
-                });
-                let allowed = keys.filter(key => fieldParams[key]), disallowed = keys.filter(key => !fieldParams[key]);
-                if (disallowed && disallowed.length) {
-                    return all_fields.filter(col => !disallowed.includes(col));
-                }
-                else {
-                    return [...allowed];
-                }
-            }
-            else {
-                throw " Unrecognised field filter.\nExpecting any of:   string | string[] | { [field]: boolean } \n Received ->  " + initialParams;
-            }
-            validate(colNames);
-        }
-        return colNames;
-        function validate(cols) {
-            let bad_keys = cols.filter(col => !all_fields.includes(col));
-            if (bad_keys && bad_keys.length) {
-                throw "\nUnrecognised or illegal fields: " + bad_keys.join(", ");
-            }
-        }
-    }
-}
-exports.ViewHandler = ViewHandler;
-function isPojoObject(obj) {
-    if (obj && (typeof obj !== "object" || Array.isArray(obj) || obj instanceof Date)) {
-        return false;
-    }
-    return true;
-}
-exports.isPojoObject = isPojoObject;
-class TableHandler extends ViewHandler {
-    constructor(db, tableOrViewInfo, dboBuilder, t, dbTX, joinPaths) {
-        super(db, tableOrViewInfo, dboBuilder, t, dbTX, joinPaths);
-        this.insertDataParse = insertDataParse_1.insertDataParse;
-        this.prepareReturning = async (returning, allowedFields) => {
-            let result = [];
-            if (returning) {
-                let sBuilder = new QueryBuilder_1.SelectItemBuilder({
-                    allFields: this.column_names.slice(0),
-                    allowedFields,
-                    allowedOrderByFields: allowedFields,
-                    computedFields: QueryBuilder_1.COMPUTED_FIELDS,
-                    functions: QueryBuilder_1.FUNCTIONS.filter(f => f.type === "function" && f.singleColArg),
-                    isView: this.is_view,
-                    columns: this.columns,
-                });
-                await sBuilder.parseUserSelect(returning);
-                return sBuilder.select;
-            }
-            return result;
-        };
-        this.remove = this.delete;
-        this.io_stats = {
-            since: Date.now(),
-            queries: 0,
-            throttle_queries_per_sec: 500,
-            batching: null
-        };
-        this.is_view = false;
-        this.is_media = dboBuilder.prostgles.isMedia(this.name);
-    }
-    /* TO DO: Maybe finished query batching */
-    willBatch(query) {
-        const now = Date.now();
-        if (this.io_stats.since < Date.now()) {
-            this.io_stats.since = Date.now();
-            this.io_stats.queries = 0;
-        }
-        else {
-            this.io_stats.queries++;
-        }
-        if (this.io_stats.queries > this.io_stats.throttle_queries_per_sec) {
-            return true;
-        }
-    }
-    async subscribe(filter, params = {}, localFunc, table_rules, localParams) {
-        try {
-            if (this.is_view)
-                throw "Cannot subscribe to a view";
-            if (this.t)
-                throw "subscribe not allowed within transactions";
-            if (!localParams && !localFunc)
-                throw " missing data. provide -> localFunc | localParams { socket } ";
-            if (localParams && localParams.socket && localFunc) {
-                console.error({ localParams, localFunc });
-                throw " Cannot have localFunc AND socket ";
-            }
-            const { filterFields, forcedFilter } = (0, utils_1.get)(table_rules, "select") || {}, filterOpts = await this.prepareWhere({ filter, forcedFilter, addKeywords: false, filterFields, tableAlias: undefined, localParams, tableRule: table_rules }), condition = filterOpts.where, throttle = (0, utils_1.get)(params, "throttle") || 0, selectParams = (0, PubSubManager_1.omitKeys)(params || {}, ["throttle"]);
-            // const { subOne = false } = localParams || {};
-            const filterSize = JSON.stringify(filter || {}).length;
-            if (filterSize * 4 > 2704) {
-                throw "filter too big. Might exceed the btree version 4 maximum 2704";
-            }
-            if (!localFunc) {
-                if (!this.dboBuilder.prostgles.isSuperUser)
-                    throw "Subscribe not possible. Must be superuser to add triggers 1856";
-                return await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, localParams)
-                    .then(async (isValid) => {
-                    const { socket } = localParams ?? {};
-                    const pubSubManager = await this.dboBuilder.getPubSubManager();
-                    return pubSubManager.addSub({
-                        table_info: this.tableOrViewInfo,
-                        socket,
-                        table_rules,
-                        condition: condition,
-                        func: undefined,
-                        filter: { ...filter },
-                        params: { ...selectParams },
-                        socket_id: socket?.id,
-                        table_name: this.name,
-                        throttle,
-                        last_throttled: 0,
-                        // subOne
-                    }).then(channelName => ({ channelName }));
-                });
-            }
-            else {
-                const pubSubManager = await this.dboBuilder.getPubSubManager();
-                pubSubManager.addSub({
-                    table_info: this.tableOrViewInfo,
-                    socket: undefined,
-                    table_rules,
-                    condition,
-                    func: localFunc,
-                    filter: { ...filter },
-                    params: { ...selectParams },
-                    socket_id: undefined,
-                    table_name: this.name,
-                    throttle,
-                    last_throttled: 0,
-                    // subOne
-                }).then(channelName => ({ channelName }));
-                const unsubscribe = async () => {
-                    const pubSubManager = await this.dboBuilder.getPubSubManager();
-                    pubSubManager.removeLocalSub(this.name, condition, localFunc);
-                };
-                let res = Object.freeze({ unsubscribe });
-                return res;
-            }
-        }
-        catch (e) {
-            if (localParams && localParams.testRule)
-                throw e;
-            throw parseError(e, `dbo.${this.name}.subscribe()`);
-        }
-    }
-    subscribeOne(filter, params = {}, localFunc, table_rules, localParams) {
-        let func = localParams ? undefined : (rows) => localFunc(rows[0]);
-        return this.subscribe(filter, { ...params, limit: 2 }, func, table_rules, localParams);
-    }
-    async updateBatch(data, params, tableRules, localParams) {
-        try {
-            const queries = await Promise.all(data.map(async ([filter, data]) => await this.update(filter, data, { ...(params || {}), returning: undefined }, tableRules, { ...(localParams || {}), returnQuery: true })));
-            const keys = (data && data.length) ? Object.keys(data[0]) : [];
-            return this.db.tx(t => {
-                const _queries = queries.map(q => t.none(q));
-                return t.batch(_queries);
-            }).catch(err => makeErr(err, localParams, this, keys));
-        }
-        catch (e) {
-            if (localParams && localParams.testRule)
-                throw e;
-            throw parseError(e, `dbo.${this.name}.update()`);
-        }
-    }
-    async parseUpdateRules(filter, newData, params, tableRules, localParams) {
-        const { testRule = false } = localParams ?? {};
-        if (!testRule) {
-            if (!newData || !Object.keys(newData).length)
-                throw "no update data provided\nEXPECTING db.table.update(filter, updateData, options)";
-            this.checkFilter(filter);
-        }
-        let forcedFilter = {}, forcedData = {}, validate, returningFields = "*", filterFields = "*", fields = "*";
-        let finalUpdateFilter = { ...filter };
-        if (tableRules) {
-            if (!tableRules.update)
-                throw "update rules missing for " + this.name;
-            ({ forcedFilter, forcedData, fields, filterFields, validate } = tableRules.update);
-            returningFields = tableRules.update.returningFields ?? (0, utils_1.get)(tableRules, "select.fields") ?? "";
-            if (!returningFields && params?.returning) {
-                throw "You are not allowed to return any fields from the update";
-            }
-            if (!fields)
-                throw ` Invalid update rule fo r ${this.name}. fields missing `;
-            finalUpdateFilter = (await this.prepareWhere({ filter, forcedFilter, filterFields, localParams, tableRule: tableRules })).filter;
-            if (tableRules.update.dynamicFields?.length) {
-                /**
-                 * dynamicFields.fields used to allow a custom list of fields for specific records
-                 * dynamicFields.filter cannot overlap each other
-                 * updates must target records from a specific dynamicFields.filter or not match any dynamicFields.filter
-                 */
-                if (testRule) {
-                    for await (const [dfIndex, dfRule] of tableRules.update.dynamicFields.entries()) {
-                        const condition = await this.getCondition({ allowed_colnames: this.column_names, filter: dfRule.filter });
-                        if (!condition)
-                            throw "dynamicFields.filter cannot be empty: " + JSON.stringify(dfRule);
-                        await this.find(dfRule.filter, { limit: 0 });
-                        /** Ensure dynamicFields filters do not overlap */
-                        for await (const [_dfIndex, _dfRule] of tableRules.update.dynamicFields.entries()) {
-                            if (dfIndex !== _dfIndex) {
-                                if (await this.findOne({ $and: [dfRule.filter, _dfRule.filter] }, { select: "" })) {
-                                    throw `dynamicFields.filter cannot overlap each other. \n
-                                    Overlapping dynamicFields rules:
-                                        ${JSON.stringify(dfRule)} 
-                                        AND
-                                        ${JSON.stringify(_dfRule)} 
-                                    `;
-                                }
-                            }
-                        }
-                    }
-                }
-                /** Pick dynamicFields.fields if matching filter */
-                let matchedRule;
-                for await (const dfRule of tableRules.update.dynamicFields) {
-                    const match = await this.findOne({ $and: [finalUpdateFilter, dfRule.filter].filter(prostgles_types_1.isDefined) });
-                    if (match) {
-                        /** Ensure it doesn't overlap with other dynamicFields.filter */
-                        if (matchedRule) {
-                            throw "Your update is targeting multiple tableRules.update.dynamicFields. Restrict update filter to only target one rule";
-                        }
-                        matchedRule = dfRule;
-                        fields = dfRule.fields;
-                    }
-                }
-            }
-            /* Safely test publish rules */
-            if (testRule) {
-                await this.validateViewRules({ fields, filterFields, returningFields, forcedFilter, dynamicFields: tableRules.update.dynamicFields, rule: "update" });
-                if (forcedData) {
-                    try {
-                        const { data, allowedCols } = this.validateNewData({ row: forcedData, forcedData: undefined, allowedFields: "*", tableRules, fixIssues: false });
-                        const updateQ = await this.colSet.getUpdateQuery(data, allowedCols, this.dbTX || this.dboBuilder.dbo, validate ? ((row) => validate({ update: row, filter: {} }, this.dbTX || this.dboBuilder.dbo)) : undefined); //pgp.helpers.update(data, columnSet)
-                        let query = updateQ + " WHERE FALSE ";
-                        await this.db.any("EXPLAIN " + query);
-                    }
-                    catch (e) {
-                        throw " issue with forcedData: \nVALUE: " + JSON.stringify(forcedData, null, 2) + "\nERROR: " + e;
-                    }
-                }
-                return true;
-            }
-        }
-        /* Update all allowed fields (fields) except the forcedFilter (so that the user cannot change the forced filter values) */
-        let _fields = this.parseFieldFilter(fields);
-        /**
-         * A forced filter must be basic
-         */
-        if (forcedFilter) {
-            const _forcedFilterKeys = Object.keys(forcedFilter);
-            const nonFields = _forcedFilterKeys.filter(key => !this.column_names.includes(key));
-            if (nonFields.length)
-                throw "forcedFilter must be a basic filter ( { col_name: 'value' } ). Invalid filter keys: " + nonFields;
-            // const clashingFields = _forcedFilterKeys.filter(key => _fields.includes(key));
-        }
-        const validateRow = validate ? (row) => validate({ update: row, filter: finalUpdateFilter }, this.dbTX || this.dboBuilder.dbo) : undefined;
-        return {
-            fields: _fields,
-            validateRow,
-            finalUpdateFilter,
-            forcedData,
-            forcedFilter,
-            returningFields,
-            filterFields,
-        };
-    }
-    async update(filter, newData, params, tableRules, localParams) {
-        return update_1.update.bind(this)(filter, newData, params, tableRules, localParams);
-    }
-    ;
-    validateNewData({ row, forcedData, allowedFields, tableRules, fixIssues = false }) {
-        const synced_field = (0, utils_1.get)(tableRules ?? {}, "sync.synced_field");
-        /* Update synced_field if sync is on and missing */
-        if (synced_field && !row[synced_field]) {
-            row[synced_field] = Date.now();
-        }
-        let data = this.prepareFieldValues(row, forcedData, allowedFields, fixIssues);
-        const dataKeys = (0, prostgles_types_1.getKeys)(data);
-        dataKeys.map(col => {
-            this.dboBuilder.prostgles?.tableConfigurator?.checkColVal({ table: this.name, col, value: data[col] });
-            const colConfig = this.dboBuilder.prostgles?.tableConfigurator?.getColumnConfig(this.name, col);
-            if (colConfig && (0, prostgles_types_1.isObject)(colConfig) && "isText" in colConfig && data[col]) {
-                if (colConfig.lowerCased) {
-                    data[col] = data[col].toString().toLowerCase();
-                }
-                if (colConfig.trimmed) {
-                    data[col] = data[col].toString().trim();
-                }
-            }
-        });
-        return { data, allowedCols: this.columns.filter(c => dataKeys.includes(c.name)).map(c => c.name) };
-    }
-    async insert(rowOrRows, param2, param3_unused, tableRules, _localParams) {
-        return insert_1.insert.bind(this)(rowOrRows, param2, param3_unused, tableRules, _localParams);
-    }
-    makeReturnQuery(items) {
-        if (items?.length)
-            return " RETURNING " + items.map(s => s.getQuery() + " AS " + (0, prostgles_types_1.asName)(s.alias)).join(", ");
-        return "";
-    }
-    async delete(filter, params, param3_unused, table_rules, localParams) {
-        return delete_1._delete.bind(this)(filter, params, param3_unused, table_rules, localParams);
-    }
-    ;
-    remove(filter, params, param3_unused, tableRules, localParams) {
-        return this.delete(filter, params, param3_unused, tableRules, localParams);
-    }
-    async upsert(filter, newData, params, table_rules, localParams) {
-        try {
-            /* Do it within a transaction to ensure consisency */
-            if (!this.t) {
-                return this.dboBuilder.getTX(dbTX => _upsert(dbTX[this.name]));
-            }
-            else {
-                return _upsert(this);
-            }
-            async function _upsert(tblH) {
-                return tblH.find(filter, { select: "", limit: 1 }, undefined, table_rules, localParams)
-                    .then(exists => {
-                    if (exists && exists.length) {
-                        return tblH.update(filter, newData, params, table_rules, localParams);
-                    }
-                    else {
-                        return tblH.insert({ ...newData, ...filter }, params, undefined, table_rules, localParams);
-                    }
-                });
-            }
-        }
-        catch (e) {
-            if (localParams && localParams.testRule)
-                throw e;
-            throw parseError(e, `dbo.${this.name}.upsert()`);
-        }
-    }
-    ;
-    /* External request. Cannot sync from server */
-    async sync(filter, params, param3_unused, table_rules, localParams) {
-        if (!localParams)
-            throw "Sync not allowed within the same server code";
-        const { socket } = localParams;
-        if (!socket)
-            throw "INTERNAL ERROR: socket missing";
-        if (!table_rules || !table_rules.sync || !table_rules.select)
-            throw "INTERNAL ERROR: sync or select rules missing";
-        if (this.t)
-            throw "Sync not allowed within transactions";
-        const ALLOWED_PARAMS = ["select"];
-        const invalidParams = Object.keys(params || {}).filter(k => !ALLOWED_PARAMS.includes(k));
-        if (invalidParams.length)
-            throw "Invalid or dissallowed params found: " + invalidParams.join(", ");
-        try {
-            let { id_fields, synced_field, allow_delete } = table_rules.sync;
-            const syncFields = [...id_fields, synced_field];
-            if (!id_fields || !synced_field) {
-                const err = "INTERNAL ERROR: id_fields OR synced_field missing from publish";
-                console.error(err);
-                throw err;
-            }
-            id_fields = this.parseFieldFilter(id_fields, false);
-            let allowedSelect = this.parseFieldFilter((0, utils_1.get)(table_rules, "select.fields"), false);
-            if (syncFields.find(f => !allowedSelect.includes(f))) {
-                throw `INTERNAL ERROR: sync field missing from publish.${this.name}.select.fields`;
-            }
-            let select = this.getAllowedSelectFields((0, utils_1.get)(params || {}, "select") || "*", allowedSelect, false);
-            if (!select.length)
-                throw "Empty select not allowed";
-            /* Add sync fields if missing */
-            syncFields.map(sf => {
-                if (!select.includes(sf))
-                    select.push(sf);
-            });
-            /* Step 1: parse command and params */
-            return this.find(filter, { select, limit: 0 }, undefined, table_rules, localParams)
-                .then(async (isValid) => {
-                const { filterFields, forcedFilter } = (0, utils_1.get)(table_rules, "select") || {};
-                const condition = (await this.prepareWhere({ filter, forcedFilter, filterFields, addKeywords: false, localParams, tableRule: table_rules })).where;
-                // let final_filter = getFindFilter(filter, table_rules);
-                const pubSubManager = await this.dboBuilder.getPubSubManager();
-                return pubSubManager.addSync({
-                    table_info: this.tableOrViewInfo,
-                    condition,
-                    id_fields, synced_field,
-                    allow_delete,
-                    socket,
-                    table_rules,
-                    filter: { ...filter },
-                    params: { select }
-                }).then(channelName => ({ channelName, id_fields, synced_field }));
-            });
-        }
-        catch (e) {
-            if (localParams && localParams.testRule)
-                throw e;
-            throw parseError(e, `dbo.${this.name}.sync()`);
-        }
-        /*
-        REPLICATION
-
-            1 Sync proccess (NO DELETES ALLOWED):
-
-                Client sends:
-                    "sync-request"
-                    { min_id, max_id, count, max_synced }
-
-                    Server sends:
-                        "sync-pull"
-                        { from_synced }
-
-                    Client sends:
-                        "sync-push"
-                        { data } -> WHERE synced >= from_synced
-
-                    Server upserts:
-                        WHERE not exists synced = synced AND id = id
-                        UNTIL
-
-                    Server sends
-                        "sync-push"
-                        { data } -> WHERE synced >= from_synced
-            */
-    }
-}
-exports.TableHandler = TableHandler;
 const Prostgles_1 = require("./Prostgles");
 const DBSchemaBuilder_1 = require("./DBSchemaBuilder");
+const TableHandler_1 = require("./DboBuilder/TableHandler");
 class DboBuilder {
     constructor(prostgles) {
         this.schema = "public";
@@ -1915,7 +161,7 @@ class DboBuilder {
             return this.db.tx((t) => {
                 let dbTX = {};
                 this.tablesOrViews?.map(tov => {
-                    dbTX[tov.name] = new (tov.is_view ? ViewHandler : TableHandler)(this.db, tov, this, t, dbTX, this.joinPaths);
+                    dbTX[tov.name] = new (tov.is_view ? ViewHandler_1.ViewHandler : TableHandler_1.TableHandler)(this.db, tov, this, t, dbTX, this.joinPaths);
                 });
                 if (!dbTX.sql) {
                     dbTX.sql = this.runSQL;
@@ -2006,13 +252,13 @@ class DboBuilder {
             // Make joins graph
             this.joinGraph = {};
             this.joins.forEach(({ tables }) => {
-                var _b, _d;
+                var _b, _c;
                 let _t = tables.slice().sort(), t1 = _t[0], t2 = _t[1];
                 if (t1 === t2)
                     return;
                 (_b = this.joinGraph)[t1] ?? (_b[t1] = {});
                 this.joinGraph[t1][t2] = 1;
-                (_d = this.joinGraph)[t2] ?? (_d[t2] = {});
+                (_c = this.joinGraph)[t2] ?? (_c[t2] = {});
                 this.joinGraph[t2][t1] = 1;
             });
             const tables = Array.from(new Set(this.joins.flatMap(t => t.tables)));
@@ -2061,7 +307,7 @@ class DboBuilder {
                 Please provide a replacement keyword name using the $filter_keyName init option. 
                 Alternatively you can rename the table column\n`;
             }
-            this.dbo[tov.name] = new (tov.is_view ? ViewHandler : TableHandler)(this.db, tov, this, undefined, undefined, this.joinPaths);
+            this.dbo[tov.name] = new (tov.is_view ? ViewHandler_1.ViewHandler : TableHandler_1.TableHandler)(this.db, tov, this, undefined, undefined, this.joinPaths);
             if (this.joinPaths && this.joinPaths.find(jp => [jp.t1, jp.t2].includes(tov.name))) {
                 let table = tov.name;
                 const makeJoin = (isLeft = true, filter, select, options) => {
@@ -2267,18 +513,6 @@ async function getTablesForSchemaPostgresSQL(db, schema = "public") {
     });
     return res;
 }
-/**
-* Throw error if illegal keys found in object
-*/
-function validateObj(obj, allowedKeys) {
-    if (obj && Object.keys(obj).length) {
-        const invalid_keys = Object.keys(obj).filter(k => !allowedKeys.includes(k));
-        if (invalid_keys.length) {
-            throw "Invalid/Illegal fields found: " + invalid_keys.join(", ");
-        }
-    }
-    return obj;
-}
 function isPlainObject(o) {
     return Object(o) === o && Object.getPrototypeOf(o) === Object.prototype;
 }