sql-love 0.9.1

package/dist/src/Parser/Parser.js

@@ -0,0 +1,304 @@
+/**
+ * Parse SQL and populate onto a Select query object
+ */
+export default class Parser {
+    query;
+    /**
+     * Create a new instance
+     * @param query  A Select object on which to build parsed conditions
+     */
+    constructor(query) {
+        this.query = query;
+    }
+    /**
+     * Strip single-line and multi-line comment blocks
+     * @param sql  The SQL string
+     * @return  The SQL string without comments
+     * @private
+     */
+    _stripComments(sql) {
+        // multiline comments
+        sql = sql.replace(/\/\*[\s\S]*?\*\//g, '');
+        // single line comments -- dashes
+        sql = sql.replace(/--([\r\n]|\s+[^\r\n]+[\r\n])/g, '');
+        // single line comments #hashes
+        sql = sql.replace(/#[^\r\n]+[\r\n]/g, '');
+        return sql;
+    }
+    /**
+     * Before splitting into SQL clauses, extract some regex-able subQueries
+     * @param sql  The unparsed sql string
+     * @return  An array with new sql and subQueries
+     * @private
+     */
+    _extractSubQueries(sql) {
+        const subQueries = {};
+        let i = 0;
+        const extractor = $0 => {
+            const placeholder = `~~SUBQUERY_${i++}~~`;
+            subQueries[placeholder] = $0;
+            return placeholder;
+        };
+        // subselect in FROM clause
+        sql = sql.replace(/\(\s*SELECT\s+.+\)\s+AS\s+[^\s,]+/, extractor);
+        // IF() in FROM clause
+        sql = sql.replace(/\bIF\s*\(.+\)\s+AS\s+[^\s,]+/, extractor);
+        // IN (SELECT *) in JOINs, WHERE or HAVING
+        sql = sql.replace(/\bIN\s*\(\s*SELECT\s.+?\)/, extractor);
+        return { sql, subQueries };
+    }
+    /**
+     * Inject column subQueries back into this object
+     * @param subQueries  The lookup of extracted subQueries
+     * @private
+     */
+    _injectSubQueries(subQueries) {
+        const replacer = $0 => {
+            return subQueries[$0] || $0;
+        };
+        const mapper = clause => {
+            return clause.replace(/~~SUBQUERY_\d+~~/g, replacer);
+        };
+        this.query._columns = this.query._columns.map(replacer);
+        this.query._joins = this.query._joins.map(mapper);
+        this.query._wheres = this.query._wheres.map(mapper);
+        this.query._havings = this.query._havings.map(mapper);
+    }
+    /**
+     * Split SQL into clauses (used by parse())
+     * @param sql  The SQL to split
+     * @return
+     * @private
+     */
+    _split(sql) {
+        const splitter = /(?:^|\s)(SELECT|FROM|(?:INNER|LEFT\s+OUTER|RIGHT\s+OUTER|LEFT|RIGHT|CROSS|FULL|FULL\s+OUTER)\s+JOIN|WHERE|GROUP\s+BY|HAVING|ORDER\s+BY|LIMIT|OFFSET|FETCH\s+NEXT)\b/i;
+        return sql.split(splitter);
+    }
+    /**
+     * Get a QuickSelect object representing the given SQL SELECT statement
+     * @param  rawSql  The raw SQL for the SELECT statement
+     * @return True if the SQL was parsed successfully
+     */
+    parse(rawSql) {
+        const stripped = this._stripComments(rawSql);
+        const { sql, subQueries } = this._extractSubQueries(stripped);
+        const expressions = this._split(sql);
+        let i = 1;
+        while (i < expressions.length) {
+            const rawKeyword = expressions[i++].trim();
+            const keyword = rawKeyword.toUpperCase().replace(/\s+/g, '_');
+            const clause = expressions[i++].trim();
+            const handler = `_handle${keyword}`;
+            this[handler](clause);
+        }
+        this._injectSubQueries(subQueries);
+        return true;
+    }
+    /**
+     * Handle SQL_CALC_FOUND_ROWS and column names
+     * @param clause  The clause after the SELECT
+     * @private
+     */
+    _handleSELECT(clause) {
+        let columns = clause.split(/s*,s*/);
+        // now handle parenthesis expressions that contain commas
+        let buffer = '';
+        columns.forEach((column, i) => {
+            if (i === 0) {
+                const optionRegex = /^(SQL_CALC_FOUND_ROWS)\s+/i;
+                const match = column.match(optionRegex);
+                if (match) {
+                    this.query.option(match[1]);
+                    column = column.replace(optionRegex, '');
+                }
+            }
+            if (buffer.length) {
+                // we are in the middle of an expression containing parenthesis
+                if (column.indexOf(')') > 0) {
+                    // we have an end parenthesis
+                    buffer += column;
+                    this.query.column(buffer.trim());
+                    buffer = '';
+                }
+                else {
+                    buffer += column + ',';
+                }
+            }
+            else if (column.match(/\([^)]+$/)) {
+                buffer = column + ',';
+            }
+            else {
+                this.query.column(column.trim());
+            }
+        });
+    }
+    /**
+     * Handle table names
+     * @param clause  The clause after the FROM
+     * @private
+     */
+    _handleFROM(clause) {
+        const tables = clause.split(/\s*,\s*/);
+        tables.forEach(table => this.query.table(table));
+    }
+    /**
+     * Handle INNER JOIN statements
+     * @param clause  The clause after the INNER JOIN
+     * @private
+     */
+    _handleINNER_JOIN(clause) {
+        this.query.innerJoin(clause);
+    }
+    /**
+     * Handle LEFT JOIN statements
+     * @param clause  The clause after the LEFT JOIN
+     * @private
+     */
+    _handleLEFT_JOIN(clause) {
+        this.query.leftJoin(clause);
+    }
+    /**
+     * Handle LEFT OUTER JOIN statements
+     * @param clause  The clause after the LEFT OUTER JOIN
+     * @private
+     */
+    _handleLEFT_OUTER_JOIN(clause) {
+        this.query.leftOuterJoin(clause);
+    }
+    /**
+     * Handle RIGHT JOIN statements
+     * @param clause  The clause after the RIGHT JOIN
+     * @private
+     */
+    _handleRIGHT_JOIN(clause) {
+        this.query.rightJoin(clause);
+    }
+    /**
+     * Handle RIGHT OUTER JOIN statements
+     * @param clause  The clause after the RIGHT OUTER JOIN
+     * @private
+     */
+    _handleRIGHT_OUTER_JOIN(clause) {
+        this.query.rightOuterJoin(clause);
+    }
+    /**
+     * Handle CROSS JOIN statements
+     * @param clause  The clause after the CROSS JOIN
+     * @private
+     */
+    _handleCROSS_JOIN(clause) {
+        this.query.crossJoin(clause);
+    }
+    /**
+     * Handle FULL JOIN statements
+     * @param clause  The clause after the FULL JOIN
+     * @private
+     */
+    _handleFULL_JOIN(clause) {
+        this.query.fullJoin(clause);
+    }
+    /**
+     * Handle FULL OUTER JOIN statements
+     * @param clause  The clause after the FULL OUTER JOIN
+     * @private
+     */
+    _handleFULL_OUTER_JOIN(clause) {
+        this.query.fullOuterJoin(clause);
+    }
+    /**
+     * Handle WHERE conditions
+     * @param clause  All the conditions after WHERE
+     * @private
+     */
+    _handleWHERE(clause) {
+        if (/^(1|'1'|true)$/i.test(clause)) {
+            this.query._wheres.push(clause);
+        }
+        else {
+            this._handleConditions('where', clause);
+        }
+    }
+    /**
+     * Handle HAVING statements
+     * @param clause  All the conditions after HAVING
+     * @private
+     */
+    _handleHAVING(clause) {
+        this._handleConditions('having', clause);
+    }
+    /**
+     * Build a conditions list
+     * @param type  Either where or having
+     * @param clause  The expressions following the type keyword
+     * @private
+     */
+    _handleConditions(type, clause) {
+        const andGroups = clause.split(/\bAND\b/i);
+        andGroups.forEach(andGroup => {
+            const orPieces = andGroup.split(/\bOR\b/i).map(str => str.trim());
+            if (orPieces.length === 1) {
+                // no OR operators
+                const fn = type; // either where or having
+                this.query[fn](orPieces[0]);
+            }
+            else {
+                // some OR operators
+                // either orWhere or orHaving
+                const orFn = type === 'where' ? 'orWhere' : 'orHaving';
+                this.query[orFn](orPieces.map(p => [p]));
+            }
+        });
+    }
+    /**
+     * Handle GROUP BY statements
+     * @param clause  The clauses after the GROUP BY
+     * @private
+     */
+    _handleGROUP_BY(clause) {
+        const columns = clause.split(/\s*,\s*/);
+        columns.forEach(column => this.query.groupBy(column));
+    }
+    /**
+     * Handle ORDER BY statements
+     * @param clause  The clause after the ORDER BY
+     * @private
+     */
+    _handleORDER_BY(clause) {
+        const columns = clause.split(/\s*,\s*/);
+        columns.forEach(column => this.query.orderBy(column));
+    }
+    /**
+     * Handle LIMIT statements including "LIMIT #" and "LIMIT #, #"
+     * @param clause  The clause after the LIMIT
+     * @private
+     */
+    _handleLIMIT(clause) {
+        const offsetLimit = clause.match(/^(\d+|\?|:\w+)\s*,\s*(\d+|\?|:\w+)$/);
+        if (offsetLimit) {
+            this.query.offset(offsetLimit[1]);
+            this.query.limit(offsetLimit[2]);
+        }
+        else {
+            clause = clause.replace(/ ROWS$/i, '');
+            this.query.limit(clause);
+        }
+    }
+    /**
+     * Handle OFFSET statements
+     * @param clause  The number after the OFFSET
+     * @private
+     */
+    _handleOFFSET(clause) {
+        clause = clause.replace(/^(\d+) ROWS$/i, '$1');
+        this.query.offset(clause);
+    }
+    /**
+     * Handle OFFSET statements
+     * @param clause  The number after the OFFSET
+     * @private
+     */
+    _handleFETCH_NEXT(clause) {
+        clause = clause.replace(/^(\d+) ROWS ONLY$/i, '$1');
+        this.query.limit(clause);
+    }
+}

package/dist/src/SelectBuilder/SelectBuilder.d.ts

@@ -0,0 +1,355 @@
+export type FieldName = 'option' | 'options' | 'select' | 'column' | 'columns' | 'table' | 'tables' | 'join' | 'joins' | 'where' | 'wheres' | 'having' | 'havings' | 'groupBy' | 'groupBys' | 'orderBy' | 'orderBys' | 'limit' | 'offset' | 'page';
+export type EngineStyle = 'mssql' | 'mysql' | 'oracle' | 'pg';
+export type WhereCriteria = [string, string, any] | [string, any] | [string] | [Record<string, any>];
+/**
+ * Build a select query
+ * Class Select
+ */
+export default class SelectBuilder {
+    /**
+     * The list of values to bind to the query
+     * @private
+     */
+    _bindings: any[];
+    /**
+     * The list of strings to come immediately after "SELECT"
+     * and before column names
+     * @private
+     */
+    _options: string[];
+    /**
+     * The list of column names to select
+     * @private
+     */
+    _tables: string[];
+    /**
+     * The list of tables in the FROM clause
+     * @private
+     */
+    _columns: string[];
+    /**
+     * The list of JOIN strings to add
+     * @private
+     */
+    _joins: string[];
+    /**
+     * The list of WHERE clauses to join with AND
+     * @private
+     */
+    _wheres: string[];
+    /**
+     * The list of GROUP BY clauses to join with commas
+     * @private
+     */
+    _groupBys: string[];
+    /**
+     * The list of HAVING clauses to join with AND
+     * @private
+     */
+    _havings: string[];
+    /**
+     * The list of ORDER BY clauses to join with commas
+     * @private
+     */
+    _orderBys: string[];
+    /**
+     * The LIMIT to use
+     * @private
+     */
+    _limit: number;
+    /**
+     * The OFFSET to use
+     * @private
+     */
+    _offset: number;
+    /**
+     * The page used to construct an OFFSET based on the LIMIT
+     * @private
+     */
+    _page: number;
+    /**
+     * Select constructor
+     * @param [sql]  A base SQL query to parse
+     * @param [bindings]  Placeholders to bind to the query
+     */
+    constructor(sql?: string, bindings?: Record<string, any>);
+    /**
+     * Get the SQL as a pretty-printed string alongside an array of bindings
+     * @param engineStyle  The database engine style (mssql, mysql, oracle, pg)
+     * @return The SQL query as a string
+     */
+    compile(engineStyle?: EngineStyle): {
+        sql: string;
+        bindings: any;
+    };
+    _compileLIMIT(engineStyle: EngineStyle, limit: number): string;
+    _compileOFFSET(engineStyle: EngineStyle, offset: number): string;
+    /**
+     * Get SQL needed to return the found rows of this query
+     * @param countExpr  The expression to use inside the COUNT()
+     * @param engineStyle  The database engine style (mssql, mysql, oracle, pg)
+     */
+    compileCount(countExpr?: string, engineStyle?: EngineStyle): {
+        sql: string;
+        bindings: any;
+    };
+    /**
+     * @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?: FieldName | FieldName[]): this;
+    /**
+     * Clone this builder object
+     */
+    getClone(): SelectBuilder;
+    /**
+     * Build a version of this query that simply returns COUNT(*)
+     * @param [countExpr="*"]  Use to specify `DISTINCT colname` if needed
+     */
+    getFoundRowsQuery(countExpr?: string): SelectBuilder;
+    /**
+     * Add an array of column names to fetch
+     * @param columnNames  The names of columns
+     */
+    select(columnNames: string[]): this;
+    /**
+     * Add an array of column names to fetch
+     * @param columnNames  The names of columns
+     */
+    columns(columnNames: string[]): this;
+    /**
+     * Add a column name to fetch
+     * @param columnName  The name of the column
+     */
+    column(columnName: string): 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: string): 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: string): this;
+    /**
+     * Add multiple table to the "FROM" clause
+     * @param {Array} tableNames  The names of the tables to query
+     * @return {Select}
+     */
+    tables(tableNames: string[]): 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: string): 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: string, expression: string, bindings?: any[]): void;
+    /**
+     * 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: string, bindings?: any[]): 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: string, bindings?: any[]): 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: string, bindings?: any[]): 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: string, bindings?: any[]): 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: string, bindings?: any[]): 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: string, bindings?: any[]): 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: string, bindings?: any[]): 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: string, bindings?: any[]): 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: string, bindings?: any[]): 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: string | string[]): 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: string[], criteria: WhereCriteria): this;
+    /**
+     * Add a group by column or expression
+     * @param column  The name of a column (or expression) to group by
+     */
+    groupBy(column: string): this;
+    /**
+     * Add WHERE clauses to conditions (See _conditions for usage)
+     */
+    where(...args: WhereCriteria): this;
+    /**
+     * Add a WHERE clause with a BETWEEN condition
+     * @param column  The column name
+     * @param twoValueArray  The two values to be between
+     */
+    whereBetween(column: string, twoValueArray: [any, any]): this;
+    /**
+     * Add a series of WHERE clauses joined by OR (See _conditions for usage)
+     * @param conditions
+     */
+    _orConditions(conditions: WhereCriteria[] | Record<string, any>[]): string;
+    /**
+     * 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: WhereCriteria[] | Record<string, any>[]): 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: WhereCriteria[] | Record<string, any>[]): this;
+    /**
+     * Add a HAVING condition (See _conditions for usage)
+     */
+    having(...args: WhereCriteria): 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: string, direction?: 'ASC' | 'DESC'): this;
+    /**
+     * Sort by the given column, with a map of columns to translate
+     * @param column  The column name such as "created_at" or "-created_at" for descending
+     * @param [mapNames]  Column names to translate from one name to another
+     * @example
+     *   query.sortField('-modified_at'); // ORDER BY modified_at DESC
+     *   query.sortField('created_at', {'created_at': 'created'}); // ORDER BY created
+     */
+    sortField(column: string, mapNames?: Record<string, string>): 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: string): boolean;
+    /**
+     * Check to see if the given string is all digits
+     * @param string  The input string
+     * @private
+     */
+    _isEntirelyDigitsNoZeros(string: string): boolean;
+    /**
+     * Limit results to the given number
+     * @param max  The number to limit by (placeholder string or integer greater than 0)
+     */
+    limit(max: number | string): this;
+    /**
+     * Fetch results from the given offset
+     * @param number  The offset (placeholder string or integer greater than or equal to 0)
+     */
+    offset(number: number | string): this;
+    /**
+     * Set the offset based on the limit with the given page number
+     * @param number  The page number (integer greater than 0)
+     */
+    page(number: number | string): this;
+}