sql-love 1.0.3 → 1.0.5

package/{src/SelectBuilder/SelectBuilder.ts → dist/index.mjs}

@@ -1,117 +1,374 @@
-import Parser from '../Parser/Parser';
-import substrCount from '../substrCount/substrCount';
-
-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>];
-
-const isNullish = v => v === undefined || v === null || v === false || isNaN(v);
+// src/Parser/Parser.ts
+var Parser = class {
+  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) {
+    sql = sql.replace(/\/\*[\s\S]*?\*\//g, "");
+    sql = sql.replace(/--([\r\n]|\s+[^\r\n]+[\r\n])/g, "");
+    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;
+    };
+    sql = sql.replace(/\(\s*SELECT\s+.+\)\s+AS\s+[^\s,]+/, extractor);
+    sql = sql.replace(/\bIF\s*\(.+\)\s+AS\s+[^\s,]+/, extractor);
+    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*/);
+    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) {
+        if (column.indexOf(")") > 0) {
+          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) {
+        const fn = type;
+        this.query[fn](orPieces[0]);
+      } else {
+        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);
+  }
+};
 
-let defaultEngine: EngineStyle = 'mysql';
+// src/substrCount/substrCount.ts
+function substrCount(haystack, needle) {
+  let count = 0;
+  let pos = haystack.indexOf(needle);
+  while (pos !== -1) {
+    count += 1;
+    pos = haystack.indexOf(needle, pos + 1);
+  }
+  return count;
+}
 
-/**
- * Build a select query
- * Class Select
- */
-export default class SelectBuilder {
+// src/SelectBuilder/SelectBuilder.ts
+var isNullish = (v) => v === void 0 || v === null || v === false || isNaN(v);
+var defaultEngine = "mysql";
+var SelectBuilder = class _SelectBuilder {
   /**
    * The list of values to bind to the query
    * @private
    */
-  _bindings: any[] = [];
+  _bindings = [];
   /**
    * The list of strings to come immediately after "SELECT"
    * and before column names
    * @private
    */
-  _options: string[] = [];
+  _options = [];
   /**
    * The list of column names to select
    * @private
    */
-  _tables: string[] = [];
+  _tables = [];
   /**
    * The list of tables in the FROM clause
    * @private
    */
-  _columns: string[] = [];
+  _columns = [];
   /**
    * The list of JOIN strings to add
    * @private
    */
-  _joins: string[] = [];
+  _joins = [];
   /**
    * The list of WHERE clauses to join with AND
    * @private
    */
-  _wheres: string[] = [];
+  _wheres = [];
   /**
    * The list of GROUP BY clauses to join with commas
    * @private
    */
-  _groupBys: string[] = [];
+  _groupBys = [];
   /**
    * The list of HAVING clauses to join with AND
    * @private
    */
-  _havings: string[] = [];
+  _havings = [];
   /**
    * The list of ORDER BY clauses to join with commas
    * @private
    */
-  _orderBys: string[] = [];
+  _orderBys = [];
   /**
    * The LIMIT to use
    * @private
    */
-  _limit: number;
+  _limit;
   /**
    * The OFFSET to use
    * @private
    */
-  _offset: number;
+  _offset;
   /**
    * The page used to construct an OFFSET based on the LIMIT
    * @private
    */
-  _page: number;
-
+  _page;
   /**
    * Select constructor
    * @param [sql]  A base SQL query to parse
    * @param [bindings]  Placeholders to bind to the query
    */
-  constructor(sql: string = null, bindings: Record<string, any> = null) {
+  constructor(sql = null, bindings = null) {
     if (sql) {
       if (bindings) {
         const keys = Object.keys(bindings);
-        const regexp = new RegExp(`:(${keys.join('|')})`, 'g');
+        const regexp = new RegExp(`:(${keys.join("|")})`, "g");
         sql = sql.replace(regexp, ($0, $1) => {
           this._bindings.push(bindings[$1]);
           return `__BOUND_${this._bindings.length - 1}__`;
@@ -120,16 +377,14 @@ export default class SelectBuilder {
       new Parser(this).parse(sql);
     }
   }
-
   /**
    * Set the default database engine style (mssql, mysql, oracle, pg)
    * @param engine
    */
-  static setDefaultEngine(engine: EngineStyle) {
+  static setDefaultEngine(engine) {
     defaultEngine = engine;
-    return SelectBuilder;
+    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)
@@ -137,22 +392,18 @@ export default class SelectBuilder {
    */
   compile({
     engine = defaultEngine,
-    bindingIndex = 1,
-  }: {
-    engine?: EngineStyle;
-    bindingIndex?: number;
+    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,
+      "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;
@@ -166,120 +417,109 @@ export default class SelectBuilder {
         lines.push(this._compileLIMIT(engine, this._limit));
       }
     }
-
-    const pretty = lines.filter(Boolean).join('\n').trim();
-    let replacer: (match0: string, match1: string) => string;
-    const bindings: any = [];
-    if (engine === 'pg') {
+    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++;
+        return "$" + idx++;
       };
     } else {
       replacer = (_, $1) => {
         bindings.push(this._bindings[$1]);
-        return '?';
+        return "?";
       };
     }
     const sql = pretty.replace(/__BOUND_(\d+)__/g, replacer);
     return { sql, bindings };
   }
-
-  _compileLIMIT(engineStyle: EngineStyle, limit: number) {
-    if (engineStyle === 'pg' || engineStyle === 'mysql') {
+  _compileLIMIT(engineStyle, limit) {
+    if (engineStyle === "pg" || engineStyle === "mysql") {
       return `LIMIT ${limit}`;
-    } else if (engineStyle === 'mssql') {
+    } else if (engineStyle === "mssql") {
       return `FETCH NEXT ${limit} ROWS ONLY`;
     }
   }
-
-  _compileOFFSET(engineStyle: EngineStyle, offset: number) {
-    if (engineStyle === 'pg' || engineStyle === 'mysql') {
+  _compileOFFSET(engineStyle, offset) {
+    if (engineStyle === "pg" || engineStyle === "mysql") {
       return `OFFSET ${offset}`;
-    } else if (engineStyle === 'mssql' || engineStyle === 'oracle') {
+    } 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 = '*',
+    countExpr = "*",
     engine = defaultEngine,
-    bindingIndex = 1,
-  }: {
-    countExpr?: string;
-    engine?: EngineStyle;
-    bindingIndex?: number;
+    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');
+      const subquerySql = sql.replace(/\n/g, "\n	");
       return {
-        sql: `SELECT COUNT(*) AS found_rows\nFROM (\n${subquerySql}\n) AS subquery_results`,
-        bindings,
+        sql: `SELECT COUNT(*) AS found_rows
+FROM (
+${subquerySql}
+) 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: SelectBuilder,
-    {
-      engine = defaultEngine,
-      bindingIndex = 1,
-    }: {
-      engine?: EngineStyle;
-      bindingIndex?: number;
-    } = {}
-  ) {
+  compileUnion(query, {
+    engine = defaultEngine,
+    bindingIndex = 1
+  } = {}) {
     const first = this.compile({ engine, bindingIndex });
     const second = query.compile({
       engine,
-      bindingIndex: first.bindings.length + bindingIndex,
+      bindingIndex: first.bindings.length + bindingIndex
     });
     return {
-      sql: `(${first.sql})\nUNION\n(${second.sql})`,
-      bindings: [...first.bindings, ...second.bindings],
+      sql: `(${first.sql})
+UNION
+(${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: FieldName | FieldName[] = null) {
+  reset(fieldOrFields = null) {
     if (Array.isArray(fieldOrFields)) {
-      fieldOrFields.forEach(name => this.reset(name));
+      fieldOrFields.forEach((name) => this.reset(name));
       return this;
     }
     if (fieldOrFields) {
       const pluralizable = [
-        'option',
-        'column',
-        'table',
-        'where',
-        'having',
-        'groupBy',
-        'orderBy',
+        "option",
+        "column",
+        "table",
+        "where",
+        "having",
+        "groupBy",
+        "orderBy"
       ];
-      let prop = '_' + fieldOrFields.replace(/s$/, '');
+      let prop = "_" + fieldOrFields.replace(/s$/, "");
       if (pluralizable.indexOf(fieldOrFields) > -1) {
-        prop += 's';
+        prop += "s";
       }
-      const isScalar = ['limit', 'offset', 'page'].indexOf(fieldOrFields) > -1;
+      const isScalar = ["limit", "offset", "page"].indexOf(fieldOrFields) > -1;
       this[prop] = isScalar ? null : [];
     } else {
       this._options = [];
@@ -297,12 +537,11 @@ export default class SelectBuilder {
     }
     return this;
   }
-
   /**
    * Clone this builder object
    */
   getClone() {
-    const copy = new SelectBuilder();
+    const copy = new _SelectBuilder();
     copy._options = [...this._options];
     copy._columns = [...this._columns];
     copy._tables = [...this._tables];
@@ -317,12 +556,11 @@ export default class SelectBuilder {
     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: string = '*') {
+  getFoundRowsQuery(countExpr = "*") {
     if (this._havings.length === 0) {
       const clone = this.getClone();
       clone._columns = [`COUNT(${countExpr}) AS found_rows`];
@@ -341,73 +579,65 @@ export default class SelectBuilder {
       return subquery;
     }
   }
-
   /**
    * Add an array of column names to fetch
    * @param columnNames  The names of columns
    */
-  select(columnNames: string[]) {
+  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: string[]) {
+  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: string) {
+  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: string) {
+  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: string) {
+  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: string[]) {
+  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: string) {
+  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.)
@@ -417,7 +647,7 @@ export default class SelectBuilder {
    *   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[] = []) {
+  _addJoin(joinType, expression, bindings = []) {
     if (bindings.length > 0) {
       expression = expression.replace(/\?/g, () => {
         this._bindings.push(bindings.shift());
@@ -426,7 +656,6 @@ export default class SelectBuilder {
     }
     this._joins.push(`${joinType} ${expression}`);
   }
-
   /**
    * Add a JOIN expression
    * @param expression  The expression following the INNER JOIN keyword
@@ -435,11 +664,10 @@ export default class SelectBuilder {
    *   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._addJoin('JOIN', expression, bindings);
+  join(expression, bindings = []) {
+    this._addJoin("JOIN", expression, bindings);
     return this;
   }
-
   /**
    * Add a LEFT JOIN expression
    * @param expression  The expression following the LEFT JOIN keyword
@@ -448,11 +676,10 @@ export default class SelectBuilder {
    *   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._addJoin('LEFT JOIN', expression, bindings);
+  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
@@ -461,11 +688,10 @@ export default class SelectBuilder {
    *   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._addJoin('FULL JOIN', expression, bindings);
+  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
@@ -474,11 +700,10 @@ export default class SelectBuilder {
    *   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._addJoin('RIGHT JOIN', expression, bindings);
+  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
@@ -487,11 +712,10 @@ export default class SelectBuilder {
    *   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._addJoin('CROSS JOIN', expression, bindings);
+  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
@@ -500,11 +724,10 @@ export default class SelectBuilder {
    *   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._addJoin('INNER JOIN', expression, bindings);
+  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
@@ -513,11 +736,10 @@ export default class SelectBuilder {
    *   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._addJoin('LEFT OUTER JOIN', expression, bindings);
+  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
@@ -526,11 +748,10 @@ export default class SelectBuilder {
    *   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._addJoin('FULL OUTER JOIN', expression, bindings);
+  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
@@ -539,27 +760,25 @@ export default class SelectBuilder {
    *   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._addJoin('RIGHT OUTER JOIN', expression, bindings);
+  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: string | string[]) {
+  unjoin(table) {
     if (Array.isArray(table)) {
-      table.forEach(t => this.unjoin(t));
+      table.forEach((t) => this.unjoin(t));
       return this;
     }
-    this._joins = this._joins.filter(join => {
+    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)
@@ -588,28 +807,19 @@ export default class SelectBuilder {
    *   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) {
+  _conditions(collection, criteria) {
     const numArgs = criteria.length;
     let [column, operator, value] = criteria;
-    if (typeof column === 'object') {
+    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]);
+    } else if (numArgs === 2 && Array.isArray(operator) && operator.length > 0 && substrCount(column, "?") === operator.length) {
       const values = operator;
       const sql = column.replace(/\?/g, () => {
         this._bindings.push(values.shift());
@@ -618,23 +828,19 @@ export default class SelectBuilder {
       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(' ');
+      const parts = column.split(" ");
       column = parts.shift();
-      operator = parts.join(' ');
+      operator = parts.join(" ");
     }
-    if (typeof operator !== 'string' || operator === '') {
-      operator = '=';
+    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
+    if (operator === "NOT BETWEEN" || operator === "BETWEEN") {
       const one = this._bindings.length;
       const two = this._bindings.length + 1;
       collection.push(
@@ -642,39 +848,35 @@ export default class SelectBuilder {
       );
       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 ?
+      const like = likeMatch[1].toUpperCase();
+      const infix = likeMatch[2] || "?";
       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));
+          this._bindings.push(infix.replace("?", v));
         }
-        const joined = ors.join(' OR ');
+        const joined = ors.join(" OR ");
         collection.push(`(${joined})`);
       } else {
         collection.push(`${column} ${like} __BOUND_${this._bindings.length}__`);
-        this._bindings.push(infix.replace('?', value || ''));
+        this._bindings.push(infix.replace("?", value || ""));
       }
     } else if (value === null) {
       collection.push(
-        operator === '=' ? `${column} IS NULL` : `${column} IS NOT NULL`
+        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(', ');
+      const joined = inVals.join(", ");
       collection.push(
-        operator === '=' || operator === 'IN'
-          ? `${column} IN(${joined})`
-          : `${column} NOT IN(${joined})`
+        operator === "=" || operator === "IN" ? `${column} IN(${joined})` : `${column} NOT IN(${joined})`
       );
-    } else if (operator === 'IN' || operator === 'NOT IN') {
-      // in clause that is not array
+    } else if (operator === "IN" || operator === "NOT IN") {
       collection.push(
         `${column} ${operator}(__BOUND_${this._bindings.length}__)`
       );
@@ -687,54 +889,47 @@ export default class SelectBuilder {
     }
     return this;
   }
-
   /**
    * Add a group by column or expression
    * @param column  The name of a column (or expression) to group by
    */
-  groupBy(column: string) {
+  groupBy(column) {
     this._groupBys.push(column);
     return this;
   }
-
   /**
    * Add WHERE clauses to conditions (See _conditions for usage)
    */
-  where(...args: WhereCriteria) {
+  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: string, twoValueArray: [any, any]) {
+  whereBetween(column, twoValueArray) {
     if (!isNullish(twoValueArray[0]) && !isNullish(twoValueArray[1])) {
-      this.where(column, 'BETWEEN', twoValueArray);
+      this.where(column, "BETWEEN", twoValueArray);
     } else if (!isNullish(twoValueArray[0]) && isNullish(twoValueArray[1])) {
-      this.where(column, '>=', twoValueArray[0]);
+      this.where(column, ">=", twoValueArray[0]);
     } else if (isNullish(twoValueArray[0]) && !isNullish(twoValueArray[1])) {
-      this.where(column, '<=', 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: WhereCriteria[] | Record<string, any>[] | Record<string, any>
-  ) {
+  _orConditions(conditions) {
     const items = [];
     if (Array.isArray(conditions)) {
       for (const condition of conditions) {
         if (Array.isArray(condition)) {
-          this._conditions(items, condition as WhereCriteria);
+          this._conditions(items, condition);
         } else {
           this._conditions(items, [condition]);
         }
@@ -746,47 +941,38 @@ export default class SelectBuilder {
         items.push(one[0]);
       }
     }
-    const joined = items.join(' OR ');
-    if (joined.startsWith('(') && joined.endsWith(')')) {
-      // start/end paraens will be added by orWhere() or orHaving()
+    const joined = items.join(" OR ");
+    if (joined.startsWith("(") && joined.endsWith(")")) {
       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: WhereCriteria[] | Record<string, any>[] | Record<string, any>
-  ) {
+  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: WhereCriteria[] | Record<string, any>[] | Record<string, any>
-  ) {
+  orHaving(conditions) {
     const joined = this._orConditions(conditions);
     this.having(`(${joined})`);
     return this;
   }
-
   /**
    * Add a HAVING condition (See _conditions for usage)
    */
-  having(...args: WhereCriteria) {
+  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
@@ -797,16 +983,15 @@ export default class SelectBuilder {
    *   query.sortField('COUNT(*)'); // ORDER BY COUNT(*)
    *   query.sortField('COUNT(*) DESC'); // ORDER BY COUNT(*) DESC
    */
-  orderBy(column: string, direction: 'ASC' | 'DESC' = null) {
+  orderBy(column, direction = null) {
     if (direction) {
       this._orderBys.push(`${column} ${direction}`);
     } else {
-      const expression = column.replace(/^-(.+)/, '$1 DESC');
+      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
@@ -815,47 +1000,43 @@ export default class SelectBuilder {
    *   query.sortField('-modified_at'); // ORDER BY modified_at DESC
    *   query.sortField('-created', {'created': 'created_at'}); // ORDER BY created_at DESC
    */
-  sortField(fieldName: string, mapNames: Record<string, string> = {}) {
-    let direction = 'ASC' as 'ASC' | 'DESC';
-    if (fieldName.startsWith('-')) {
-      direction = '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: string) {
+  _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: string) {
+  _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: number | string) {
-    if (typeof max === 'string') {
+  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) {
+    } else if (typeof max === "number" && Number.isInteger(max) && max >= 1) {
       this._limit = max;
     } else {
       throw new Error(
@@ -864,20 +1045,14 @@ export default class SelectBuilder {
     }
     return 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) {
-    if (typeof number === 'string' && this._isEntirelyDigits(number.trim())) {
-      // is entirely digits (or zero)
+  offset(number) {
+    if (typeof number === "string" && this._isEntirelyDigits(number.trim())) {
       this._offset = parseInt(number, 10);
-    } else if (
-      typeof number === 'number' &&
-      Number.isInteger(number) &&
-      number >= 0
-    ) {
+    } else if (typeof number === "number" && Number.isInteger(number) && number >= 0) {
       this._offset = number;
     } else {
       throw new Error(
@@ -886,23 +1061,14 @@ export default class SelectBuilder {
     }
     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: number | string) {
-    if (
-      typeof number === 'string' &&
-      this._isEntirelyDigitsNoZeros(number.trim())
-    ) {
-      // is entirely digits (or zero)
+  page(number) {
+    if (typeof number === "string" && this._isEntirelyDigitsNoZeros(number.trim())) {
       this._page = parseInt(number, 10);
-    } else if (
-      typeof number === 'number' &&
-      Number.isInteger(number) &&
-      number >= 1
-    ) {
+    } else if (typeof number === "number" && Number.isInteger(number) && number >= 1) {
       this._page = number;
     } else {
       throw new Error(
@@ -911,4 +1077,211 @@ export default class SelectBuilder {
     }
     return this;
   }
+};
+
+// src/extractGrouped/extractGrouped.ts
+function extractGrouped(field, records) {
+  let idx = 0;
+  const grouped = {};
+  for (const record of records) {
+    if (!(field in record)) {
+      throw new Error(
+        `Column "${String(field)}" is not present in record ${idx}`
+      );
+    }
+    if (!grouped[record[field]]) {
+      grouped[record[field]] = [];
+    }
+    grouped[record[field]].push(record);
+    idx++;
+  }
+  return grouped;
+}
+
+// src/extractIndexed/extractIndexed.ts
+function extractIndexed(field, records) {
+  let idx = 0;
+  const indexed = {};
+  for (const record of records) {
+    if (!(field in record)) {
+      throw new Error(
+        `Column "${String(field)}" is not present in record ${idx}`
+      );
+    }
+    indexed[record[field]] = record;
+    idx++;
+  }
+  return indexed;
+}
+
+// src/extractLookup/extractLookup.ts
+function extractLookup(keyField, valueField, records) {
+  const lookup = {};
+  let idx = 0;
+  for (const record of records) {
+    if (!(keyField in record)) {
+      throw new Error(
+        `Column "${String(keyField)}" is not present in record ${idx}`
+      );
+    }
+    if (!(valueField in record)) {
+      throw new Error(
+        `Column "${String(valueField)}" is not present in record ${idx}`
+      );
+    }
+    idx++;
+    lookup[String(record[keyField])] = record[valueField];
+  }
+  return lookup;
+}
+
+// src/getPagination/getPagination.ts
+function getPagination(query, total) {
+  total = Number(total) || 0;
+  const perPage = Number(query._limit) || null;
+  let page = null;
+  if (total === 0) {
+    page = null;
+  } else if (query._page) {
+    page = Number(query._page);
+  } else if (query._limit && query._offset) {
+    page = Math.floor(Number(query._offset) / Number(query._limit)) + 1;
+  } else if (query._limit && !query._offset) {
+    page = 1;
+  } else {
+    page = null;
+  }
+  const numPages = total === 0 || perPage === null ? 0 : Math.ceil(total / perPage) || 0;
+  const isFirst = page === 1;
+  const isLast = numPages > 0 && page === numPages;
+  const prevPage = numPages === 0 ? null : page - 1 || null;
+  const nextPage = numPages > 0 && page + 1 <= numPages ? page + 1 : null;
+  return {
+    page,
+    prevPage,
+    nextPage,
+    perPage,
+    numPages,
+    total,
+    isFirst,
+    isLast
+  };
+}
+
+// src/runMysql/runMysql.ts
+function _queryToPromise(mysqlClient, sql, bindings) {
+  return new Promise((resolve, reject) => {
+    mysqlClient.query(sql, bindings, (err, rows, fields) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve([rows, fields]);
+    });
+  });
+}
+async function runMysql(mysqlClient, query) {
+  const { sql, bindings } = query.compile({ engine: "mysql" });
+  return _queryToPromise(mysqlClient, sql, bindings);
+}
+async function runMysqlWithCount(mysqlClient, query, { countExpr = "*" } = {}) {
+  const { sql, bindings } = query.compile({ engine: "mysql" });
+  const [records, fields] = await _queryToPromise(mysqlClient, sql, bindings);
+  if (records.length > 0) {
+    const { sql: sql2, bindings: bindings2 } = query.compileCount({
+      engine: "mysql",
+      countExpr
+    });
+    const [rows] = await _queryToPromise(mysqlClient, sql2, bindings2);
+    const total = rows[0].found_rows;
+    return { records, total, pagination: getPagination(query, total), fields };
+  } else {
+    return { records, total: 0, pagination: getPagination(query, 0), fields };
+  }
+}
+async function runMysqlAsync(mysqlClient, query) {
+  const { sql, bindings } = query.compile({ engine: "mysql" });
+  return mysqlClient.query(sql, bindings);
+}
+async function runMysqlAsyncWithCount(mysqlClient, query, {
+  engine = "mysql",
+  countExpr = "*"
+} = {}) {
+  const { sql, bindings } = query.compile({ engine });
+  const [records, fields] = await mysqlClient.query(sql, bindings);
+  if (records.length > 0) {
+    const { sql: sql2, bindings: bindings2 } = query.compileCount({ engine, countExpr });
+    const [rows] = await mysqlClient.query(sql2, bindings2);
+    const total = rows[0].found_rows;
+    return { records, total, pagination: getPagination(query, total), fields };
+  } else {
+    return { records, total: 0, pagination: getPagination(query, 0), fields };
+  }
+}
+
+// src/toSafeJson/toSafeJson.ts
+function toSafeJsonValue(value) {
+  if (typeof value === "bigint") {
+    const asNumber = Number(value);
+    return value == asNumber ? asNumber : value.toString();
+  }
+  return value;
+}
+function toSafeJsonRecord(record) {
+  const newRecord = {};
+  for (const key in record) {
+    if (!Object.prototype.hasOwnProperty.call(record, key)) {
+      continue;
+    }
+    newRecord[key] = toSafeJsonValue(record[key]);
+  }
+  return newRecord;
+}
+function toSafeJsonRecords(records) {
+  return records.map(toSafeJsonRecord);
+}
+function toSafeJsonString(records) {
+  return JSON.stringify(records, (_, value) => toSafeJsonValue(value));
+}
+
+// src/runPrisma/runPrisma.ts
+async function runPrisma(prisma, query, { engine = void 0 } = {}) {
+  const { sql, bindings } = query.compile({ engine });
+  return prisma.$queryRawUnsafe(sql, ...bindings);
+}
+async function runPrismaWithCount(prisma, query, {
+  engine = void 0,
+  countExpr = "*"
+} = {}) {
+  const { sql, bindings } = query.compile({ engine });
+  const records = await prisma.$queryRawUnsafe(
+    sql,
+    ...bindings
+  );
+  if (records.length > 0) {
+    const { sql: sql2, bindings: bindings2 } = query.compileCount({ engine, countExpr });
+    const result = await prisma.$queryRawUnsafe(sql2, ...bindings2);
+    const total = toSafeJsonValue(result[0].found_rows);
+    return { records, total, pagination: getPagination(query, total) };
+  } else {
+    return { records, total: 0, pagination: getPagination(query, 0) };
+  }
 }
+export {
+  Parser,
+  SelectBuilder,
+  extractGrouped,
+  extractIndexed,
+  extractLookup,
+  getPagination,
+  runMysql,
+  runMysqlAsync,
+  runMysqlAsyncWithCount,
+  runMysqlWithCount,
+  runPrisma,
+  runPrismaWithCount,
+  toSafeJsonRecord,
+  toSafeJsonRecords,
+  toSafeJsonString,
+  toSafeJsonValue
+};