@nocobase/plugin-collection-fdw 2.0.3

package/dist/node_modules/node-sql-parser/lib/func.js

@@ -0,0 +1,152 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./expr", "./util", "./over"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"), require("./util"), require("./over"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr, global.util, global.over);
+    global.func = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _util, _over) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.anyValueFuncToSQL = anyValueFuncToSQL;
+  _exports.castToSQL = castToSQL;
+  _exports.extractFunToSQL = extractFunToSQL;
+  _exports.flattenFunToSQL = flattenFunToSQL;
+  _exports.funcToSQL = funcToSQL;
+  _exports.tablefuncFunToSQL = tablefuncFunToSQL;
+  function anyValueFuncToSQL(stmt) {
+    const {
+      args,
+      type,
+      over
+    } = stmt;
+    const {
+      expr,
+      having
+    } = args;
+    let sql = `${(0, _util.toUpper)(type)}(${(0, _expr.exprToSQL)(expr)}`;
+    if (having) sql = `${sql} HAVING ${(0, _util.toUpper)(having.prefix)} ${(0, _expr.exprToSQL)(having.expr)}`;
+    sql = `${sql})`;
+    const overStr = (0, _over.overToSQL)(over);
+    return [sql, overStr].filter(_util.hasVal).join(' ');
+  }
+  function arrayDimensionToSymbol(target) {
+    if (!target || !target.array) return '';
+    switch (target.array) {
+      case 'one':
+        return '[]';
+      case 'two':
+        return '[][]';
+    }
+  }
+  function castToSQL(expr) {
+    const {
+      arrows = [],
+      collate,
+      target,
+      expr: expression,
+      keyword,
+      symbol,
+      as: alias,
+      properties = []
+    } = expr;
+    const {
+      length,
+      dataType,
+      parentheses,
+      quoted,
+      scale,
+      suffix: dataTypeSuffix
+    } = target;
+    let str = '';
+    if (length != null) str = scale ? `${length}, ${scale}` : length;
+    if (parentheses) str = `(${str})`;
+    if (dataTypeSuffix && dataTypeSuffix.length) str += ` ${dataTypeSuffix.join(' ')}`;
+    let prefix = (0, _expr.exprToSQL)(expression);
+    let symbolChar = '::';
+    let suffix = '';
+    if (symbol === 'as') {
+      prefix = `${(0, _util.toUpper)(keyword)}(${prefix}`;
+      suffix = ')';
+      symbolChar = ` ${symbol.toUpperCase()} `;
+    }
+    suffix += arrows.map((arrow, index) => (0, _util.commonOptionConnector)(arrow, _util.literalToSQL, properties[index])).join(' ');
+    if (alias) suffix += ` AS ${(0, _util.identifierToSql)(alias)}`;
+    if (collate) suffix += ` ${(0, _util.commonTypeValue)(collate).join(' ')}`;
+    const arrayDimension = arrayDimensionToSymbol(target);
+    const result = [prefix, symbolChar, quoted, dataType, quoted, arrayDimension, str, suffix];
+    return result.filter(_util.hasVal).join('');
+  }
+  function extractFunToSQL(stmt) {
+    const {
+      args,
+      type
+    } = stmt;
+    const {
+      field,
+      cast_type: castType,
+      source
+    } = args;
+    const result = [`${(0, _util.toUpper)(type)}(${(0, _util.toUpper)(field)}`, 'FROM', (0, _util.toUpper)(castType), (0, _expr.exprToSQL)(source)];
+    return `${result.filter(_util.hasVal).join(' ')})`;
+  }
+  function flattenArgToSQL(arg) {
+    if (!arg) return '';
+    const {
+      type,
+      symbol,
+      value
+    } = arg;
+    const result = [(0, _util.toUpper)(type), symbol, (0, _expr.exprToSQL)(value)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function flattenFunToSQL(stmt) {
+    const {
+      args,
+      type
+    } = stmt;
+    const keys = ['input', 'path', 'outer', 'recursive', 'mode'];
+    const argsStr = keys.map(key => flattenArgToSQL(args[key])).filter(_util.hasVal).join(', ');
+    return `${(0, _util.toUpper)(type)}(${argsStr})`;
+  }
+  function funcToSQL(expr) {
+    const {
+      args,
+      name,
+      args_parentheses,
+      parentheses,
+      over,
+      collate,
+      suffix
+    } = expr;
+    const collateStr = (0, _util.commonTypeValue)(collate).join(' ');
+    const overStr = (0, _over.overToSQL)(over);
+    const suffixStr = (0, _expr.exprToSQL)(suffix);
+    if (!args) return [name, overStr].filter(_util.hasVal).join(' ');
+    let separator = expr.separator || ', ';
+    if ((0, _util.toUpper)(name) === 'TRIM') separator = ' ';
+    let str = [name];
+    str.push(args_parentheses === false ? ' ' : '(');
+    str.push((0, _expr.exprToSQL)(args).join(separator));
+    if (args_parentheses !== false) str.push(')');
+    str = [str.join(''), suffixStr].filter(_util.hasVal).join(' ');
+    return [parentheses ? `(${str})` : str, collateStr, overStr].filter(_util.hasVal).join(' ');
+  }
+  function tablefuncFunToSQL(expr) {
+    const {
+      as,
+      name,
+      args
+    } = expr;
+    const result = [`${name}(${(0, _expr.exprToSQL)(args).join(', ')})`, 'AS', funcToSQL(as)];
+    return result.join(' ');
+  }
+});

package/dist/node_modules/node-sql-parser/lib/index-definition.js

@@ -0,0 +1,106 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./util", "./expr"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./util"), require("./expr"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.util, global.expr);
+    global.indexDefinition = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _util, _expr) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.indexDefinitionToSQL = indexDefinitionToSQL;
+  _exports.indexOptionListToSQL = indexOptionListToSQL;
+  _exports.indexOptionToSQL = indexOptionToSQL;
+  _exports.indexTypeAndOptionToSQL = indexTypeAndOptionToSQL;
+  _exports.indexTypeToSQL = indexTypeToSQL;
+  function indexTypeToSQL(indexType) {
+    if (!indexType) return [];
+    const {
+      keyword,
+      type
+    } = indexType;
+    return [keyword.toUpperCase(), (0, _util.toUpper)(type)];
+  }
+  function indexOptionToSQL(indexOpt) {
+    if (!indexOpt) return;
+    const {
+      type,
+      expr,
+      symbol
+    } = indexOpt;
+    const upperType = type.toUpperCase();
+    const indexOptArray = [];
+    indexOptArray.push(upperType);
+    switch (upperType) {
+      case 'KEY_BLOCK_SIZE':
+        if (symbol) indexOptArray.push(symbol);
+        indexOptArray.push((0, _util.literalToSQL)(expr));
+        break;
+      case 'BTREE':
+      case 'HASH':
+        indexOptArray.length = 0;
+        indexOptArray.push(...indexTypeToSQL(indexOpt));
+        break;
+      case 'WITH PARSER':
+        indexOptArray.push(expr);
+        break;
+      case 'VISIBLE':
+      case 'INVISIBLE':
+        break;
+      case 'COMMENT':
+        indexOptArray.shift();
+        indexOptArray.push((0, _util.commentToSQL)(indexOpt));
+        break;
+      case 'DATA_COMPRESSION':
+        indexOptArray.push(symbol, (0, _util.toUpper)(expr.value), (0, _util.onPartitionsToSQL)(expr.on));
+        break;
+      default:
+        indexOptArray.push(symbol, (0, _util.literalToSQL)(expr));
+        break;
+    }
+    return indexOptArray.filter(_util.hasVal).join(' ');
+  }
+  function indexOptionListToSQL(indexOptList) {
+    if (!indexOptList) return [];
+    return indexOptList.map(indexOptionToSQL);
+  }
+  function indexTypeAndOptionToSQL(indexDefinition) {
+    const {
+      constraint_type: constraintType,
+      index_type: indexType,
+      index_options: indexOptions = [],
+      definition,
+      on,
+      with: withExpr
+    } = indexDefinition;
+    const dataType = [];
+    dataType.push(...indexTypeToSQL(indexType));
+    if (definition && definition.length) {
+      const definitionSQL = (0, _util.toUpper)(constraintType) === 'CHECK' ? `(${(0, _expr.exprToSQL)(definition[0])})` : `(${definition.map(col => (0, _expr.exprToSQL)(col)).join(', ')})`;
+      dataType.push(definitionSQL);
+    }
+    dataType.push(indexOptionListToSQL(indexOptions).join(' '));
+    if (withExpr) dataType.push(`WITH (${indexOptionListToSQL(withExpr).join(', ')})`);
+    if (on) dataType.push(`ON [${on}]`);
+    return dataType;
+  }
+  function indexDefinitionToSQL(indexDefinition) {
+    const indexSQL = [];
+    const {
+      keyword,
+      index
+    } = indexDefinition;
+    indexSQL.push((0, _util.toUpper)(keyword));
+    indexSQL.push(index);
+    indexSQL.push(...indexTypeAndOptionToSQL(indexDefinition));
+    return indexSQL.filter(_util.hasVal).join(' ');
+  }
+});

package/dist/node_modules/node-sql-parser/lib/insert.js

@@ -0,0 +1,111 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./tables", "./expr", "./column", "./util", "./select", "./update"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./tables"), require("./expr"), require("./column"), require("./util"), require("./select"), require("./update"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.tables, global.expr, global.column, global.util, global.select, global.update);
+    global.insert = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _tables, _expr, _column, _util, _select, _update) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.conflictToSQL = conflictToSQL;
+  _exports.insertToSQL = insertToSQL;
+  _exports.valuesToSQL = valuesToSQL;
+  /**
+   * @param {Array} values
+   * @return {string}
+   */
+  function valuesToSQL(values) {
+    if (values.type === 'select') return (0, _select.selectToSQL)(values);
+    const clauses = values.map(_expr.exprToSQL);
+    return `(${clauses.join('), (')})`;
+  }
+  function partitionToSQL(partition) {
+    if (!partition) return '';
+    const partitionArr = ['PARTITION', '('];
+    if (Array.isArray(partition)) {
+      partitionArr.push(partition.map(_util.identifierToSql).join(', '));
+    } else {
+      const {
+        value
+      } = partition;
+      partitionArr.push(value.map(_expr.exprToSQL).join(', '));
+    }
+    partitionArr.push(')');
+    return partitionArr.filter(_util.hasVal).join('');
+  }
+  function conflictTargetToSQL(conflictTarget) {
+    if (!conflictTarget) return '';
+    const {
+      type
+    } = conflictTarget;
+    switch (type) {
+      case 'column':
+        return `(${conflictTarget.expr.map(_column.columnRefToSQL).join(', ')})`;
+    }
+  }
+  function conflictActionToSQL(conflictAction) {
+    const {
+      expr,
+      keyword
+    } = conflictAction;
+    const {
+      type
+    } = expr;
+    const result = [(0, _util.toUpper)(keyword)];
+    switch (type) {
+      case 'origin':
+        result.push((0, _util.literalToSQL)(expr));
+        break;
+      case 'update':
+        result.push('UPDATE', (0, _util.commonOptionConnector)('SET', _update.setToSQL, expr.set), (0, _util.commonOptionConnector)('WHERE', _expr.exprToSQL, expr.where));
+        break;
+    }
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function conflictToSQL(conflict) {
+    if (!conflict) return '';
+    const {
+      action,
+      target
+    } = conflict;
+    const result = [conflictTargetToSQL(target), conflictActionToSQL(action)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function insertToSQL(stmt) {
+    const {
+      table,
+      type,
+      prefix = 'into',
+      columns,
+      conflict,
+      values,
+      where,
+      on_duplicate_update: onDuplicateUpdate,
+      partition,
+      returning,
+      set
+    } = stmt;
+    const {
+      keyword,
+      set: duplicateSet
+    } = onDuplicateUpdate || {};
+    const clauses = [(0, _util.toUpper)(type), (0, _util.toUpper)(prefix), (0, _tables.tablesToSQL)(table), partitionToSQL(partition)];
+    if (Array.isArray(columns)) clauses.push(`(${columns.map(_util.identifierToSql).join(', ')})`);
+    clauses.push((0, _util.commonOptionConnector)(Array.isArray(values) ? 'VALUES' : '', valuesToSQL, values));
+    clauses.push((0, _util.commonOptionConnector)('ON CONFLICT', conflictToSQL, conflict));
+    clauses.push((0, _util.commonOptionConnector)('SET', _update.setToSQL, set));
+    clauses.push((0, _util.commonOptionConnector)('WHERE', _expr.exprToSQL, where));
+    clauses.push((0, _util.returningToSQL)(returning));
+    clauses.push((0, _util.commonOptionConnector)(keyword, _update.setToSQL, duplicateSet));
+    return clauses.filter(_util.hasVal).join(' ');
+  }
+});

package/dist/node_modules/node-sql-parser/lib/interval.js

@@ -0,0 +1,28 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./util", "./expr"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./util"), require("./expr"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.util, global.expr);
+    global.interval = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _util, _expr) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.intervalToSQL = intervalToSQL;
+  function intervalToSQL(intervalExpr) {
+    const {
+      expr,
+      unit
+    } = intervalExpr;
+    const result = ['INTERVAL', (0, _expr.exprToSQL)(expr), (0, _util.toUpper)(unit)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+});

package/dist/node_modules/node-sql-parser/lib/json.js

@@ -0,0 +1,28 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./expr", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr, global.util);
+    global.json = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.jsonExprToSQL = jsonExprToSQL;
+  function jsonExprToSQL(expr) {
+    const {
+      keyword,
+      expr_list: exprList
+    } = expr;
+    const result = [(0, _util.toUpper)(keyword), exprList.map(exprItem => (0, _expr.exprToSQL)(exprItem)).join(', ')].join(' ');
+    return result;
+  }
+});

package/dist/node_modules/node-sql-parser/lib/limit.js

@@ -0,0 +1,45 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./util", "./expr"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./util"), require("./expr"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.util, global.expr);
+    global.limit = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _util, _expr) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.limitToSQL = limitToSQL;
+  function composePrefixValSuffix(stmt) {
+    if (!stmt) return [];
+    return [(0, _util.toUpper)(stmt.prefix), (0, _expr.exprToSQL)(stmt.value), (0, _util.toUpper)(stmt.suffix)];
+  }
+  function fetchOffsetToSQL(stmt) {
+    const {
+      fetch,
+      offset
+    } = stmt;
+    const result = [...composePrefixValSuffix(offset), ...composePrefixValSuffix(fetch)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function limitOffsetToSQL(limit) {
+    const {
+      seperator,
+      value
+    } = limit;
+    if (value.length === 1 && seperator === 'offset') return (0, _util.connector)('OFFSET', (0, _expr.exprToSQL)(value[0]));
+    return (0, _util.connector)('LIMIT', value.map(_expr.exprToSQL).join(`${seperator === 'offset' ? ' ' : ''}${(0, _util.toUpper)(seperator)} `));
+  }
+  function limitToSQL(limit) {
+    if (!limit) return '';
+    if (limit.fetch) return fetchOffsetToSQL(limit);
+    return limitOffsetToSQL(limit);
+  }
+});

package/dist/node_modules/node-sql-parser/lib/over.js

@@ -0,0 +1,39 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./util", "./expr", "./window"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./util"), require("./expr"), require("./window"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.util, global.expr, global.window);
+    global.over = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _util, _expr, _window) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.overToSQL = overToSQL;
+  function overToSQL(over) {
+    if (!over) return;
+    const {
+      as_window_specification: asWindowSpec,
+      expr,
+      keyword,
+      type,
+      parentheses
+    } = over;
+    const upperType = (0, _util.toUpper)(type);
+    if (upperType === 'WINDOW') return `OVER ${(0, _window.asWindowSpecToSQL)(asWindowSpec)}`;
+    if (upperType === 'ON UPDATE') {
+      let onUpdate = `${(0, _util.toUpper)(type)} ${(0, _util.toUpper)(keyword)}`;
+      const args = (0, _expr.exprToSQL)(expr) || [];
+      if (parentheses) onUpdate = `${onUpdate}(${args.join(', ')})`;
+      return onUpdate;
+    }
+    throw new Error('unknown over type');
+  }
+});

package/dist/node_modules/node-sql-parser/lib/parser.all.js

@@ -0,0 +1,33 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../pegjs/bigquery.pegjs", "../pegjs/db2.pegjs", "../pegjs/hive.pegjs", "../pegjs/mysql.pegjs", "../pegjs/mariadb.pegjs", "../pegjs/postgresql.pegjs", "../pegjs/sqlite.pegjs", "../pegjs/transactsql.pegjs", "../pegjs/flinksql.pegjs", "../pegjs/snowflake.pegjs", "../pegjs/noql.pegjs"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../pegjs/bigquery.pegjs"), require("../pegjs/db2.pegjs"), require("../pegjs/hive.pegjs"), require("../pegjs/mysql.pegjs"), require("../pegjs/mariadb.pegjs"), require("../pegjs/postgresql.pegjs"), require("../pegjs/sqlite.pegjs"), require("../pegjs/transactsql.pegjs"), require("../pegjs/flinksql.pegjs"), require("../pegjs/snowflake.pegjs"), require("../pegjs/noql.pegjs"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.bigquery, global.db2, global.hive, global.mysql, global.mariadb, global.postgresql, global.sqlite, global.transactsql, global.flinksql, global.snowflake, global.noql);
+    global.parserAll = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _bigquery, _db, _hive, _mysql, _mariadb, _postgresql, _sqlite, _transactsql, _flinksql, _snowflake, _noql) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  var _default = _exports.default = {
+    bigquery: _bigquery.parse,
+    db2: _db.parse,
+    hive: _hive.parse,
+    mysql: _mysql.parse,
+    mariadb: _mariadb.parse,
+    postgresql: _postgresql.parse,
+    snowflake: _snowflake.parse,
+    sqlite: _sqlite.parse,
+    transactsql: _transactsql.parse,
+    flinksql: _flinksql.parse,
+    noql: _noql.parse
+  };
+});

package/dist/node_modules/node-sql-parser/lib/parser.js

@@ -0,0 +1,82 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./expr", "./parser.all", "./sql", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"), require("./parser.all"), require("./sql"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr, global.parser, global.sql, global.util);
+    global.parser = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _parser, _sql, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _parser = _interopRequireDefault(_parser);
+  _sql = _interopRequireDefault(_sql);
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  class Parser {
+    astify(sql, opt = _util.DEFAULT_OPT) {
+      const astInfo = this.parse(sql, opt);
+      return astInfo && astInfo.ast;
+    }
+    sqlify(ast, opt = _util.DEFAULT_OPT) {
+      (0, _util.setParserOpt)(opt);
+      return (0, _sql.default)(ast, opt);
+    }
+    exprToSQL(expr, opt = _util.DEFAULT_OPT) {
+      (0, _util.setParserOpt)(opt);
+      return (0, _expr.exprToSQL)(expr);
+    }
+    parse(sql, opt = _util.DEFAULT_OPT) {
+      const {
+        database = PARSER_NAME || 'mysql'
+      } = opt;
+      (0, _util.setParserOpt)(opt);
+      const typeCase = database.toLowerCase();
+      if (_parser.default[typeCase]) return _parser.default[typeCase](sql.trim(), opt.parseOptions || _util.DEFAULT_OPT.parseOptions);
+      throw new Error(`${database} is not supported currently`);
+    }
+    whiteListCheck(sql, whiteList, opt = _util.DEFAULT_OPT) {
+      if (!whiteList || whiteList.length === 0) return;
+      const {
+        type = 'table'
+      } = opt;
+      if (!this[`${type}List`] || typeof this[`${type}List`] !== 'function') throw new Error(`${type} is not valid check mode`);
+      const checkFun = this[`${type}List`].bind(this);
+      const authorityList = checkFun(sql, opt);
+      let hasAuthority = true;
+      let denyInfo = '';
+      for (const authority of authorityList) {
+        let hasCorrespondingAuthority = false;
+        for (const whiteAuthority of whiteList) {
+          const regex = new RegExp(whiteAuthority, 'i');
+          if (regex.test(authority)) {
+            hasCorrespondingAuthority = true;
+            break;
+          }
+        }
+        if (!hasCorrespondingAuthority) {
+          denyInfo = authority;
+          hasAuthority = false;
+          break;
+        }
+      }
+      if (!hasAuthority) throw new Error(`authority = '${denyInfo}' is required in ${type} whiteList to execute SQL = '${sql}'`);
+    }
+    tableList(sql, opt) {
+      const astInfo = this.parse(sql, opt);
+      return astInfo && astInfo.tableList;
+    }
+    columnList(sql, opt) {
+      const astInfo = this.parse(sql, opt);
+      return astInfo && astInfo.columnList;
+    }
+  }
+  var _default = _exports.default = Parser;
+});

package/dist/node_modules/node-sql-parser/lib/parser.single.js

@@ -0,0 +1,23 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../pegjs/mysql.pegjs"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../pegjs/mysql.pegjs"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.mysql);
+    global.parserSingle = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _mysql) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  var _default = _exports.default = {
+    [PARSER_NAME]: _mysql.parse
+  };
+});