prostgles-server 4.0.57 → 4.0.59

package/lib/DboBuilder/QueryBuilder/QueryBuilder.d.ts

@@ -1,73 +0,0 @@
-import { Filter, LocalParams, SortItem } from "../../DboBuilder";
-import { TableRule } from "../../PublishParser";
-import { SelectParams, ColumnInfo, PG_COLUMN_UDT_DATA_TYPE, Select, JoinSelect } from "prostgles-types";
-import { TableHandler } from "../TableHandler";
-import { FieldSpec, FunctionSpec } from "./Functions";
-import { ViewHandler } from "../ViewHandler";
-export type SelectItem = {
-    type: "column" | "function" | "aggregation" | "joinedColumn" | "computed";
-    getFields: (args?: any[]) => string[] | "*";
-    getQuery: (tableAlias?: string) => string;
-    columnPGDataType?: string;
-    column_udt_type?: PG_COLUMN_UDT_DATA_TYPE;
-    alias: string;
-    selected: boolean;
-};
-export type SelectItemValidated = SelectItem & {
-    fields: string[];
-};
-export type NewQuery = {
-    /**
-     * All fields from the table will be in nested SELECT and GROUP BY to allow order/filter by fields not in select
-     */
-    allFields: string[];
-    /**
-     * Contains user selection and all the allowed columns. Allowed columns not selected are marked with  selected: false
-     */
-    select: SelectItem[];
-    table: string;
-    where: string;
-    whereOpts: Awaited<ReturnType<ViewHandler["prepareWhere"]>>;
-    orderByItems: SortItem[];
-    having: string;
-    limit: number;
-    offset: number;
-    isLeftJoin: boolean;
-    joins?: NewQuery[];
-    tableAlias?: string;
-    $path?: string[];
-};
-export declare const asNameAlias: (field: string, tableAlias?: string) => string;
-export declare const parseFunctionObject: (funcData: any) => {
-    funcName: string;
-    args: any[];
-};
-export declare class SelectItemBuilder {
-    select: SelectItemValidated[];
-    private allFields;
-    private allowedFields;
-    private allowedOrderByFields;
-    private computedFields;
-    private functions;
-    private allowedFieldsIncludingComputed;
-    private isView;
-    private columns;
-    constructor(params: {
-        allowedFields: string[];
-        allowedOrderByFields: string[];
-        computedFields: FieldSpec[];
-        functions: FunctionSpec[];
-        allFields: string[];
-        isView: boolean;
-        columns: ColumnInfo[];
-    });
-    private checkField;
-    private addItem;
-    private addFunction;
-    addColumn: (fieldName: string, selected: boolean) => void;
-    parseUserSelect: (userSelect: Select, joinParse?: (key: string, val: JoinSelect, throwErr: (msg: string) => any) => any) => Promise<any[]>;
-}
-export declare function getNewQuery(_this: TableHandler, filter: Filter, selectParams: (SelectParams & {
-    alias?: string;
-}), param3_unused: any, tableRules: TableRule | undefined, localParams: LocalParams | undefined, columns: ColumnInfo[]): Promise<NewQuery>;
-//# sourceMappingURL=QueryBuilder.d.ts.map

package/lib/DboBuilder/QueryBuilder/QueryBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryBuilder.d.ts","sourceRoot":"","sources":["QueryBuilder.ts"],"names":[],"mappings":"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"}

package/lib/DboBuilder/QueryBuilder/QueryBuilder.js

@@ -1,335 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Stefan L. All rights reserved.
- *  Licensed under the MIT License. See LICENSE in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNewQuery = exports.SelectItemBuilder = exports.parseFunctionObject = exports.asNameAlias = void 0;
-const DboBuilder_1 = require("../../DboBuilder");
-const prostgles_types_1 = require("prostgles-types");
-const utils_1 = require("../../utils");
-const Functions_1 = require("./Functions");
-const asNameAlias = (field, tableAlias) => {
-    const result = (0, prostgles_types_1.asName)(field);
-    if (tableAlias)
-        return (0, prostgles_types_1.asName)(tableAlias) + "." + result;
-    return result;
-};
-exports.asNameAlias = asNameAlias;
-const parseFunctionObject = (funcData) => {
-    const makeErr = (msg) => `Function not specified correctly. Expecting { $funcName: ["columnName",...] } object but got: ${JSON.stringify(funcData)} \n ${msg}`;
-    if (!(0, prostgles_types_1.isObject)(funcData))
-        throw makeErr("");
-    const keys = (0, prostgles_types_1.getKeys)(funcData);
-    if (keys.length !== 1)
-        throw makeErr("");
-    const funcName = keys[0];
-    const args = funcData[funcName];
-    if (!args || !Array.isArray(args)) {
-        throw makeErr("Arguments missing or invalid");
-    }
-    return { funcName, args };
-};
-exports.parseFunctionObject = parseFunctionObject;
-class SelectItemBuilder {
-    select = [];
-    allFields;
-    allowedFields;
-    allowedOrderByFields;
-    computedFields;
-    functions;
-    allowedFieldsIncludingComputed;
-    isView;
-    columns;
-    constructor(params) {
-        this.allFields = params.allFields;
-        this.allowedFields = params.allowedFields;
-        this.allowedOrderByFields = params.allowedOrderByFields;
-        this.computedFields = params.computedFields;
-        this.isView = params.isView;
-        this.functions = params.functions;
-        this.columns = params.columns;
-        this.allowedFieldsIncludingComputed = this.allowedFields.concat(this.computedFields ? this.computedFields.map(cf => cf.name) : []);
-        if (!this.allowedFields.length) {
-            throw "allowedFields empty/missing";
-        }
-        /* Check for conflicting computed column names */
-        const conflictingCol = this.allFields.find(fieldName => this.computedFields.find(cf => cf.name === fieldName));
-        if (conflictingCol) {
-            throw "INTERNAL ERROR: Cannot have duplicate column names ( " + conflictingCol + " ). One or more computed column names are colliding with table columns ones";
-        }
-    }
-    checkField = (f, isSelected) => {
-        const allowedSelectedFields = this.allowedFieldsIncludingComputed;
-        const allowedNonSelectedFields = [...this.allowedFieldsIncludingComputed, ...this.allowedOrderByFields];
-        /** Not selected items can be part of the orderBy fields */
-        const allowedFields = isSelected ? allowedSelectedFields : allowedNonSelectedFields;
-        if (!allowedFields.includes(f)) {
-            throw "Field " + f + " is invalid or dissallowed. \nAllowed fields: " + allowedFields.join(", ");
-        }
-        return f;
-    };
-    addItem = (item) => {
-        let fields = item.getFields();
-        // console.trace(fields)
-        if (fields === "*")
-            fields = this.allowedFields.slice(0);
-        fields.map(f => this.checkField(f, item.selected));
-        if (this.select.find(s => s.alias === item.alias)) {
-            throw `Cannot specify duplicate columns ( ${item.alias} ). Perhaps you're using "*" with column names?`;
-        }
-        this.select.push({ ...item, fields });
-    };
-    addFunction = (func, args, alias) => {
-        const funcDef = (0, Functions_1.parseFunction)({
-            func, args, functions: this.functions,
-            allowedFields: this.allowedFieldsIncludingComputed,
-        });
-        this.addItem({
-            type: funcDef.type,
-            alias,
-            getFields: () => funcDef.getFields(args),
-            getQuery: (tableAlias) => funcDef.getQuery({ allColumns: this.columns, allowedFields: this.allowedFields, args, tableAlias,
-                ctidField: undefined,
-                /* CTID not available in AFTER trigger */
-                // ctidField: this.isView? undefined : "ctid" 
-            }),
-            selected: true
-        });
-    };
-    addColumn = (fieldName, selected) => {
-        /* Check if computed col */
-        if (selected) {
-            const compCol = Functions_1.COMPUTED_FIELDS.find(cf => cf.name === fieldName);
-            if (compCol && !this.select.find(s => s.alias === fieldName)) {
-                const cf = {
-                    ...compCol,
-                    type: "computed",
-                    numArgs: 0,
-                    singleColArg: false,
-                    getFields: (_args) => []
-                };
-                this.addFunction(cf, [], compCol.name);
-                return;
-            }
-        }
-        const colDef = this.columns.find(c => c.name === fieldName);
-        const alias = selected ? fieldName : ("not_selected_" + fieldName);
-        this.addItem({
-            type: "column",
-            columnPGDataType: colDef?.data_type,
-            column_udt_type: colDef?.udt_name,
-            alias,
-            getQuery: () => (0, prostgles_types_1.asName)(fieldName),
-            getFields: () => [fieldName],
-            selected
-        });
-    };
-    parseUserSelect = async (userSelect, joinParse) => {
-        /* [col1, col2, col3] */
-        if (Array.isArray(userSelect)) {
-            if (userSelect.find(key => typeof key !== "string"))
-                throw "Invalid array select. Expecting an array of strings";
-            userSelect.map(key => this.addColumn(key, true));
-            /* Empty select */
-        }
-        else if (userSelect === "") {
-            return [];
-        }
-        else if (userSelect === "*") {
-            this.allowedFields.map(key => this.addColumn(key, true));
-        }
-        else if ((0, DboBuilder_1.isPlainObject)(userSelect) && !(0, prostgles_types_1.isEmpty)(userSelect)) {
-            const selectKeys = Object.keys(userSelect), selectValues = Object.values(userSelect);
-            /* Cannot include and exclude at the same time */
-            if (selectValues.filter(v => [0, false].includes(v)).length) {
-                if (selectValues.filter(v => ![0, false].includes(v)).length) {
-                    throw "\nCannot include and exclude fields at the same time";
-                }
-                /* Exclude only */
-                this.allowedFields.filter(f => !selectKeys.includes(f)).map(key => this.addColumn(key, true));
-            }
-            else {
-                await Promise.all(selectKeys.map(async (key) => {
-                    const val = userSelect[key], throwErr = (extraErr = "") => {
-                        console.trace(extraErr);
-                        throw "Unexpected select -> " + JSON.stringify({ [key]: val }) + "\n" + extraErr;
-                    };
-                    /* Included fields */
-                    if ([1, true].includes(val)) {
-                        if (key === "*") {
-                            this.allowedFields.map(key => this.addColumn(key, true));
-                        }
-                        else {
-                            this.addColumn(key, true);
-                        }
-                        /* Aggs and functions */
-                    }
-                    else if (typeof val === "string" || (0, prostgles_types_1.isObject)(val)) {
-                        /* Function shorthand notation
-                            { id: "$max" } === { id: { $max: ["id"] } } === SELECT MAX(id) AS id
-                        */
-                        if ((typeof val === "string" && val !== "*") ||
-                            (0, DboBuilder_1.isPlainObject)(val) && Object.keys(val).length === 1 && Array.isArray(Object.values(val)[0]) // !isPlainObject(Object.values(val)[0])
-                        ) {
-                            // if(!Array.isArray(Object.values(val)[0])){
-                            //   throw `Could not parse selected item: ${JSON.stringify(val)}\nFunction arguments must be in an array`;
-                            // }
-                            let funcName, args;
-                            if (typeof val === "string") {
-                                /* Shorthand notation -> it is expected that the key is the column name used as the only argument */
-                                try {
-                                    this.checkField(key, true);
-                                }
-                                catch (err) {
-                                    throwErr(` Shorthand function notation error: the specifield column ( ${key} ) is invalid or dissallowed. \n Use correct column name or full aliased function notation, e.g.: -> { alias: { $func_name: ["column_name"] } } `);
-                                }
-                                funcName = val;
-                                args = [key];
-                                /** Function full notation { $funcName: ["colName", ...args] } */
-                            }
-                            else {
-                                ({ funcName, args } = (0, exports.parseFunctionObject)(val));
-                            }
-                            this.addFunction(funcName, args, key);
-                            /* Join */
-                        }
-                        else {
-                            if (!joinParse) {
-                                throw "Joins dissalowed";
-                            }
-                            await joinParse(key, val, throwErr);
-                        }
-                    }
-                    else
-                        throwErr();
-                }));
-            }
-        }
-        else
-            throw "Unexpected select -> " + JSON.stringify(userSelect);
-    };
-}
-exports.SelectItemBuilder = SelectItemBuilder;
-async function getNewQuery(_this, filter, selectParams = {}, param3_unused = null, tableRules, localParams, columns) {
-    if (localParams?.isRemoteRequest && !tableRules?.select?.fields) {
-        throw `INTERNAL ERROR: publish.${_this.name}.select.fields rule missing`;
-    }
-    const allowedOrderByFields = !tableRules ? _this.column_names.slice(0) : _this.parseFieldFilter(tableRules?.select?.orderByFields ?? tableRules?.select?.fields);
-    const allowedSelectFields = !tableRules ? _this.column_names.slice(0) : _this.parseFieldFilter(tableRules?.select?.fields);
-    const joinQueries = [];
-    const { select: userSelect = "*" } = selectParams, sBuilder = new SelectItemBuilder({
-        allowedFields: allowedSelectFields,
-        allowedOrderByFields,
-        computedFields: Functions_1.COMPUTED_FIELDS,
-        isView: _this.is_view,
-        functions: Functions_1.FUNCTIONS,
-        allFields: _this.column_names.slice(0),
-        columns
-    });
-    await sBuilder.parseUserSelect(userSelect, async (key, val, throwErr) => {
-        const j_selectParams = {};
-        let j_filter = {}, j_isLeftJoin = true, j_path, j_alias, j_tableRules, j_table;
-        if (val === "*") {
-            j_selectParams.select = "*";
-            j_alias = key;
-            j_table = key;
-        }
-        else {
-            /* Full option join  { field_name: db.innerJoin.table_name(filter, select)  } */
-            const JOIN_KEYS = ["$innerJoin", "$leftJoin"];
-            const JOIN_PARAMS = ["select", "filter", "$path", "$condition", "offset", "limit", "orderBy"];
-            const joinKeys = Object.keys(val).filter(k => JOIN_KEYS.includes(k));
-            if (joinKeys.length > 1) {
-                throwErr("\nCannot specify more than one join type ( $innerJoin OR $leftJoin )");
-            }
-            else if (joinKeys.length === 1) {
-                const invalidParams = Object.keys(val).filter(k => ![...JOIN_PARAMS, ...JOIN_KEYS].includes(k));
-                if (invalidParams.length) {
-                    throw "Invalid join params: " + invalidParams.join(", ");
-                }
-                j_isLeftJoin = joinKeys[0] === "$leftJoin";
-                j_table = val[joinKeys[0]];
-                j_alias = key;
-                if (typeof j_table !== "string") {
-                    throw "\nIssue with select. \nJoin type must be a string table name but got -> " + JSON.stringify({ [key]: val });
-                }
-                j_selectParams.select = val.select || "*";
-                j_filter = val.filter || {};
-                j_selectParams.limit = val.limit;
-                j_selectParams.offset = val.offset;
-                j_selectParams.orderBy = val.orderBy;
-                j_path = val.$path;
-            }
-            else {
-                j_selectParams.select = val;
-                j_alias = key;
-                j_table = key;
-            }
-        }
-        if (!j_table) {
-            throw "j_table missing";
-        }
-        const _thisJoinedTable = _this.dboBuilder.dbo[j_table];
-        if (!_thisJoinedTable) {
-            throw `Joined table ${JSON.stringify(j_table)} is disallowed or inexistent \nOr you've forgot to put the function arguments into an array`;
-        }
-        let isLocal = true;
-        if (localParams && (localParams.socket || localParams.httpReq)) {
-            isLocal = false;
-            j_tableRules = await _this.dboBuilder.publishParser?.getValidatedRequestRuleWusr({ tableName: j_table, command: "find", localParams });
-        }
-        if (isLocal || j_tableRules) {
-            const joinQuery = await getNewQuery(_thisJoinedTable, j_filter, { ...j_selectParams, alias: j_alias }, param3_unused, j_tableRules, localParams, columns);
-            joinQuery.isLeftJoin = j_isLeftJoin;
-            joinQuery.tableAlias = j_alias;
-            joinQuery.$path = j_path;
-            joinQueries.push(joinQuery);
-            // console.log(joinQuery)
-        }
-    });
-    /**
-     * Add non selected columns
-     * This ensures all fields are available for orderBy in case of nested select
-     * */
-    Array.from(new Set([...allowedSelectFields, ...allowedOrderByFields])).map(key => {
-        if (!sBuilder.select.find(s => s.alias === key && s.type === "column")) {
-            sBuilder.addColumn(key, false);
-        }
-    });
-    const select = sBuilder.select;
-    // const validatedAggAliases = select
-    //   .filter(s => s.type !== "joinedColumn")
-    //   .map(s => s.alias);
-    const filterOpts = await _this.prepareWhere({
-        filter,
-        select,
-        forcedFilter: (0, utils_1.get)(tableRules, "select.forcedFilter"),
-        filterFields: (0, utils_1.get)(tableRules, "select.filterFields"),
-        tableAlias: selectParams.alias,
-        localParams,
-        tableRule: tableRules
-    });
-    const where = filterOpts.where;
-    const p = _this.getValidatedRules(tableRules, localParams);
-    const resQuery = {
-        /** Why was this the case? */
-        // allFields: allowedSelectFields,
-        allFields: _this.column_names.slice(0),
-        select,
-        table: _this.name,
-        joins: joinQueries,
-        where,
-        whereOpts: filterOpts,
-        having: "",
-        isLeftJoin: false,
-        // having: cond.having,
-        limit: _this.prepareLimitQuery(selectParams.limit, p),
-        orderByItems: _this.prepareSortItems(selectParams.orderBy, allowedOrderByFields, selectParams.alias, select),
-        offset: _this.prepareOffsetQuery(selectParams.offset)
-    };
-    // console.log(resQuery);
-    // console.log(buildJoinQuery(_this, resQuery));
-    return resQuery;
-}
-exports.getNewQuery = getNewQuery;

package/lib/DboBuilder/QueryBuilder/makeSelectQuery.d.ts

@@ -1,8 +0,0 @@
-import { SelectParams } from "prostgles-types";
-import { NewQuery } from "./QueryBuilder";
-import { TableHandler } from "../TableHandler";
-/**
- * Creating the text query from the NewQuery spec
- * No validation/authorisation at this point */
-export declare function makeSelectQuery(_this: TableHandler, q: NewQuery, depth?: number, joinFields?: string[], selectParams?: SelectParams): string;
-//# sourceMappingURL=makeSelectQuery.d.ts.map

package/lib/DboBuilder/QueryBuilder/makeSelectQuery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"makeSelectQuery.d.ts","sourceRoot":"","sources":["makeSelectQuery.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAU,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAc,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C;;+CAE+C;AAC/C,wBAAgB,eAAe,CAC7B,KAAK,EAAE,YAAY,EACnB,CAAC,EAAE,QAAQ,EACX,KAAK,SAAI,EACT,UAAU,GAAE,MAAM,EAAO,EACzB,YAAY,GAAE,YAAiB,GAC9B,MAAM,CA2RR"}

package/lib/DboBuilder/QueryBuilder/makeSelectQuery.js

@@ -1,227 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSelectQuery = void 0;
-const DboBuilder_1 = require("../../DboBuilder");
-const prostgles_types_1 = require("prostgles-types");
-/**
- * Creating the text query from the NewQuery spec
- * No validation/authorisation at this point */
-function makeSelectQuery(_this, q, depth = 0, joinFields = [], selectParams = {}) {
-    const PREF = `prostgles`, joins = q.joins || [], 
-    // aggs = q.aggs || [],
-    getTableAlias = (q) => !q.tableAlias ? q.table : `${q.tableAlias || ""}_${q.table}`, getTableJoinAliasAsName = (joinAlias, table) => (0, prostgles_types_1.asName)(!joinAlias ? table : `${joinAlias || ""}_${table}`), getTableAliasAsName = (q) => (0, prostgles_types_1.asName)(getTableAlias(q));
-    const indentLine = (numberOfSpaces, str, indentStr = "    ") => new Array(numberOfSpaces).fill(indentStr).join("") + str;
-    const indentArray = (numberOfSpaces, strArr, indentStr = "    ") => strArr.map(str => indentLine(numberOfSpaces, str, indentStr));
-    const indentArrayAndJoin = (numberOfSpaces, strArr, separator = " \n ", indentStr = "    ") => indentArray(numberOfSpaces, strArr, indentStr).join(separator);
-    const appendCommas = (strArr) => strArr.map((s, i, arr) => s + (i < arr.length - 1 ? " , " : " "));
-    const createAlias = (q, str) => (0, prostgles_types_1.asName)(`${q.tableAlias || q.table}_${PREF}_${str}`);
-    // const indent = (a, b) => a;
-    const joinTables = (q1, q2) => {
-        const joinInfo = _this.getJoins(q1.table, q2.table, q2.$path, true);
-        const paths = joinInfo.paths;
-        let rowidSortedColName = "";
-        let rowidDupesColName = "";
-        let jsonColName = "";
-        let t2Alias = "";
-        let limitColName = "";
-        const t1Alias = q.table;
-        const queries = paths.flatMap(({ table, on }, i) => {
-            const getColName = (col, q) => {
-                if (table === q.table) {
-                    const colFromSelect = q.select.find(s => s.getQuery() === (0, prostgles_types_1.asName)(col));
-                    if (!colFromSelect) {
-                        console.error(`${col} column might be missing in user publish `);
-                        throw `Could not find join column (${col}) in allowe select. Some join tables and columns might be invalid/dissallowed`;
-                    }
-                    return colFromSelect.alias;
-                }
-                return col;
-            };
-            const getPrevColName = (col) => {
-                return getColName(col, q1);
-            };
-            const getThisColName = (col) => {
-                return getColName(col, q2);
-            };
-            // console.log(JSON.stringify({i, table, on, q1, q2}, null, 2));
-            const prevTable = i === 0 ? t1Alias : (paths[i - 1].table);
-            const thisAlias = getTableJoinAliasAsName(q2.tableAlias, table);
-            const prevAlias = i === 0 ? getTableAliasAsName(q1) : getTableJoinAliasAsName(q2.tableAlias, prevTable);
-            /* If root then prev table is aliased from root query. Alias from join otherwise  */
-            let iQ = [
-                (0, prostgles_types_1.asName)(table) + ` ${thisAlias}`
-            ];
-            /* If target table then add filters, options, etc */
-            if (i === paths.length - 1) {
-                const targetSelect = q2.select.filter(s => s.selected).map(s => {
-                    /* Rename aggs to avoid collision with join cols */
-                    if (s.type === "aggregation")
-                        return (0, prostgles_types_1.asName)(`agg_${s.alias}`) + " AS " + (0, prostgles_types_1.asName)(s.alias);
-                    return (0, prostgles_types_1.asName)(s.alias);
-                }).concat(q2.joins?.map(j => (0, prostgles_types_1.asName)(j.table)) ?? []).join(", ");
-                const leafSelect = makeSelectQuery(_this, q2, depth + 1, on.flatMap(cond => cond.map(([c1, c2]) => (0, prostgles_types_1.asName)(c2))), selectParams).split("\n");
-                t2Alias = thisAlias;
-                rowidSortedColName = createAlias(q2, `rowid_sorted`);
-                rowidDupesColName = createAlias(q2, `dupes_rowid`);
-                limitColName = createAlias(q2, `limit`);
-                jsonColName = createAlias(q2, `json`);
-                iQ = [
-                    "(",
-                    ...indentArray(depth + 1, [
-                        `-- 4. [target table] `,
-                        `SELECT *,`,
-                        `row_number() over() as ${rowidSortedColName},`,
-                        `row_to_json((select x from (SELECT ${targetSelect}) as x)) AS ${jsonColName}`,
-                        `FROM (`,
-                        ...indentArray(depth + 2, leafSelect),
-                        `) ${(0, prostgles_types_1.asName)(q2.table)}    `
-                    ]),
-                    `) ${thisAlias}`
-                ];
-            }
-            const getJoinCondition = (t1Alias, t2Alias, on) => {
-                return on.map(cond => cond.map(([c1, c2]) => `${t1Alias}.${(0, prostgles_types_1.asName)(getPrevColName(c1))} = ${t2Alias}.${(0, prostgles_types_1.asName)(getThisColName(c2))} `).join(" AND ")).join(" OR ");
-            };
-            const query = [
-                `${q2.isLeftJoin ? "LEFT" : "INNER"} JOIN `,
-                ...iQ,
-                `ON ${getJoinCondition(prevAlias, thisAlias, on)}`
-            ];
-            return { query, prevTable, thisAlias };
-        });
-        return { q: q2, query: queries.flatMap(q => q.query), t1Alias: q.table, t2Alias, rowidSortedColName: rowidSortedColName, jsonColName, rowidDupesColName, limitColName };
-    };
-    const getGroupBy = (rootSelectItems, groupByItems) => {
-        if (groupByItems.length) {
-            /** Root Select column index number is used where possible to prevent "non-integer constant in GROUP BY" error */
-            return `GROUP BY ` + groupByItems.map(gi => {
-                const idx = rootSelectItems.findIndex(si => si.alias === gi.alias);
-                if (idx < 0)
-                    throw `Could not find GROUP BY column ${gi.alias} in ROOT SELECT ${rootSelectItems.map(s => s.alias)}`;
-                return idx + 1;
-            }).join(", ");
-        }
-        return "";
-    };
-    /* Leaf query with no joins -> return simple query */
-    const aggs = q.select.filter(s => s.type === "aggregation");
-    const nonAggs = q.select.filter(s => depth || s.selected).filter(s => s.type !== "aggregation");
-    if (!joins.length) {
-        /* Nested queries contain all fields to allow joining */
-        let groupBy = "";
-        const rootSelectItems = q.select.filter(s => joinFields.includes(s.getQuery()) || s.selected);
-        /* If aggs exist need to set groupBy add joinFields into select */
-        if (aggs.length || selectParams?.groupBy) {
-            if (nonAggs.length) {
-                const groupByFields = nonAggs.filter(sf => !depth || joinFields.includes(sf.getQuery()));
-                groupBy = getGroupBy(rootSelectItems, groupByFields);
-            }
-        }
-        const simpleQuery = indentArrayAndJoin(depth, [
-            `-- 0. or 5. [leaf query] `
-            /* Group by selected fields + any join fields */
-            ,
-            `SELECT ` + rootSelectItems.map(s => {
-                // return s.getQuery() + ((s.type !== "column")? (" AS " + s.alias) : "")
-                if (s.type === "aggregation") {
-                    /* Rename aggs to avoid collision with join cols */
-                    return s.getQuery() + " AS " + (0, prostgles_types_1.asName)((depth ? "agg_" : "") + s.alias);
-                }
-                return s.getQuery() + " AS " + (0, prostgles_types_1.asName)(s.alias);
-            }).join(", "),
-            `FROM ${(0, prostgles_types_1.asName)(q.table)} `,
-            q.where,
-            groupBy //!aggs.length? "" : `GROUP BY ${nonAggs.map(sf => asName(sf.alias)).join(", ")}`,
-            ,
-            q.having ? `HAVING ${q.having}` : "",
-            (0, DboBuilder_1.prepareSort)(q.orderByItems),
-            !depth ? `LIMIT ${q.limit} ` : null,
-            !depth ? `OFFSET ${q.offset || 0} ` : null
-        ].filter(v => v && (v + "").trim().length));
-        // console.log(fres);
-        return simpleQuery;
-    }
-    else {
-        // if(q.aggs && q.aggs && q.aggs.length) throw "Cannot join an aggregate";
-        if (q.select.find(s => s.type === "aggregation") &&
-            joins.find(j => j.select.find(s => s.type === "aggregation")))
-            throw "Cannot join two aggregates";
-    }
-    if (joins && joins.length && (aggs.length || selectParams.groupBy))
-        throw "Joins within Aggs dissallowed";
-    // if(q.selectFuncs.length) throw "Functions within select not allowed in joins yet. -> " + q.selectFuncs.map(s => s.alias).join(", ");
-    const rootSelectItems = q.select.filter(s => depth || s.selected);
-    let rootGroupBy;
-    if ((selectParams.groupBy || aggs.length || q.joins && q.joins.length) && nonAggs.length) {
-        const groupByItems = (depth ?
-            q.allFields.map(f => (0, prostgles_types_1.asName)(f)) :
-            nonAggs.map(s => s.type === "function" ? s.getQuery() : (0, prostgles_types_1.asName)(s.alias))).concat((aggs?.length) ?
-            [] :
-            [`ctid`]).filter(s => s);
-        /** Add ORDER BY items not included in root select */
-        q.orderByItems.forEach(sortItem => {
-            if ("fieldQuery" in sortItem && !groupByItems.includes(sortItem.fieldQuery)) {
-                groupByItems.push(sortItem.fieldQuery);
-            }
-        });
-        rootGroupBy = `GROUP BY ${groupByItems.join(", ")} `;
-    }
-    const parsedJoins = joins.map(j => joinTables(q, j));
-    /* Joined query */
-    const joinedQuery = [
-        " \n",
-        `-- 0. [joined root]  `,
-        "SELECT    ",
-        ...appendCommas(rootSelectItems.map(s => s.getQuery() + " AS " + (0, prostgles_types_1.asName)(s.alias)).concat(parsedJoins.map((j, i) => {
-            /** Apply LIMIT to joined items */
-            const jsq = `json_agg(${j.jsonColName}::jsonb ORDER BY ${j.rowidSortedColName}) FILTER (WHERE ${j.limitColName} <= ${j.q.limit} AND ${j.rowidDupesColName} = 1 AND ${j.jsonColName} IS NOT NULL)`;
-            const resAlias = (0, prostgles_types_1.asName)(j.q.tableAlias || j.q.table);
-            /* If limit = 1 then return a single json object (first one) */
-            return (j.q.limit === 1 ? `${jsq}->0 ` : `COALESCE(${jsq}, '[]') `) + `  AS ${resAlias}`;
-        }))),
-        `FROM ( `,
-        ...indentArray(depth + 1, [
-            "-- 1. [subquery limit + dupes] ",
-            "SELECT     ",
-            ...appendCommas([`t1.*`].concat(parsedJoins.map((j, i) => {
-                return `row_number() over(partition by ${j.rowidDupesColName}, ` +
-                    `ctid order by ${j.rowidDupesColName}) AS ${j.limitColName}  `;
-            }))),
-            `FROM ( ----------- ${getTableAliasAsName(q)}`,
-            ...indentArray(depth + 1, [
-                "-- 2. [source full select + ctid to group by] ",
-                "SELECT ",
-                ...appendCommas(q.allFields.concat(["ctid"])
-                    .map(field => `${getTableAliasAsName(q)}.${(0, prostgles_types_1.asName)(field)}  `)
-                    .concat(parsedJoins.map((j, i) => j.t2Alias + "." + j.jsonColName + ", " +
-                    j.t2Alias + "." + j.rowidSortedColName + ", " +
-                    `row_number() over(partition by ` +
-                    `${j.t2Alias}.${j.rowidSortedColName}, ` +
-                    `${getTableAliasAsName(q)}.ctid ) AS ${j.rowidDupesColName}`))),
-                `FROM ( `,
-                ...indentArray(depth + 1, [
-                    "-- 3. [source table] ",
-                    "SELECT ",
-                    "*, row_number() over() as ctid ",
-                    `FROM ${(0, prostgles_types_1.asName)(q.table)} `,
-                    `${q.where} `
-                ]),
-                `) ${getTableAliasAsName(q)} `,
-                ...joins.flatMap((j, i) => joinTables(q, j).query)
-            ]),
-            ") t1"
-        ]),
-        ") t0",
-        rootGroupBy,
-        q.having ? `HAVING ${q.having} ` : "",
-        (0, DboBuilder_1.prepareSort)(q.orderByItems),
-        depth ? null : `LIMIT ${q.limit || 0} OFFSET ${q.offset || 0}`,
-        "-- EOF 0. joined root",
-        " \n"
-    ].filter(v => v);
-    const res = indentArrayAndJoin(depth, joinedQuery);
-    // res = indent(res, depth);
-    // console.log(res);
-    return res;
-}
-exports.makeSelectQuery = makeSelectQuery;