sql-love 1.0.3 → 1.0.4

package/dist/src/SelectBuilder/SelectBuilder.js

@@ -1,810 +0,0 @@
-import Parser from '../Parser/Parser';
-import substrCount from '../substrCount/substrCount';
-const isNullish = v => v === undefined || v === null || v === false || isNaN(v);
-let defaultEngine = 'mysql';
-/**
- * Build a select query
- * Class Select
- */
-export default class SelectBuilder {
-    /**
-     * The list of values to bind to the query
-     * @private
-     */
-    _bindings = [];
-    /**
-     * The list of strings to come immediately after "SELECT"
-     * and before column names
-     * @private
-     */
-    _options = [];
-    /**
-     * The list of column names to select
-     * @private
-     */
-    _tables = [];
-    /**
-     * The list of tables in the FROM clause
-     * @private
-     */
-    _columns = [];
-    /**
-     * The list of JOIN strings to add
-     * @private
-     */
-    _joins = [];
-    /**
-     * The list of WHERE clauses to join with AND
-     * @private
-     */
-    _wheres = [];
-    /**
-     * The list of GROUP BY clauses to join with commas
-     * @private
-     */
-    _groupBys = [];
-    /**
-     * The list of HAVING clauses to join with AND
-     * @private
-     */
-    _havings = [];
-    /**
-     * The list of ORDER BY clauses to join with commas
-     * @private
-     */
-    _orderBys = [];
-    /**
-     * The LIMIT to use
-     * @private
-     */
-    _limit;
-    /**
-     * The OFFSET to use
-     * @private
-     */
-    _offset;
-    /**
-     * The page used to construct an OFFSET based on the LIMIT
-     * @private
-     */
-    _page;
-    /**
-     * Select constructor
-     * @param [sql]  A base SQL query to parse
-     * @param [bindings]  Placeholders to bind to the query
-     */
-    constructor(sql = null, bindings = null) {
-        if (sql) {
-            if (bindings) {
-                const keys = Object.keys(bindings);
-                const regexp = new RegExp(`:(${keys.join('|')})`, 'g');
-                sql = sql.replace(regexp, ($0, $1) => {
-                    this._bindings.push(bindings[$1]);
-                    return `__BOUND_${this._bindings.length - 1}__`;
-                });
-            }
-            new Parser(this).parse(sql);
-        }
-    }
-    /**
-     * Set the default database engine style (mssql, mysql, oracle, pg)
-     * @param engine
-     */
-    static setDefaultEngine(engine) {
-        defaultEngine = engine;
-        return SelectBuilder;
-    }
-    /**
-     * Get the SQL as a pretty-printed string alongside an array of bindings
-     * @param engine  The database engine style (mssql, mysql, oracle, pg)
-     * @return The SQL query as a string
-     */
-    compile({ engine = defaultEngine, bindingIndex = 1, } = {}) {
-        // build all the lines
-        const lines = [
-            'SELECT',
-            this._options.length ? `  ${this._options.join('\n  ')}` : null,
-            this._columns.length ? `  ${this._columns.join(',\n  ')}` : '  *\n',
-            `FROM ${this._tables.join(', ')}`,
-            this._joins.length ? this._joins.join('\n') : null,
-            this._wheres.length ? `WHERE ${this._wheres.join('\n  AND ')}` : null,
-            this._groupBys.length ? `GROUP BY ${this._groupBys.join(',\n  ')}` : null,
-            this._havings.length ? `HAVING ${this._havings.join('\n  AND ')}` : null,
-            this._orderBys.length ? `ORDER BY ${this._orderBys.join(',\n  ')}` : null,
-        ];
-        if (this._page > 0) {
-            const offset = (this._page - 1) * this._limit;
-            lines.push(this._compileOFFSET(engine, offset));
-            lines.push(this._compileLIMIT(engine, this._limit));
-        }
-        else {
-            if (this._offset) {
-                lines.push(this._compileOFFSET(engine, this._offset));
-            }
-            if (this._limit) {
-                lines.push(this._compileLIMIT(engine, this._limit));
-            }
-        }
-        const pretty = lines.filter(Boolean).join('\n').trim();
-        let replacer;
-        const bindings = [];
-        if (engine === 'pg') {
-            let idx = bindingIndex;
-            replacer = (_, $1) => {
-                bindings.push(this._bindings[$1]);
-                return '$' + idx++;
-            };
-        }
-        else {
-            replacer = (_, $1) => {
-                bindings.push(this._bindings[$1]);
-                return '?';
-            };
-        }
-        const sql = pretty.replace(/__BOUND_(\d+)__/g, replacer);
-        return { sql, bindings };
-    }
-    _compileLIMIT(engineStyle, limit) {
-        if (engineStyle === 'pg' || engineStyle === 'mysql') {
-            return `LIMIT ${limit}`;
-        }
-        else if (engineStyle === 'mssql') {
-            return `FETCH NEXT ${limit} ROWS ONLY`;
-        }
-    }
-    _compileOFFSET(engineStyle, offset) {
-        if (engineStyle === 'pg' || engineStyle === 'mysql') {
-            return `OFFSET ${offset}`;
-        }
-        else if (engineStyle === 'mssql' || engineStyle === 'oracle') {
-            return `OFFSET ${offset} ROWS`;
-        }
-    }
-    /**
-     * Get SQL needed to return the found rows of this query
-     * @param engineStyle  The database engine style (mssql, mysql, oracle, pg)
-     * @param countExpr  The expression to use inside the COUNT()
-     */
-    compileCount({ countExpr = '*', engine = defaultEngine, bindingIndex = 1, } = {}) {
-        const query = this.getFoundRowsQuery(countExpr);
-        const { sql, bindings } = query.compile({ engine, bindingIndex });
-        if (this._havings.length === 0) {
-            return { sql, bindings };
-        }
-        else {
-            const subquerySql = sql.replace(/\n/g, '\n\t');
-            return {
-                sql: `SELECT COUNT(*) AS found_rows\nFROM (\n${subquerySql}\n) AS subquery_results`,
-                bindings,
-            };
-        }
-    }
-    /**
-     * Get SQL needed to union this query with another
-     * @param query  The query to union
-     * @param engine  The database engine style (mssql, mysql, oracle, pg)
-     */
-    compileUnion(query, { engine = defaultEngine, bindingIndex = 1, } = {}) {
-        const first = this.compile({ engine, bindingIndex });
-        const second = query.compile({
-            engine,
-            bindingIndex: first.bindings.length + bindingIndex,
-        });
-        return {
-            sql: `(${first.sql})\nUNION\n(${second.sql})`,
-            bindings: [...first.bindings, ...second.bindings],
-        };
-    }
-    /**
-     * @param  [fieldOrFields]  If given, reset the given component(s), otherwise reset all query components
-     *   Valid components: option, column, table, where, orWhere, having, groupBy, orderBy, limit, offset, page
-     * @return This object
-     */
-    reset(fieldOrFields = null) {
-        if (Array.isArray(fieldOrFields)) {
-            fieldOrFields.forEach(name => this.reset(name));
-            return this;
-        }
-        if (fieldOrFields) {
-            const pluralizable = [
-                'option',
-                'column',
-                'table',
-                'where',
-                'having',
-                'groupBy',
-                'orderBy',
-            ];
-            let prop = '_' + fieldOrFields.replace(/s$/, '');
-            if (pluralizable.indexOf(fieldOrFields) > -1) {
-                prop += 's';
-            }
-            const isScalar = ['limit', 'offset', 'page'].indexOf(fieldOrFields) > -1;
-            this[prop] = isScalar ? null : [];
-        }
-        else {
-            this._options = [];
-            this._columns = [];
-            this._tables = [];
-            this._joins = [];
-            this._wheres = [];
-            this._groupBys = [];
-            this._havings = [];
-            this._orderBys = [];
-            this._limit = null;
-            this._offset = null;
-            this._page = null;
-            this._bindings = [];
-        }
-        return this;
-    }
-    /**
-     * Clone this builder object
-     */
-    getClone() {
-        const copy = new SelectBuilder();
-        copy._options = [...this._options];
-        copy._columns = [...this._columns];
-        copy._tables = [...this._tables];
-        copy._joins = [...this._joins];
-        copy._wheres = [...this._wheres];
-        copy._havings = [...this._havings];
-        copy._groupBys = [...this._groupBys];
-        copy._orderBys = [...this._orderBys];
-        copy._limit = this._limit;
-        copy._offset = this._offset;
-        copy._page = this._page;
-        copy._bindings = [...this._bindings];
-        return copy;
-    }
-    /**
-     * Build a version of this query that simply returns COUNT(*)
-     * @param [countExpr="*"]  Use to specify `DISTINCT colname` if needed
-     */
-    getFoundRowsQuery(countExpr = '*') {
-        if (this._havings.length === 0) {
-            const clone = this.getClone();
-            clone._columns = [`COUNT(${countExpr}) AS found_rows`];
-            clone._options = [];
-            clone._groupBys = [];
-            clone._orderBys = [];
-            clone._limit = null;
-            clone._offset = null;
-            clone._page = null;
-            return clone;
-        }
-        else {
-            const subquery = this.getClone();
-            subquery._limit = null;
-            subquery._offset = null;
-            subquery._page = null;
-            return subquery;
-        }
-    }
-    /**
-     * Add an array of column names to fetch
-     * @param columnNames  The names of columns
-     */
-    select(columnNames) {
-        this._columns = this._columns.concat(columnNames);
-        return this;
-    }
-    /**
-     * Add an array of column names to fetch
-     * @param columnNames  The names of columns
-     */
-    columns(columnNames) {
-        this._columns = this._columns.concat(columnNames);
-        return this;
-    }
-    /**
-     * Add a column name to fetch
-     * @param columnName  The name of the column
-     */
-    column(columnName) {
-        this._columns.push(columnName);
-        return this;
-    }
-    /**
-     * Add an option expression such as "TOP 10" or "SQL_CALC_FOUND_ROWS"
-     * @param optionExpression  Expression to go after "SELECT" and before column list
-     */
-    option(optionExpression) {
-        this._options.push(optionExpression);
-        return this;
-    }
-    /**
-     * Add a table to the "FROM" clause (same as .from())
-     * @param {String} tableName  The name of the table to query
-     * @return {Select}
-     */
-    table(tableName) {
-        this._tables.push(tableName);
-        return this;
-    }
-    /**
-     * Add multiple table to the "FROM" clause
-     * @param {Array} tableNames  The names of the tables to query
-     * @return {Select}
-     */
-    tables(tableNames) {
-        this._tables.push(...tableNames);
-        return this;
-    }
-    /**
-     * Add a table to the "FROM" clause (same as .table())
-     * @param {String} tableName  The name of the table to query
-     * @return {Select}
-     */
-    from(tableName) {
-        this._tables.push(tableName);
-        return this;
-    }
-    /**
-     * Add the given join type expression
-     * @param joinType  The type of join (e.g. "INNER JOIN", "LEFT JOIN", etc.)
-     * @param expression  The expression following the INNER JOIN keyword
-     * @param bindings  A list of values to bind to ? placeholders in the expression
-     * @example
-     *   query.join('posts p ON p.id = c.post_id');
-     *   query.join('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
-     */
-    _addJoin(joinType, expression, bindings = []) {
-        if (bindings.length > 0) {
-            expression = expression.replace(/\?/g, () => {
-                this._bindings.push(bindings.shift());
-                return `__BOUND_${this._bindings.length - 1}__`;
-            });
-        }
-        this._joins.push(`${joinType} ${expression}`);
-    }
-    /**
-     * Add a JOIN expression
-     * @param expression  The expression following the INNER JOIN keyword
-     * @param bindings  A list of values to bind to ? placeholders in the expression
-     * @example
-     *   query.join('posts p ON p.id = c.post_id');
-     *   query.join('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
-     */
-    join(expression, bindings = []) {
-        this._addJoin('JOIN', expression, bindings);
-        return this;
-    }
-    /**
-     * Add a LEFT JOIN expression
-     * @param expression  The expression following the LEFT JOIN keyword
-     * @param bindings  A list of values to bind to ? placeholders in the expression
-     * @example
-     *   query.leftJoin('posts p ON p.id = c.post_id');
-     *   query.leftJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
-     */
-    leftJoin(expression, bindings = []) {
-        this._addJoin('LEFT JOIN', expression, bindings);
-        return this;
-    }
-    /**
-     * Add a FULL JOIN expression
-     * @param expression  The expression following the FULL JOIN keyword
-     * @param bindings  A list of values to bind to ? placeholders in the expression
-     * @example
-     *   query.fullJoin('posts p ON p.id = c.post_id');
-     *   query.fullJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
-     */
-    fullJoin(expression, bindings = []) {
-        this._addJoin('FULL JOIN', expression, bindings);
-        return this;
-    }
-    /**
-     * Add a RIGHT JOIN expression
-     * @param expression  The expression following the RIGHT JOIN keyword
-     * @param bindings  A list of values to bind to ? placeholders in the expression
-     * @example
-     *   query.rightJoin('posts p ON p.id = c.post_id');
-     *   query.rightJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
-     */
-    rightJoin(expression, bindings = []) {
-        this._addJoin('RIGHT JOIN', expression, bindings);
-        return this;
-    }
-    /**
-     * Add a CROSS JOIN expression
-     * @param expression  The expression following the CROSS JOIN keyword
-     * @param bindings  A list of values to bind to ? placeholders in the expression
-     * @example
-     *   query.crossJoin('posts p ON p.id = c.post_id');
-     *   query.crossJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
-     */
-    crossJoin(expression, bindings = []) {
-        this._addJoin('CROSS JOIN', expression, bindings);
-        return this;
-    }
-    /**
-     * Add an INNER JOIN expression (same as ->join())
-     * @param expression  The expression following the INNER JOIN keyword
-     * @param bindings  A list of values to bind to ? placeholders in the expression
-     * @example
-     *   query.innerJoin('posts p ON p.id = c.post_id');
-     *   query.innerJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
-     */
-    innerJoin(expression, bindings = []) {
-        this._addJoin('INNER JOIN', expression, bindings);
-        return this;
-    }
-    /**
-     * Add a LEFT OUTER JOIN expression
-     * @param expression  The expression following the LEFT OUTER JOIN keyword
-     * @param bindings  A list of values to bind to ? placeholders in the expression
-     * @example
-     *   query.leftOuterJoin('posts p ON p.id = c.post_id');
-     *   query.leftOuterJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
-     */
-    leftOuterJoin(expression, bindings = []) {
-        this._addJoin('LEFT OUTER JOIN', expression, bindings);
-        return this;
-    }
-    /**
-     * Add a FULL OUTER JOIN expression
-     * @param expression  The expression following the FULL OUTER JOIN keyword
-     * @param bindings  A list of values to bind to ? placeholders in the expression
-     * @example
-     *   query.fullOuterJoin('posts p ON p.id = c.post_id');
-     *   query.fullOuterJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
-     */
-    fullOuterJoin(expression, bindings = []) {
-        this._addJoin('FULL OUTER JOIN', expression, bindings);
-        return this;
-    }
-    /**
-     * Add a RIGHT OUTER JOIN expression
-     * @param expression  The expression following the RIGHT OUTER JOIN keyword
-     * @param bindings  A list of values to bind to ? placeholders in the expression
-     * @example
-     *   query.rightOuterJoin('posts p ON p.id = c.post_id');
-     *   query.rightOuterJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
-     */
-    rightOuterJoin(expression, bindings = []) {
-        this._addJoin('RIGHT OUTER JOIN', expression, bindings);
-        return this;
-    }
-    /**
-     * Remove a join condition with the specified table
-     * @param table  The name of the table or tables in the first part of the join statement
-     */
-    unjoin(table) {
-        if (Array.isArray(table)) {
-            table.forEach(t => this.unjoin(t));
-            return this;
-        }
-        this._joins = this._joins.filter(join => {
-            const regex = new RegExp(`JOIN ${table}\\b`);
-            return !regex.test(join);
-        });
-        return this;
-    }
-    /**
-     * Utility function to add conditions for a clause (WHERE, HAVING)
-     * @param  collection  The collection to add the clauses to (e.g. this._wheres or this._havings)
-     * @param  criteria  Criteria adhering to WhereCriteria type
-     * @example  The following are equivalent
-     *   this._conditions(this._wheres, ['deleted_at IS NULL']);
-     *   this._conditions(this._wheres, ['deleted_at', null]);
-     *   this._conditions(this._wheres, ['deleted_at', '=', null]);
-     * @example  More examples
-     *   this._conditions(this._wheres, ['fname', 'LIKE', 'joe']); // `fname` LIKE 'joe'
-     *   this._conditions(this._wheres, ['fname', 'LIKE ?', 'joe']); // `fname` LIKE 'joe'
-     *   this._conditions(this._wheres, ['fname LIKE %?%', 'joe']); // `fname` LIKE '%joe%'
-     *   this._conditions(this._wheres, ['fname LIKE ?%', 'joe']); // `fname` LIKE 'joe%'
-     *   this._conditions(this._wheres, ['fname', 'LIKE ?%', 'joe']); // `fname` LIKE 'joe%'
-     *   this._conditions(this._wheres, ['price >', 10]); // `price` > 10
-     *   this._conditions(this._wheres, ['price', '>', 10]); // `price` > 10
-     *   this._conditions(this._wheres, ['price =', 10]); // `price` = 10
-     *   this._conditions(this._wheres, ['price !=', 10]); // `price` != 10
-     *   this._conditions(this._wheres, ['price', 10]); // `price` = 10
-     *   this._conditions(this._wheres, ['price', '=', 10]); // `price` = 10
-     *   this._conditions(this._wheres, ['price', '!=', 10]); // `price` != 10
-     *   this._conditions(this._wheres, ['price', 'BETWEEN', [10,20]]); // `price` BETWEEN 10 AND 20
-     *   this._conditions(this._wheres, ['price', 'NOT BETWEEN', [10,20]]); // `price` NOT BETWEEN 10 AND 20
-     *   this._conditions(this._wheres, ['price', [10,20]]); // `price` IN(10,20)
-     *   this._conditions(this._wheres, ['price', '=', [10,20]]); // `price` IN(10,20)
-     *   this._conditions(this._wheres, ['price', 'IN', [10,20]]); // `price` IN(10,20)
-     *   this._conditions(this._wheres, ['price', 'NOT IN', [10,20]]); // `price` NOT IN(10,20)
-     */
-    _conditions(collection, criteria) {
-        const numArgs = criteria.length;
-        let [column, operator, value] = criteria;
-        if (typeof column === 'object') {
-            for (const keyValue of Object.entries(column)) {
-                this._conditions(collection, keyValue);
-            }
-            return this;
-        }
-        if (numArgs === 1) {
-            // condition is a stand-alone expression
-            // e.g. "SUM(price) > 10"
-            collection.push(column);
-            return this;
-        }
-        else if (numArgs === 2 &&
-            Array.isArray(operator) &&
-            operator.length > 0 &&
-            substrCount(column, '?') === operator.length) {
-            // column is a string with question marks and operator is an array of replacements
-            // e.g. query.where('SUBSTR(prefs, ?, ?) = role', [1, 4]);
-            const values = operator;
-            const sql = column.replace(/\?/g, () => {
-                this._bindings.push(values.shift());
-                return `__BOUND_${this._bindings.length - 1}__`;
-            });
-            collection.push(sql);
-            return this;
-        }
-        else if (numArgs === 2) {
-            // condition has pairs of "column + operator" => "value"
-            // e.g. ["price >", 10]
-            // e.g. ["status LIKE ?%", 10]
-            value = operator;
-            const parts = column.split(' ');
-            column = parts.shift();
-            operator = parts.join(' ');
-        }
-        if (typeof operator !== 'string' || operator === '') {
-            operator = '=';
-        }
-        operator = operator.toLocaleUpperCase();
-        const likeMatch = operator.match(/^(LIKE|NOT LIKE|ILIKE|NOT ILIKE)(?: (\?|\?%|%\?|%\?%))?$/i);
-        if (operator === 'NOT BETWEEN' || operator === 'BETWEEN') {
-            // expect a two-item array
-            const one = this._bindings.length;
-            const two = this._bindings.length + 1;
-            collection.push(`${column} ${operator} __BOUND_${one}__ AND __BOUND_${two}__`);
-            this._bindings.push(value[0], value[1]);
-        }
-        else if (likeMatch) {
-            const like = likeMatch[1].toUpperCase(); // Either "LIKE", "NOT LIKE" etc.
-            const infix = likeMatch[2] || '?'; // ONE OF ?% or %?% or %? or ?
-            if (Array.isArray(value)) {
-                const ors = [];
-                for (const v of value) {
-                    ors.push(`${column} ${like} __BOUND_${this._bindings.length}__`);
-                    this._bindings.push(infix.replace('?', v));
-                }
-                const joined = ors.join(' OR ');
-                collection.push(`(${joined})`);
-            }
-            else {
-                collection.push(`${column} ${like} __BOUND_${this._bindings.length}__`);
-                this._bindings.push(infix.replace('?', value || ''));
-            }
-        }
-        else if (value === null) {
-            collection.push(operator === '=' ? `${column} IS NULL` : `${column} IS NOT NULL`);
-        }
-        else if (Array.isArray(value)) {
-            // an array of values should be IN or NOT IN
-            const inVals = [];
-            for (let i = 0; i < value.length; i++) {
-                inVals.push(`__BOUND_${this._bindings.length}__`);
-                this._bindings.push(value[i]);
-            }
-            const joined = inVals.join(', ');
-            collection.push(operator === '=' || operator === 'IN'
-                ? `${column} IN(${joined})`
-                : `${column} NOT IN(${joined})`);
-        }
-        else if (operator === 'IN' || operator === 'NOT IN') {
-            // in clause that is not array
-            collection.push(`${column} ${operator}(__BOUND_${this._bindings.length}__)`);
-            this._bindings.push(value);
-        }
-        else {
-            collection.push(`${column} ${operator} __BOUND_${this._bindings.length}__`);
-            this._bindings.push(value);
-        }
-        return this;
-    }
-    /**
-     * Add a group by column or expression
-     * @param column  The name of a column (or expression) to group by
-     */
-    groupBy(column) {
-        this._groupBys.push(column);
-        return this;
-    }
-    /**
-     * Add WHERE clauses to conditions (See _conditions for usage)
-     */
-    where(...args) {
-        this._conditions(this._wheres, args);
-        return this;
-    }
-    /**
-     * Add a WHERE clause with a BETWEEN condition
-     * @param column  The column name
-     * @param twoValueArray  The two values to be between
-     */
-    whereBetween(column, twoValueArray) {
-        if (!isNullish(twoValueArray[0]) && !isNullish(twoValueArray[1])) {
-            this.where(column, 'BETWEEN', twoValueArray);
-        }
-        else if (!isNullish(twoValueArray[0]) && isNullish(twoValueArray[1])) {
-            this.where(column, '>=', twoValueArray[0]);
-        }
-        else if (isNullish(twoValueArray[0]) && !isNullish(twoValueArray[1])) {
-            this.where(column, '<=', twoValueArray[1]);
-        }
-        else {
-            // both are nullish! omit expression
-        }
-        return this;
-    }
-    /**
-     * Add a series of WHERE clauses joined by OR (See _conditions for usage)
-     * @param conditions
-     */
-    _orConditions(conditions) {
-        const items = [];
-        if (Array.isArray(conditions)) {
-            for (const condition of conditions) {
-                if (Array.isArray(condition)) {
-                    this._conditions(items, condition);
-                }
-                else {
-                    this._conditions(items, [condition]);
-                }
-            }
-        }
-        else {
-            for (const [key, value] of Object.entries(conditions)) {
-                const one = [];
-                this._conditions(one, [key, value]);
-                items.push(one[0]);
-            }
-        }
-        const joined = items.join(' OR ');
-        if (joined.startsWith('(') && joined.endsWith(')')) {
-            // start/end paraens will be added by orWhere() or orHaving()
-            return joined.slice(1, -1);
-        }
-        else {
-            return joined;
-        }
-    }
-    /**
-     * Add WHERE conditions to place inside an OR block (See _conditions for usage)
-     * @param conditions  A list or object where each item is an array with parameters that would be taken by where()
-     */
-    orWhere(conditions) {
-        const joined = this._orConditions(conditions);
-        this.where(`(${joined})`);
-        return this;
-    }
-    /**
-     * Add an OR with conditions under the HAVING clause
-     * @param conditions  A list or object where each item is an array with parameters that would be taken by having()
-     */
-    orHaving(conditions) {
-        const joined = this._orConditions(conditions);
-        this.having(`(${joined})`);
-        return this;
-    }
-    /**
-     * Add a HAVING condition (See _conditions for usage)
-     */
-    having(...args) {
-        this._conditions(this._havings, args);
-        return this;
-    }
-    /**
-     * Add a column or expression to order by
-     * @param column  The column name or expression to sort by. Include DESC or prefix with - to sort descending
-     * @param [direction]  The direction to sort by (ASC or DESC)
-     * @example
-     *   query.sortField('modified_at'); // ORDER BY modified_at
-     *   query.sortField('-modified_at'); // ORDER BY modified_at DESC
-     *   query.sortField('COUNT(*)'); // ORDER BY COUNT(*)
-     *   query.sortField('COUNT(*) DESC'); // ORDER BY COUNT(*) DESC
-     */
-    orderBy(column, direction = null) {
-        if (direction) {
-            this._orderBys.push(`${column} ${direction}`);
-        }
-        else {
-            const expression = column.replace(/^-(.+)/, '$1 DESC');
-            this._orderBys.push(expression);
-        }
-        return this;
-    }
-    /**
-     * Sort by the given column, with a map of columns to translate
-     * @param fieldName  The file name such as "created_at" or "-created_at" for descending
-     * @param [mapNames]  Column names to translate from field to column expression
-     * @example
-     *   query.sortField('-modified_at'); // ORDER BY modified_at DESC
-     *   query.sortField('-created', {'created': 'created_at'}); // ORDER BY created_at DESC
-     */
-    sortField(fieldName, mapNames = {}) {
-        let direction = 'ASC';
-        if (fieldName.startsWith('-')) {
-            direction = 'DESC';
-            fieldName = fieldName.slice(1);
-        }
-        const column = mapNames[fieldName] || fieldName;
-        this.orderBy(column, direction);
-        return this;
-    }
-    /**
-     * Check to see if the given string is 0 or all digits not starting with 0
-     * @param string  The input string
-     * @private
-     */
-    _isEntirelyDigits(string) {
-        return /^(0|[1-9]\d*)$/.test(string);
-    }
-    /**
-     * Check to see if the given string is all digits
-     * @param string  The input string
-     * @private
-     */
-    _isEntirelyDigitsNoZeros(string) {
-        return /^[1-9]\d*$/.test(string);
-    }
-    /**
-     * Limit results to the given number
-     * @param max  The number to limit by (placeholder string or integer greater than 0)
-     */
-    limit(max) {
-        if (typeof max === 'string') {
-            max = max.trim();
-            if (this._isEntirelyDigitsNoZeros(max)) {
-                // is entirely digits (no leading zeros)
-                this._limit = parseInt(max, 10);
-            }
-        }
-        else if (typeof max === 'number' && Number.isInteger(max) && max >= 1) {
-            this._limit = max;
-        }
-        else {
-            throw new Error(`SelectBuilder: "limit(n)" must receive a positive integer (got "${max}")`);
-        }
-        return this;
-    }
-    /**
-     * Fetch results from the given offset
-     * @param number  The offset (placeholder string or integer greater than or equal to 0)
-     */
-    offset(number) {
-        if (typeof number === 'string' && this._isEntirelyDigits(number.trim())) {
-            // is entirely digits (or zero)
-            this._offset = parseInt(number, 10);
-        }
-        else if (typeof number === 'number' &&
-            Number.isInteger(number) &&
-            number >= 0) {
-            this._offset = number;
-        }
-        else {
-            throw new Error(`SelectBuilder: "offset(n)" must receive a positive integer (got "${number}")`);
-        }
-        return this;
-    }
-    /**
-     * Set the offset based on the limit with the given page number
-     * @param number  The page number (integer greater than 0)
-     */
-    page(number) {
-        if (typeof number === 'string' &&
-            this._isEntirelyDigitsNoZeros(number.trim())) {
-            // is entirely digits (or zero)
-            this._page = parseInt(number, 10);
-        }
-        else if (typeof number === 'number' &&
-            Number.isInteger(number) &&
-            number >= 1) {
-            this._page = number;
-        }
-        else {
-            throw new Error('SelectBuilder: "page(n)" must receive a positive integer');
-        }
-        return this;
-    }
-}