@tachybase/module-collection 1.6.25 → 1.6.26

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 [stmt.prefix.map(_util.literalToSQL).join(' '), (0, _expr.exprToSQL)(stmt.value), stmt.suffix.map(_util.literalToSQL).join(' ')];
+  }
+  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 || limit.offset) 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,36 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../pegjs/athena.pegjs", "../pegjs/bigquery.pegjs", "../pegjs/db2.pegjs", "../pegjs/flinksql.pegjs", "../pegjs/hive.pegjs", "../pegjs/mysql.pegjs", "../pegjs/mariadb.pegjs", "../pegjs/noql.pegjs", "../pegjs/postgresql.pegjs", "../pegjs/redshift.pegjs", "../pegjs/sqlite.pegjs", "../pegjs/transactsql.pegjs", "../pegjs/snowflake.pegjs", "../pegjs/trino.pegjs"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../pegjs/athena.pegjs"), require("../pegjs/bigquery.pegjs"), require("../pegjs/db2.pegjs"), require("../pegjs/flinksql.pegjs"), require("../pegjs/hive.pegjs"), require("../pegjs/mysql.pegjs"), require("../pegjs/mariadb.pegjs"), require("../pegjs/noql.pegjs"), require("../pegjs/postgresql.pegjs"), require("../pegjs/redshift.pegjs"), require("../pegjs/sqlite.pegjs"), require("../pegjs/transactsql.pegjs"), require("../pegjs/snowflake.pegjs"), require("../pegjs/trino.pegjs"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.athena, global.bigquery, global.db2, global.flinksql, global.hive, global.mysql, global.mariadb, global.noql, global.postgresql, global.redshift, global.sqlite, global.transactsql, global.snowflake, global.trino);
+    global.parserAll = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _athena, _bigquery, _db, _flinksql, _hive, _mysql, _mariadb, _noql, _postgresql, _redshift, _sqlite, _transactsql, _snowflake, _trino) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  var _default = _exports.default = {
+    athena: _athena.parse,
+    bigquery: _bigquery.parse,
+    db2: _db.parse,
+    flinksql: _flinksql.parse,
+    hive: _hive.parse,
+    mysql: _mysql.parse,
+    mariadb: _mariadb.parse,
+    noql: _noql.parse,
+    postgresql: _postgresql.parse,
+    redshift: _redshift.parse,
+    snowflake: _snowflake.parse,
+    sqlite: _sqlite.parse,
+    transactsql: _transactsql.parse,
+    trino: _trino.parse
+  };
+});

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

@@ -0,0 +1,88 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./column", "./expr", "./parser.all", "./sql", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./column"), require("./expr"), require("./parser.all"), require("./sql"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.column, global.expr, global.parser, global.sql, global.util);
+    global.parser = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _column, _expr, _parser, _sql, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _parser = _interopRequireDefault(_parser);
+  _sql = _interopRequireDefault(_sql);
+  function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+  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);
+    }
+    columnsToSQL(columns, tables, opt = _util.DEFAULT_OPT) {
+      (0, _util.setParserOpt)(opt);
+      if (!columns || columns === '*') return [];
+      const isDual = (0, _column.getDual)(tables);
+      return columns.map(col => (0, _column.columnToSQL)(col, isDual));
+    }
+    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](opt.trimQuery === false ? sql : 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
+  };
+});

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

@@ -0,0 +1,39 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./assign", "./expr", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./assign"), require("./expr"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.assign, global.expr, global.util);
+    global.proc = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _assign, _expr, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.procToSQL = procToSQL;
+  _exports.returnToSQL = returnToSQL;
+  function returnToSQL(stmt) {
+    const {
+      type,
+      expr
+    } = stmt;
+    return [(0, _util.toUpper)(type), (0, _expr.exprToSQL)(expr)].join(' ');
+  }
+  function procToSQL(expr) {
+    const {
+      stmt
+    } = expr;
+    switch (stmt.type) {
+      case 'assign':
+        return (0, _assign.assignToSQL)(stmt);
+      case 'return':
+        return returnToSQL(stmt);
+    }
+  }
+});

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

@@ -0,0 +1,138 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./expr", "./column", "./limit", "./with", "./tables", "./util", "./collate"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"), require("./column"), require("./limit"), require("./with"), require("./tables"), require("./util"), require("./collate"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr, global.column, global.limit, global._with, global.tables, global.util, global.collate);
+    global.select = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _column, _limit, _with, _tables, _util, _collate) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.selectIntoToSQL = selectIntoToSQL;
+  _exports.selectToSQL = selectToSQL;
+  function distinctToSQL(distinct) {
+    if (!distinct) return;
+    if (typeof distinct === 'string') return distinct;
+    const {
+      type,
+      columns
+    } = distinct;
+    const result = [(0, _util.toUpper)(type)];
+    if (columns) result.push(`(${columns.map(_expr.exprToSQL).join(', ')})`);
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function selectIntoToSQL(into) {
+    if (!into) return;
+    const {
+      position
+    } = into;
+    if (!position) return;
+    const {
+      keyword,
+      expr
+    } = into;
+    const result = [];
+    const intoType = (0, _util.toUpper)(keyword);
+    switch (intoType) {
+      case 'VAR':
+        result.push(expr.map(_expr.varToSQL).join(', '));
+        break;
+      default:
+        result.push(intoType, typeof expr === 'string' ? (0, _util.identifierToSql)(expr) : (0, _expr.exprToSQL)(expr));
+    }
+    return result.filter(_util.hasVal).join(' ');
+  }
+  /**
+   * @param {Object}      stmt
+   * @param {?Array}      stmt.with
+   * @param {?Array}      stmt.options
+   * @param {?string}     stmt.distinct
+   * @param {?Array|string}   stmt.columns
+   * @param {?Array}      stmt.from
+   * @param {?Object}     stmt.where
+   * @param {?Array}      stmt.groupby
+   * @param {?Object}     stmt.having
+   * @param {?Array}      stmt.orderby
+   * @param {?Array}      stmt.limit
+   * @return {string}
+   */
+
+  function forXmlToSQL(stmt) {
+    if (!stmt) return;
+    const {
+      expr,
+      keyword,
+      type
+    } = stmt;
+    const result = [(0, _util.toUpper)(type), (0, _util.toUpper)(keyword)];
+    if (!expr) return result.join(' ');
+    return `${result.join(' ')}(${(0, _expr.exprToSQL)(expr)})`;
+  }
+  function selectToSQL(stmt) {
+    const {
+      as_struct_val: asStructVal,
+      columns,
+      collate,
+      distinct,
+      for: forXml,
+      from,
+      for_sys_time_as_of: forSystem = {},
+      locking_read: lockingRead,
+      groupby,
+      having,
+      into = {},
+      isolation,
+      limit,
+      options,
+      orderby,
+      parentheses_symbol: parentheses,
+      qualify,
+      top,
+      window: windowInfo,
+      with: withInfo,
+      where
+    } = stmt;
+    const clauses = [(0, _with.withToSQL)(withInfo), 'SELECT', (0, _util.toUpper)(asStructVal)];
+    if (Array.isArray(options)) clauses.push(options.join(' '));
+    clauses.push(distinctToSQL(distinct), (0, _util.topToSQL)(top), (0, _column.columnsToSQL)(columns, from));
+    const {
+      position
+    } = into;
+    let intoSQL = '';
+    if (position) intoSQL = (0, _util.commonOptionConnector)('INTO', selectIntoToSQL, into);
+    if (position === 'column') clauses.push(intoSQL);
+    // FROM + joins
+    clauses.push((0, _util.commonOptionConnector)('FROM', _tables.tablesToSQL, from));
+    if (position === 'from') clauses.push(intoSQL);
+    const {
+      keyword,
+      expr
+    } = forSystem || {};
+    clauses.push((0, _util.commonOptionConnector)(keyword, _expr.exprToSQL, expr));
+    clauses.push((0, _util.commonOptionConnector)('WHERE', _expr.exprToSQL, where));
+    if (groupby) {
+      clauses.push((0, _util.connector)('GROUP BY', (0, _expr.getExprListSQL)(groupby.columns).join(', ')));
+      clauses.push((0, _expr.getExprListSQL)(groupby.modifiers).join(', '));
+    }
+    clauses.push((0, _util.commonOptionConnector)('HAVING', _expr.exprToSQL, having));
+    clauses.push((0, _util.commonOptionConnector)('QUALIFY', _expr.exprToSQL, qualify));
+    clauses.push((0, _util.commonOptionConnector)('WINDOW', _expr.exprToSQL, windowInfo));
+    clauses.push((0, _expr.orderOrPartitionByToSQL)(orderby, 'order by'));
+    clauses.push((0, _collate.collateToSQL)(collate));
+    clauses.push((0, _limit.limitToSQL)(limit));
+    if (isolation) clauses.push((0, _util.commonOptionConnector)(isolation.keyword, _util.literalToSQL, isolation.expr));
+    clauses.push((0, _util.toUpper)(lockingRead));
+    if (position === 'end') clauses.push(intoSQL);
+    clauses.push(forXmlToSQL(forXml));
+    const sql = clauses.filter(_util.hasVal).join(' ');
+    return parentheses ? `(${sql})` : sql;
+  }
+});

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

@@ -0,0 +1,89 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./expr", "./limit", "./tables", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"), require("./limit"), require("./tables"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr, global.limit, global.tables, global.util);
+    global.show = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _limit, _tables, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.showToSQL = showToSQL;
+  function showEventToSQL(showEventExpr) {
+    const {
+      in: inClause,
+      from,
+      limit
+    } = showEventExpr;
+    return [(0, _util.commonOptionConnector)('IN', _util.literalToSQL, inClause && inClause.right), (0, _util.commonOptionConnector)('FROM', _tables.tablesToSQL, from), (0, _limit.limitToSQL)(limit)].filter(_util.hasVal).join(' ');
+  }
+  function showLikeAndWhereToSQL(showCharacterSetExpr) {
+    const {
+      expr
+    } = showCharacterSetExpr;
+    if (!expr) return;
+    const {
+      op
+    } = expr;
+    if ((0, _util.toUpper)(op) === 'LIKE') return (0, _util.commonOptionConnector)('LIKE', _util.literalToSQL, expr.right);
+    return (0, _util.commonOptionConnector)('WHERE', _expr.exprToSQL, expr);
+  }
+  function showGrantsForUser(showGrantsForExpr) {
+    const {
+      for: forExpr
+    } = showGrantsForExpr;
+    if (!forExpr) return;
+    const {
+      user,
+      host,
+      role_list
+    } = forExpr;
+    let userAndHost = `'${user}'`;
+    if (host) userAndHost += `@'${host}'`;
+    return ['FOR', userAndHost, role_list && 'USING', role_list && role_list.map(role => `'${role}'`).join(', ')].filter(_util.hasVal).join(' ');
+  }
+  function showToSQL(showExpr) {
+    let {
+      keyword
+    } = showExpr;
+    const {
+      suffix
+    } = showExpr;
+    let str = '';
+    switch ((0, _util.toUpper)(keyword)) {
+      case 'BINLOG':
+        str = showEventToSQL(showExpr);
+        break;
+      case 'CHARACTER':
+      case 'COLLATION':
+        str = showLikeAndWhereToSQL(showExpr);
+        break;
+      case 'COLUMNS':
+      case 'INDEXES':
+      case 'INDEX':
+        str = (0, _util.commonOptionConnector)('FROM', _tables.tablesToSQL, showExpr.from);
+        break;
+      case 'GRANTS':
+        str = showGrantsForUser(showExpr);
+        break;
+      case 'CREATE':
+        str = (0, _util.commonOptionConnector)('', _tables.tableToSQL, showExpr[suffix]);
+        break;
+      case 'VAR':
+        str = (0, _expr.varToSQL)(showExpr.var);
+        keyword = '';
+        break;
+      default:
+        break;
+    }
+    return ['SHOW', (0, _util.toUpper)(keyword), (0, _util.toUpper)(suffix), str].filter(_util.hasVal).join(' ');
+  }
+});

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

@@ -0,0 +1,43 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./union"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./union"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.union);
+    global.sql = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _union) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = astToSQL;
+  const supportedTypes = ['analyze', 'attach', 'select', 'deallocate', 'delete', 'exec', 'update', 'insert', 'drop', 'rename', 'truncate', 'call', 'desc', 'use', 'alter', 'set', 'create', 'lock', 'unlock', 'declare', 'show', 'replace', 'if', 'grant', 'revoke', 'proc', 'raise', 'execute', 'transaction', 'explain', 'comment'];
+  function checkSupported(expr) {
+    const ast = expr && expr.ast ? expr.ast : expr;
+    if (!supportedTypes.includes(ast.type)) throw new Error(`${ast.type} statements not supported at the moment`);
+  }
+  function toSQL(ast) {
+    if (Array.isArray(ast)) {
+      ast.forEach(checkSupported);
+      return (0, _union.multipleToSQL)(ast);
+    }
+    checkSupported(ast);
+    return (0, _union.unionToSQL)(ast);
+  }
+  function goToSQL(stmt) {
+    if (!stmt || stmt.length === 0) return '';
+    const res = [toSQL(stmt.ast)];
+    if (stmt.go_next) res.push(stmt.go.toUpperCase(), goToSQL(stmt.go_next));
+    return res.filter(sqlItem => sqlItem).join(' ');
+  }
+  function astToSQL(ast) {
+    const sql = ast.go === 'go' ? goToSQL(ast) : toSQL(ast);
+    return sql;
+  }
+});