sql-love 1.0.4 → 1.0.5

package/dist/index.cjs

@@ -1,16 +1,1328 @@
-var m=Object.defineProperty;var L=Object.getOwnPropertyDescriptor;var U=Object.getOwnPropertyNames;var A=Object.prototype.hasOwnProperty;var j=(i,t)=>{for(var e in t)m(i,e,{get:t[e],enumerable:!0})},D=(i,t,e,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of U(t))!A.call(i,s)&&s!==e&&m(i,s,{get:()=>t[s],enumerable:!(n=L(t,s))||n.enumerable});return i};var F=i=>D(m({},"__esModule",{value:!0}),i);var P={};j(P,{Parser:()=>c,SelectBuilder:()=>d,extractGrouped:()=>S,extractIndexed:()=>E,extractLookup:()=>R,getPagination:()=>g,runMysql:()=>N,runMysqlAsync:()=>$,runMysqlAsyncWithCount:()=>I,runMysqlWithCount:()=>B,runPrisma:()=>x,runPrismaWithCount:()=>q,toSafeJsonRecord:()=>T,toSafeJsonRecords:()=>C,toSafeJsonString:()=>w,toSafeJsonValue:()=>p});module.exports=F(P);var c=class{query;constructor(t){this.query=t}_stripComments(t){return t=t.replace(/\/\*[\s\S]*?\*\//g,""),t=t.replace(/--([\r\n]|\s+[^\r\n]+[\r\n])/g,""),t=t.replace(/#[^\r\n]+[\r\n]/g,""),t}_extractSubQueries(t){let e={},n=0,s=r=>{let o=`~~SUBQUERY_${n++}~~`;return e[o]=r,o};return t=t.replace(/\(\s*SELECT\s+.+\)\s+AS\s+[^\s,]+/,s),t=t.replace(/\bIF\s*\(.+\)\s+AS\s+[^\s,]+/,s),t=t.replace(/\bIN\s*\(\s*SELECT\s.+?\)/,s),{sql:t,subQueries:e}}_injectSubQueries(t){let e=s=>t[s]||s,n=s=>s.replace(/~~SUBQUERY_\d+~~/g,e);this.query._columns=this.query._columns.map(e),this.query._joins=this.query._joins.map(n),this.query._wheres=this.query._wheres.map(n),this.query._havings=this.query._havings.map(n)}_split(t){let e=/(?:^|\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 t.split(e)}parse(t){let e=this._stripComments(t),{sql:n,subQueries:s}=this._extractSubQueries(e),r=this._split(n),o=1;for(;o<r.length;){let l=r[o++].trim().toUpperCase().replace(/\s+/g,"_"),h=r[o++].trim(),a=`_handle${l}`;this[a](h)}return this._injectSubQueries(s),!0}_handleSELECT(t){let e=t.split(/s*,s*/),n="";e.forEach((s,r)=>{if(r===0){let o=/^(SQL_CALC_FOUND_ROWS)\s+/i,u=s.match(o);u&&(this.query.option(u[1]),s=s.replace(o,""))}n.length?s.indexOf(")")>0?(n+=s,this.query.column(n.trim()),n=""):n+=s+",":s.match(/\([^)]+$/)?n=s+",":this.query.column(s.trim())})}_handleFROM(t){t.split(/\s*,\s*/).forEach(n=>this.query.table(n))}_handleINNER_JOIN(t){this.query.innerJoin(t)}_handleLEFT_JOIN(t){this.query.leftJoin(t)}_handleLEFT_OUTER_JOIN(t){this.query.leftOuterJoin(t)}_handleRIGHT_JOIN(t){this.query.rightJoin(t)}_handleRIGHT_OUTER_JOIN(t){this.query.rightOuterJoin(t)}_handleCROSS_JOIN(t){this.query.crossJoin(t)}_handleFULL_JOIN(t){this.query.fullJoin(t)}_handleFULL_OUTER_JOIN(t){this.query.fullOuterJoin(t)}_handleWHERE(t){/^(1|'1'|true)$/i.test(t)?this.query._wheres.push(t):this._handleConditions("where",t)}_handleHAVING(t){this._handleConditions("having",t)}_handleConditions(t,e){e.split(/\bAND\b/i).forEach(s=>{let r=s.split(/\bOR\b/i).map(o=>o.trim());if(r.length===1){let o=t;this.query[o](r[0])}else{let o=t==="where"?"orWhere":"orHaving";this.query[o](r.map(u=>[u]))}})}_handleGROUP_BY(t){t.split(/\s*,\s*/).forEach(n=>this.query.groupBy(n))}_handleORDER_BY(t){t.split(/\s*,\s*/).forEach(n=>this.query.orderBy(n))}_handleLIMIT(t){let e=t.match(/^(\d+|\?|:\w+)\s*,\s*(\d+|\?|:\w+)$/);e?(this.query.offset(e[1]),this.query.limit(e[2])):(t=t.replace(/ ROWS$/i,""),this.query.limit(t))}_handleOFFSET(t){t=t.replace(/^(\d+) ROWS$/i,"$1"),this.query.offset(t)}_handleFETCH_NEXT(t){t=t.replace(/^(\d+) ROWS ONLY$/i,"$1"),this.query.limit(t)}};function b(i,t){let e=0,n=i.indexOf(t);for(;n!==-1;)e+=1,n=i.indexOf(t,n+1);return e}var _=i=>i==null||i===!1||isNaN(i),y="mysql",d=class i{_bindings=[];_options=[];_tables=[];_columns=[];_joins=[];_wheres=[];_groupBys=[];_havings=[];_orderBys=[];_limit;_offset;_page;constructor(t=null,e=null){if(t){if(e){let n=Object.keys(e),s=new RegExp(`:(${n.join("|")})`,"g");t=t.replace(s,(r,o)=>(this._bindings.push(e[o]),`__BOUND_${this._bindings.length-1}__`))}new c(this).parse(t)}}static setDefaultEngine(t){return y=t,i}compile({engine:t=y,bindingIndex:e=1}={}){let n=["SELECT",this._options.length?`  ${this._options.join(`
-  `)}`:null,this._columns.length?`  ${this._columns.join(`,
-  `)}`:`  *
-`,`FROM ${this._tables.join(", ")}`,this._joins.length?this._joins.join(`
-`):null,this._wheres.length?`WHERE ${this._wheres.join(`
-  AND `)}`:null,this._groupBys.length?`GROUP BY ${this._groupBys.join(`,
-  `)}`:null,this._havings.length?`HAVING ${this._havings.join(`
-  AND `)}`:null,this._orderBys.length?`ORDER BY ${this._orderBys.join(`,
-  `)}`:null];if(this._page>0){let l=(this._page-1)*this._limit;n.push(this._compileOFFSET(t,l)),n.push(this._compileLIMIT(t,this._limit))}else this._offset&&n.push(this._compileOFFSET(t,this._offset)),this._limit&&n.push(this._compileLIMIT(t,this._limit));let s=n.filter(Boolean).join(`
-`).trim(),r,o=[];if(t==="pg"){let l=e;r=(h,a)=>(o.push(this._bindings[a]),"$"+l++)}else r=(l,h)=>(o.push(this._bindings[h]),"?");return{sql:s.replace(/__BOUND_(\d+)__/g,r),bindings:o}}_compileLIMIT(t,e){if(t==="pg"||t==="mysql")return`LIMIT ${e}`;if(t==="mssql")return`FETCH NEXT ${e} ROWS ONLY`}_compileOFFSET(t,e){if(t==="pg"||t==="mysql")return`OFFSET ${e}`;if(t==="mssql"||t==="oracle")return`OFFSET ${e} ROWS`}compileCount({countExpr:t="*",engine:e=y,bindingIndex:n=1}={}){let s=this.getFoundRowsQuery(t),{sql:r,bindings:o}=s.compile({engine:e,bindingIndex:n});return this._havings.length===0?{sql:r,bindings:o}:{sql:`SELECT COUNT(*) AS found_rows
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  Parser: () => Parser,
+  SelectBuilder: () => SelectBuilder,
+  extractGrouped: () => extractGrouped,
+  extractIndexed: () => extractIndexed,
+  extractLookup: () => extractLookup,
+  getPagination: () => getPagination,
+  runMysql: () => runMysql,
+  runMysqlAsync: () => runMysqlAsync,
+  runMysqlAsyncWithCount: () => runMysqlAsyncWithCount,
+  runMysqlWithCount: () => runMysqlWithCount,
+  runPrisma: () => runPrisma,
+  runPrismaWithCount: () => runPrismaWithCount,
+  toSafeJsonRecord: () => toSafeJsonRecord,
+  toSafeJsonRecords: () => toSafeJsonRecords,
+  toSafeJsonString: () => toSafeJsonString,
+  toSafeJsonValue: () => toSafeJsonValue
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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);
+  }
+};
+
+// 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;
+}
+
+// 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 = [];
+  /**
+   * 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
+  } = {}) {
+    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	");
+      return {
+        sql: `SELECT COUNT(*) AS found_rows
 FROM (
-${r.replace(/\n/g,`
-	`)}
-) AS subquery_results`,bindings:o}}compileUnion(t,{engine:e=y,bindingIndex:n=1}={}){let s=this.compile({engine:e,bindingIndex:n}),r=t.compile({engine:e,bindingIndex:s.bindings.length+n});return{sql:`(${s.sql})
+${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, {
+    engine = defaultEngine,
+    bindingIndex = 1
+  } = {}) {
+    const first = this.compile({ engine, bindingIndex });
+    const second = query.compile({
+      engine,
+      bindingIndex: first.bindings.length + bindingIndex
+    });
+    return {
+      sql: `(${first.sql})
 UNION
-(${r.sql})`,bindings:[...s.bindings,...r.bindings]}}reset(t=null){if(Array.isArray(t))return t.forEach(e=>this.reset(e)),this;if(t){let e=["option","column","table","where","having","groupBy","orderBy"],n="_"+t.replace(/s$/,"");e.indexOf(t)>-1&&(n+="s");let s=["limit","offset","page"].indexOf(t)>-1;this[n]=s?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}getClone(){let t=new i;return t._options=[...this._options],t._columns=[...this._columns],t._tables=[...this._tables],t._joins=[...this._joins],t._wheres=[...this._wheres],t._havings=[...this._havings],t._groupBys=[...this._groupBys],t._orderBys=[...this._orderBys],t._limit=this._limit,t._offset=this._offset,t._page=this._page,t._bindings=[...this._bindings],t}getFoundRowsQuery(t="*"){if(this._havings.length===0){let e=this.getClone();return e._columns=[`COUNT(${t}) AS found_rows`],e._options=[],e._groupBys=[],e._orderBys=[],e._limit=null,e._offset=null,e._page=null,e}else{let e=this.getClone();return e._limit=null,e._offset=null,e._page=null,e}}select(t){return this._columns=this._columns.concat(t),this}columns(t){return this._columns=this._columns.concat(t),this}column(t){return this._columns.push(t),this}option(t){return this._options.push(t),this}table(t){return this._tables.push(t),this}tables(t){return this._tables.push(...t),this}from(t){return this._tables.push(t),this}_addJoin(t,e,n=[]){n.length>0&&(e=e.replace(/\?/g,()=>(this._bindings.push(n.shift()),`__BOUND_${this._bindings.length-1}__`))),this._joins.push(`${t} ${e}`)}join(t,e=[]){return this._addJoin("JOIN",t,e),this}leftJoin(t,e=[]){return this._addJoin("LEFT JOIN",t,e),this}fullJoin(t,e=[]){return this._addJoin("FULL JOIN",t,e),this}rightJoin(t,e=[]){return this._addJoin("RIGHT JOIN",t,e),this}crossJoin(t,e=[]){return this._addJoin("CROSS JOIN",t,e),this}innerJoin(t,e=[]){return this._addJoin("INNER JOIN",t,e),this}leftOuterJoin(t,e=[]){return this._addJoin("LEFT OUTER JOIN",t,e),this}fullOuterJoin(t,e=[]){return this._addJoin("FULL OUTER JOIN",t,e),this}rightOuterJoin(t,e=[]){return this._addJoin("RIGHT OUTER JOIN",t,e),this}unjoin(t){return Array.isArray(t)?(t.forEach(e=>this.unjoin(e)),this):(this._joins=this._joins.filter(e=>!new RegExp(`JOIN ${t}\\b`).test(e)),this)}_conditions(t,e){let n=e.length,[s,r,o]=e;if(typeof s=="object"){for(let l of Object.entries(s))this._conditions(t,l);return this}if(n===1)return t.push(s),this;if(n===2&&Array.isArray(r)&&r.length>0&&b(s,"?")===r.length){let l=r,h=s.replace(/\?/g,()=>(this._bindings.push(l.shift()),`__BOUND_${this._bindings.length-1}__`));return t.push(h),this}else if(n===2){o=r;let l=s.split(" ");s=l.shift(),r=l.join(" ")}(typeof r!="string"||r==="")&&(r="="),r=r.toLocaleUpperCase();let u=r.match(/^(LIKE|NOT LIKE|ILIKE|NOT ILIKE)(?: (\?|\?%|%\?|%\?%))?$/i);if(r==="NOT BETWEEN"||r==="BETWEEN"){let l=this._bindings.length,h=this._bindings.length+1;t.push(`${s} ${r} __BOUND_${l}__ AND __BOUND_${h}__`),this._bindings.push(o[0],o[1])}else if(u){let l=u[1].toUpperCase(),h=u[2]||"?";if(Array.isArray(o)){let a=[];for(let J of o)a.push(`${s} ${l} __BOUND_${this._bindings.length}__`),this._bindings.push(h.replace("?",J));let f=a.join(" OR ");t.push(`(${f})`)}else t.push(`${s} ${l} __BOUND_${this._bindings.length}__`),this._bindings.push(h.replace("?",o||""))}else if(o===null)t.push(r==="="?`${s} IS NULL`:`${s} IS NOT NULL`);else if(Array.isArray(o)){let l=[];for(let a=0;a<o.length;a++)l.push(`__BOUND_${this._bindings.length}__`),this._bindings.push(o[a]);let h=l.join(", ");t.push(r==="="||r==="IN"?`${s} IN(${h})`:`${s} NOT IN(${h})`)}else r==="IN"||r==="NOT IN"?(t.push(`${s} ${r}(__BOUND_${this._bindings.length}__)`),this._bindings.push(o)):(t.push(`${s} ${r} __BOUND_${this._bindings.length}__`),this._bindings.push(o));return this}groupBy(t){return this._groupBys.push(t),this}where(...t){return this._conditions(this._wheres,t),this}whereBetween(t,e){return!_(e[0])&&!_(e[1])?this.where(t,"BETWEEN",e):!_(e[0])&&_(e[1])?this.where(t,">=",e[0]):_(e[0])&&!_(e[1])&&this.where(t,"<=",e[1]),this}_orConditions(t){let e=[];if(Array.isArray(t))for(let s of t)Array.isArray(s)?this._conditions(e,s):this._conditions(e,[s]);else for(let[s,r]of Object.entries(t)){let o=[];this._conditions(o,[s,r]),e.push(o[0])}let n=e.join(" OR ");return n.startsWith("(")&&n.endsWith(")")?n.slice(1,-1):n}orWhere(t){let e=this._orConditions(t);return this.where(`(${e})`),this}orHaving(t){let e=this._orConditions(t);return this.having(`(${e})`),this}having(...t){return this._conditions(this._havings,t),this}orderBy(t,e=null){if(e)this._orderBys.push(`${t} ${e}`);else{let n=t.replace(/^-(.+)/,"$1 DESC");this._orderBys.push(n)}return this}sortField(t,e={}){let n="ASC";t.startsWith("-")&&(n="DESC",t=t.slice(1));let s=e[t]||t;return this.orderBy(s,n),this}_isEntirelyDigits(t){return/^(0|[1-9]\d*)$/.test(t)}_isEntirelyDigitsNoZeros(t){return/^[1-9]\d*$/.test(t)}limit(t){if(typeof t=="string")t=t.trim(),this._isEntirelyDigitsNoZeros(t)&&(this._limit=parseInt(t,10));else if(typeof t=="number"&&Number.isInteger(t)&&t>=1)this._limit=t;else throw new Error(`SelectBuilder: "limit(n)" must receive a positive integer (got "${t}")`);return this}offset(t){if(typeof t=="string"&&this._isEntirelyDigits(t.trim()))this._offset=parseInt(t,10);else if(typeof t=="number"&&Number.isInteger(t)&&t>=0)this._offset=t;else throw new Error(`SelectBuilder: "offset(n)" must receive a positive integer (got "${t}")`);return this}page(t){if(typeof t=="string"&&this._isEntirelyDigitsNoZeros(t.trim()))this._page=parseInt(t,10);else if(typeof t=="number"&&Number.isInteger(t)&&t>=1)this._page=t;else throw new Error('SelectBuilder: "page(n)" must receive a positive integer');return this}};function S(i,t){let e=0,n={};for(let s of t){if(!(i in s))throw new Error(`Column "${String(i)}" is not present in record ${e}`);n[s[i]]||(n[s[i]]=[]),n[s[i]].push(s),e++}return n}function E(i,t){let e=0,n={};for(let s of t){if(!(i in s))throw new Error(`Column "${String(i)}" is not present in record ${e}`);n[s[i]]=s,e++}return n}function R(i,t,e){let n={},s=0;for(let r of e){if(!(i in r))throw new Error(`Column "${String(i)}" is not present in record ${s}`);if(!(t in r))throw new Error(`Column "${String(t)}" is not present in record ${s}`);s++,n[String(r[i])]=r[t]}return n}function g(i,t){t=Number(t)||0;let e=Number(i._limit)||null,n=null;t===0?n=null:i._page?n=Number(i._page):i._limit&&i._offset?n=Math.floor(Number(i._offset)/Number(i._limit))+1:i._limit&&!i._offset?n=1:n=null;let s=t===0||e===null?0:Math.ceil(t/e)||0,r=n===1,o=s>0&&n===s,u=s===0?null:n-1||null,l=s>0&&n+1<=s?n+1:null;return{page:n,prevPage:u,nextPage:l,perPage:e,numPages:s,total:t,isFirst:r,isLast:o}}function O(i,t,e){return new Promise((n,s)=>{i.query(t,e,(r,o,u)=>{if(r){s(r);return}n([o,u])})})}async function N(i,t){let{sql:e,bindings:n}=t.compile({engine:"mysql"});return O(i,e,n)}async function B(i,t,{countExpr:e="*"}={}){let{sql:n,bindings:s}=t.compile({engine:"mysql"}),[r,o]=await O(i,n,s);if(r.length>0){let{sql:u,bindings:l}=t.compileCount({engine:"mysql",countExpr:e}),[h]=await O(i,u,l),a=h[0].found_rows;return{records:r,total:a,pagination:g(t,a),fields:o}}else return{records:r,total:0,pagination:g(t,0),fields:o}}async function $(i,t){let{sql:e,bindings:n}=t.compile({engine:"mysql"});return i.query(e,n)}async function I(i,t,{engine:e="mysql",countExpr:n="*"}={}){let{sql:s,bindings:r}=t.compile({engine:e}),[o,u]=await i.query(s,r);if(o.length>0){let{sql:l,bindings:h}=t.compileCount({engine:e,countExpr:n}),[a]=await i.query(l,h),f=a[0].found_rows;return{records:o,total:f,pagination:g(t,f),fields:u}}else return{records:o,total:0,pagination:g(t,0),fields:u}}function p(i){if(typeof i=="bigint"){let t=Number(i);return i==t?t:i.toString()}return i}function T(i){let t={};for(let e in i)Object.prototype.hasOwnProperty.call(i,e)&&(t[e]=p(i[e]));return t}function C(i){return i.map(T)}function w(i){return JSON.stringify(i,(t,e)=>p(e))}async function x(i,t,{engine:e=void 0}={}){let{sql:n,bindings:s}=t.compile({engine:e});return i.$queryRawUnsafe(n,...s)}async function q(i,t,{engine:e=void 0,countExpr:n="*"}={}){let{sql:s,bindings:r}=t.compile({engine:e}),o=await i.$queryRawUnsafe(s,...r);if(o.length>0){let{sql:u,bindings:l}=t.compileCount({engine:e,countExpr:n}),h=await i.$queryRawUnsafe(u,...l),a=p(h[0].found_rows);return{records:o,total:a,pagination:g(t,a)}}else return{records:o,total:0,pagination:g(t,0)}}0&&(module.exports={Parser,SelectBuilder,extractGrouped,extractIndexed,extractLookup,getPagination,runMysql,runMysqlAsync,runMysqlAsyncWithCount,runMysqlWithCount,runPrisma,runPrismaWithCount,toSafeJsonRecord,toSafeJsonRecords,toSafeJsonString,toSafeJsonValue});
+(${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) {
+      collection.push(column);
+      return this;
+    } 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());
+        return `__BOUND_${this._bindings.length - 1}__`;
+      });
+      collection.push(sql);
+      return this;
+    } else if (numArgs === 2) {
+      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") {
+      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();
+      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));
+        }
+        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)) {
+      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") {
+      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 {
+    }
+    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(")")) {
+      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)) {
+        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())) {
+      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())) {
+      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;
+  }
+};
+
+// 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) };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Parser,
+  SelectBuilder,
+  extractGrouped,
+  extractIndexed,
+  extractLookup,
+  getPagination,
+  runMysql,
+  runMysqlAsync,
+  runMysqlAsyncWithCount,
+  runMysqlWithCount,
+  runPrisma,
+  runPrismaWithCount,
+  toSafeJsonRecord,
+  toSafeJsonRecords,
+  toSafeJsonString,
+  toSafeJsonValue
+});