@tachybase/module-collection 1.6.25 → 1.6.26

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

@@ -0,0 +1,259 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./collate", "./constrain", "./expr", "./func", "./tables", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./collate"), require("./constrain"), require("./expr"), require("./func"), require("./tables"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.collate, global.constrain, global.expr, global.func, global.tables, global.util);
+    global.column = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _collate, _constrain, _expr, _func, _tables, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.arrayIndexToSQL = arrayIndexToSQL;
+  _exports.asToSQL = asToSQL;
+  _exports.columnDataType = columnDataType;
+  _exports.columnDefinitionToSQL = columnDefinitionToSQL;
+  _exports.columnOffsetToSQL = columnOffsetToSQL;
+  _exports.columnOrderToSQL = columnOrderToSQL;
+  _exports.columnRefToSQL = columnRefToSQL;
+  _exports.columnReferenceDefinitionToSQL = columnReferenceDefinitionToSQL;
+  _exports.columnToSQL = columnToSQL;
+  _exports.columnsToSQL = columnsToSQL;
+  _exports.fullTextSearchToSQL = fullTextSearchToSQL;
+  _exports.getDual = getDual;
+  function columnOffsetToSQL(column, isDual) {
+    if (typeof column === 'string') return (0, _util.identifierToSql)(column, isDual);
+    const {
+      expr,
+      offset,
+      suffix
+    } = column;
+    const offsetExpr = offset && offset.map(offsetItem => ['[', offsetItem.name, `${offsetItem.name ? '(' : ''}`, (0, _util.literalToSQL)(offsetItem.value), `${offsetItem.name ? ')' : ''}`, ']'].filter(_util.hasVal).join('')).join('');
+    const result = [(0, _expr.exprToSQL)(expr), offsetExpr, suffix].filter(_util.hasVal).join('');
+    return result;
+  }
+  function arrayIndexToSQL(arrayIndexList) {
+    if (!arrayIndexList || arrayIndexList.length === 0) return '';
+    const result = [];
+    for (const arrayIndex of arrayIndexList) {
+      let arrayIndexStr = arrayIndex.brackets ? `[${(0, _util.literalToSQL)(arrayIndex.index)}]` : `${arrayIndex.notation}${(0, _util.literalToSQL)(arrayIndex.index)}`;
+      if (arrayIndex.property) arrayIndexStr = `${arrayIndexStr}.${(0, _util.literalToSQL)(arrayIndex.property)}`;
+      result.push(arrayIndexStr);
+    }
+    return result.join('');
+  }
+  function columnRefToSQL(expr) {
+    const {
+      array_index,
+      as,
+      column,
+      collate,
+      db,
+      isDual,
+      notations = [],
+      options,
+      schema,
+      table,
+      parentheses,
+      suffix,
+      order_by,
+      subFields = []
+    } = expr;
+    let str = column === '*' ? '*' : columnOffsetToSQL(column, isDual);
+    const prefix = [db, schema, table].filter(_util.hasVal).map(val => `${typeof val === 'string' ? (0, _util.identifierToSql)(val) : (0, _expr.exprToSQL)(val)}`);
+    let prefixStr = prefix[0];
+    if (prefixStr) {
+      let i = 1;
+      for (; i < prefix.length; ++i) {
+        prefixStr = `${prefixStr}${notations[i] || '.'}${prefix[i]}`;
+      }
+      str = `${prefixStr}${notations[i] || '.'}${str}`;
+    }
+    str = [`${str}${arrayIndexToSQL(array_index)}`, ...subFields].join('.');
+    const result = [str, (0, _collate.collateToSQL)(collate), (0, _expr.exprToSQL)(options), (0, _util.commonOptionConnector)('AS', _expr.exprToSQL, as)];
+    result.push(typeof suffix === 'string' ? (0, _util.toUpper)(suffix) : (0, _expr.exprToSQL)(suffix));
+    result.push((0, _util.toUpper)(order_by));
+    const sql = result.filter(_util.hasVal).join(' ');
+    return parentheses ? `(${sql})` : sql;
+  }
+  function columnDataType(definition) {
+    if (!definition) return;
+    const {
+      dataType,
+      length,
+      suffix,
+      scale,
+      expr
+    } = definition;
+    const parentheses = length != null && true || false;
+    let result = (0, _util.dataTypeToSQL)({
+      dataType,
+      length,
+      suffix,
+      scale,
+      parentheses
+    });
+    if (expr) result += (0, _expr.exprToSQL)(expr);
+    if (definition.array) {
+      const arrayExpr = (0, _func.arrayDimensionToSymbol)(definition);
+      const space = /^\[.*\]$/.test(arrayExpr) ? '' : ' ';
+      result += [space, arrayExpr].join('');
+    }
+    return result;
+  }
+  function columnReferenceDefinitionToSQL(referenceDefinition) {
+    const reference = [];
+    if (!referenceDefinition) return reference;
+    const {
+      definition,
+      keyword,
+      match,
+      table,
+      on_action: onAction
+    } = referenceDefinition;
+    reference.push((0, _util.toUpper)(keyword));
+    reference.push((0, _tables.tablesToSQL)(table));
+    reference.push(definition && `(${definition.map(col => (0, _expr.exprToSQL)(col)).join(', ')})`);
+    reference.push((0, _util.toUpper)(match));
+    onAction.map(onRef => reference.push((0, _util.toUpper)(onRef.type), (0, _expr.exprToSQL)(onRef.value)));
+    return reference.filter(_util.hasVal);
+  }
+  function generatedExpressionToSQL(generated) {
+    if (!generated) return;
+    const result = [(0, _util.toUpper)(generated.value), `(${(0, _expr.exprToSQL)(generated.expr)})`, (0, _util.toUpper)(generated.storage_type)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function columnOption(definition) {
+    const columnOpt = [];
+    const {
+      nullable,
+      character_set: characterSet,
+      check,
+      comment,
+      constraint,
+      collate,
+      storage,
+      using,
+      default_val: defaultOpt,
+      generated,
+      auto_increment: autoIncrement,
+      unique: uniqueKey,
+      primary_key: primaryKey,
+      column_format: columnFormat,
+      reference_definition: referenceDefinition
+    } = definition;
+    const nullSQL = [(0, _util.toUpper)(nullable && nullable.action), (0, _util.toUpper)(nullable && nullable.value)].filter(_util.hasVal).join(' ');
+    if (!generated) columnOpt.push(nullSQL);
+    if (defaultOpt) {
+      const {
+        type,
+        value
+      } = defaultOpt;
+      columnOpt.push(type.toUpperCase(), (0, _expr.exprToSQL)(value));
+    }
+    const {
+      database
+    } = (0, _util.getParserOpt)();
+    if (constraint) columnOpt.push((0, _util.toUpper)(constraint.keyword), (0, _util.literalToSQL)(constraint.constraint));
+    columnOpt.push((0, _constrain.constraintDefinitionToSQL)(check));
+    columnOpt.push(generatedExpressionToSQL(generated));
+    if (generated) columnOpt.push(nullSQL);
+    columnOpt.push((0, _util.autoIncrementToSQL)(autoIncrement), (0, _util.toUpper)(primaryKey), (0, _util.toUpper)(uniqueKey), (0, _util.commentToSQL)(comment));
+    columnOpt.push(...(0, _util.commonTypeValue)(characterSet));
+    if (database.toLowerCase() !== 'sqlite') columnOpt.push((0, _expr.exprToSQL)(collate));
+    columnOpt.push(...(0, _util.commonTypeValue)(columnFormat));
+    columnOpt.push(...(0, _util.commonTypeValue)(storage));
+    columnOpt.push(...columnReferenceDefinitionToSQL(referenceDefinition));
+    columnOpt.push((0, _util.commonOptionConnector)('USING', _expr.exprToSQL, using));
+    return columnOpt.filter(_util.hasVal).join(' ');
+  }
+  function columnOrderToSQL(columnOrder) {
+    const {
+      column,
+      collate,
+      nulls,
+      opclass,
+      order_by
+    } = columnOrder;
+    const columnExpr = typeof column === 'string' ? {
+      type: 'column_ref',
+      table: columnOrder.table,
+      column
+    } : columnOrder;
+    columnExpr.collate = null;
+    const result = [(0, _expr.exprToSQL)(columnExpr), (0, _expr.exprToSQL)(collate), opclass, (0, _util.toUpper)(order_by), (0, _util.toUpper)(nulls)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function columnDefinitionToSQL(columnDefinition) {
+    const column = [];
+    const name = columnRefToSQL(columnDefinition.column);
+    const dataType = columnDataType(columnDefinition.definition);
+    column.push(name);
+    column.push(dataType);
+    column.push(columnOption(columnDefinition));
+    return column.filter(_util.hasVal).join(' ');
+  }
+  function asToSQL(asStr) {
+    if (!asStr) return '';
+    if (typeof asStr === 'object') return ['AS', (0, _expr.exprToSQL)(asStr)].join(' ');
+    return ['AS', /^(`?)[a-z_][0-9a-z_]*(`?)$/i.test(asStr) ? (0, _util.identifierToSql)(asStr) : (0, _util.columnIdentifierToSql)(asStr)].join(' ');
+  }
+  function fullTextSearchToSQL(expr) {
+    const {
+      against,
+      as,
+      columns,
+      match,
+      mode
+    } = expr;
+    const matchExpr = [(0, _util.toUpper)(match), `(${columns.map(col => columnRefToSQL(col)).join(', ')})`].join(' ');
+    const againstExpr = [(0, _util.toUpper)(against), ['(', (0, _expr.exprToSQL)(expr.expr), mode && ` ${(0, _util.literalToSQL)(mode)}`, ')'].filter(_util.hasVal).join('')].join(' ');
+    return [matchExpr, againstExpr, asToSQL(as)].filter(_util.hasVal).join(' ');
+  }
+  function columnToSQL(column, isDual) {
+    const {
+      expr,
+      type
+    } = column;
+    if (type === 'cast') return (0, _func.castToSQL)(column);
+    if (isDual) expr.isDual = isDual;
+    let str = (0, _expr.exprToSQL)(expr);
+    const {
+      expr_list: exprList
+    } = column;
+    if (exprList) {
+      const result = [str];
+      const columnsStr = exprList.map(col => columnToSQL(col, isDual)).join(', ');
+      result.push([(0, _util.toUpper)(type), type && '(', columnsStr, type && ')'].filter(_util.hasVal).join(''));
+      return result.filter(_util.hasVal).join(' ');
+    }
+    if (expr.parentheses && Reflect.has(expr, 'array_index') && expr.type !== 'cast') str = `(${str})`;
+    if (expr.array_index && expr.type !== 'column_ref') {
+      str = `${str}${arrayIndexToSQL(expr.array_index)}`;
+    }
+    return [str, asToSQL(column.as)].filter(_util.hasVal).join(' ');
+  }
+  function getDual(tables) {
+    const baseTable = Array.isArray(tables) && tables[0];
+    if (baseTable && baseTable.type === 'dual') return true;
+    return false;
+  }
+  /**
+   * Stringify column expressions
+   *
+   * @param {Array} columns
+   * @return {string}
+   */
+  function columnsToSQL(columns, tables) {
+    if (!columns || columns === '*') return columns;
+    const isDual = getDual(tables);
+    return columns.map(col => columnToSQL(col, isDual)).join(', ');
+  }
+});

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

@@ -0,0 +1,306 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./column", "./create", "./util", "./expr", "./tables", "./sql", "./union"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./column"), require("./create"), require("./util"), require("./expr"), require("./tables"), require("./sql"), require("./union"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.column, global.create, global.util, global.expr, global.tables, global.sql, global.union);
+    global.command = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _column, _create, _util, _expr, _tables, _sql, _union) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.callToSQL = callToSQL;
+  _exports.commonCmdToSQL = commonCmdToSQL;
+  _exports.deallocateToSQL = deallocateToSQL;
+  _exports.declareToSQL = declareToSQL;
+  _exports.descToSQL = descToSQL;
+  _exports.executeToSQL = executeToSQL;
+  _exports.forLoopToSQL = forLoopToSQL;
+  _exports.grantAndRevokeToSQL = grantAndRevokeToSQL;
+  _exports.grantUserOrRoleToSQL = grantUserOrRoleToSQL;
+  _exports.ifToSQL = ifToSQL;
+  _exports.lockUnlockToSQL = lockUnlockToSQL;
+  _exports.raiseToSQL = raiseToSQL;
+  _exports.renameToSQL = renameToSQL;
+  _exports.setVarToSQL = setVarToSQL;
+  _exports.useToSQL = useToSQL;
+  _sql = _interopRequireDefault(_sql);
+  function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+  function callToSQL(stmt) {
+    const type = 'CALL';
+    const storeProcessCall = (0, _expr.exprToSQL)(stmt.expr);
+    return `${type} ${storeProcessCall}`;
+  }
+  function commonCmdToSQL(stmt) {
+    const {
+      type,
+      keyword,
+      name,
+      prefix,
+      suffix
+    } = stmt;
+    const clauses = [(0, _util.toUpper)(type), (0, _util.toUpper)(keyword), (0, _util.toUpper)(prefix)];
+    switch (keyword) {
+      case 'table':
+        clauses.push((0, _tables.tablesToSQL)(name));
+        break;
+      case 'trigger':
+        clauses.push([name[0].schema ? `${(0, _util.identifierToSql)(name[0].schema)}.` : '', (0, _util.identifierToSql)(name[0].trigger)].filter(_util.hasVal).join(''));
+        break;
+      case 'database':
+      case 'schema':
+      case 'procedure':
+        clauses.push((0, _util.identifierToSql)(name));
+        break;
+      case 'view':
+        clauses.push((0, _tables.tablesToSQL)(name), stmt.options && stmt.options.map(_expr.exprToSQL).filter(_util.hasVal).join(' '));
+        break;
+      case 'index':
+        clauses.push((0, _column.columnRefToSQL)(name), ...(stmt.table ? ['ON', (0, _tables.tableToSQL)(stmt.table)] : []), stmt.options && stmt.options.map(_expr.exprToSQL).filter(_util.hasVal).join(' '));
+        break;
+      case 'type':
+        clauses.push(name.map(_column.columnRefToSQL).join(', '), stmt.options && stmt.options.map(_expr.exprToSQL).filter(_util.hasVal).join(' '));
+        break;
+      default:
+        break;
+    }
+    if (suffix) clauses.push(suffix.map(_expr.exprToSQL).filter(_util.hasVal).join(' '));
+    return clauses.filter(_util.hasVal).join(' ');
+  }
+  function descToSQL(stmt) {
+    const {
+      type,
+      table
+    } = stmt;
+    const action = (0, _util.toUpper)(type);
+    return `${action} ${(0, _util.identifierToSql)(table)}`;
+  }
+  function executeToSQL(stmt) {
+    const {
+      type,
+      name,
+      args
+    } = stmt;
+    const sql = [(0, _util.toUpper)(type)];
+    const nameWithArgs = [name];
+    if (args) nameWithArgs.push(`(${(0, _expr.exprToSQL)(args).join(', ')})`);
+    sql.push(nameWithArgs.join(''));
+    return sql.filter(_util.hasVal).join(' ');
+  }
+  function forLoopToSQL(stmt) {
+    const {
+      type,
+      label,
+      target,
+      query,
+      stmts
+    } = stmt;
+    const sql = [label, (0, _util.toUpper)(type), target, 'IN', (0, _union.multipleToSQL)([query]), 'LOOP', (0, _union.multipleToSQL)(stmts), 'END LOOP', label];
+    return sql.filter(_util.hasVal).join(' ');
+  }
+  function raiseToSQL(stmt) {
+    const {
+      type,
+      level,
+      raise,
+      using
+    } = stmt;
+    const sql = [(0, _util.toUpper)(type), (0, _util.toUpper)(level)];
+    if (raise) sql.push([(0, _util.literalToSQL)(raise.keyword), raise.type === 'format' && raise.expr.length > 0 && ','].filter(_util.hasVal).join(''), raise.expr.map(exprInfo => (0, _expr.exprToSQL)(exprInfo)).join(', '));
+    if (using) sql.push((0, _util.toUpper)(using.type), (0, _util.toUpper)(using.option), using.symbol, using.expr.map(exprInfo => (0, _expr.exprToSQL)(exprInfo)).join(', '));
+    return sql.filter(_util.hasVal).join(' ');
+  }
+  function renameToSQL(stmt) {
+    const {
+      type,
+      table
+    } = stmt;
+    const clauses = [];
+    const prefix = `${type && type.toUpperCase()} TABLE`;
+    if (table) {
+      for (const tables of table) {
+        const renameInfo = tables.map(_tables.tableToSQL);
+        clauses.push(renameInfo.join(' TO '));
+      }
+    }
+    return `${prefix} ${clauses.join(', ')}`;
+  }
+  function useToSQL(stmt) {
+    const {
+      type,
+      db
+    } = stmt;
+    const action = (0, _util.toUpper)(type);
+    const database = (0, _util.identifierToSql)(db);
+    return `${action} ${database}`;
+  }
+  function setVarToSQL(stmt) {
+    const {
+      type,
+      expr,
+      keyword
+    } = stmt;
+    const action = (0, _util.toUpper)(type);
+    const setItems = expr.map(_expr.exprToSQL).join(', ');
+    return [action, (0, _util.toUpper)(keyword), setItems].filter(_util.hasVal).join(' ');
+  }
+  function pgLock(stmt) {
+    const {
+      lock_mode: lockMode,
+      nowait
+    } = stmt;
+    const lockInfo = [];
+    if (lockMode) {
+      const {
+        mode
+      } = lockMode;
+      lockInfo.push(mode.toUpperCase());
+    }
+    if (nowait) lockInfo.push(nowait.toUpperCase());
+    return lockInfo;
+  }
+  function lockUnlockToSQL(stmt) {
+    const {
+      type,
+      keyword,
+      tables
+    } = stmt;
+    const result = [type.toUpperCase(), (0, _util.toUpper)(keyword)];
+    if (type.toUpperCase() === 'UNLOCK') return result.join(' ');
+    const tableStmt = [];
+    for (const tableInfo of tables) {
+      const {
+        table,
+        lock_type: lockType
+      } = tableInfo;
+      const tableInfoTemp = [(0, _tables.tableToSQL)(table)];
+      if (lockType) {
+        const lockKeyList = ['prefix', 'type', 'suffix'];
+        tableInfoTemp.push(lockKeyList.map(key => (0, _util.toUpper)(lockType[key])).filter(_util.hasVal).join(' '));
+      }
+      tableStmt.push(tableInfoTemp.join(' '));
+    }
+    result.push(tableStmt.join(', '), ...pgLock(stmt));
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function deallocateToSQL(stmt) {
+    const {
+      type,
+      keyword,
+      expr
+    } = stmt;
+    return [(0, _util.toUpper)(type), (0, _util.toUpper)(keyword), (0, _expr.exprToSQL)(expr)].filter(_util.hasVal).join(' ');
+  }
+  function declareToSQL(stmt) {
+    const {
+      type,
+      declare,
+      symbol
+    } = stmt;
+    const result = [(0, _util.toUpper)(type)];
+    const info = declare.map(dec => {
+      const {
+        at,
+        name,
+        as,
+        constant,
+        datatype,
+        not_null,
+        prefix,
+        definition,
+        keyword
+      } = dec;
+      const declareInfo = [[at, name].filter(_util.hasVal).join(''), (0, _util.toUpper)(as), (0, _util.toUpper)(constant)];
+      switch (keyword) {
+        case 'variable':
+          declareInfo.push((0, _column.columnDataType)(datatype), (0, _expr.exprToSQL)(dec.collate), (0, _util.toUpper)(not_null));
+          if (definition) declareInfo.push((0, _util.toUpper)(definition.keyword), (0, _expr.exprToSQL)(definition.value));
+          break;
+        case 'cursor':
+          declareInfo.push((0, _util.toUpper)(prefix));
+          break;
+        case 'table':
+          declareInfo.push((0, _util.toUpper)(prefix), `(${definition.map(_create.createDefinitionToSQL).join(', ')})`);
+          break;
+        default:
+          break;
+      }
+      return declareInfo.filter(_util.hasVal).join(' ');
+    }).join(`${symbol} `);
+    result.push(info);
+    return result.join(' ');
+  }
+  function ifToSQL(stmt) {
+    const {
+      boolean_expr: boolExpr,
+      else_expr: elseExpr,
+      elseif_expr: elseifExpr,
+      if_expr: ifExpr,
+      prefix,
+      go,
+      semicolons,
+      suffix,
+      type
+    } = stmt;
+    const result = [(0, _util.toUpper)(type), (0, _expr.exprToSQL)(boolExpr), (0, _util.literalToSQL)(prefix), `${(0, _sql.default)(ifExpr.ast || ifExpr)}${semicolons[0]}`, (0, _util.toUpper)(go)];
+    if (elseifExpr) {
+      result.push(elseifExpr.map(elseif => [(0, _util.toUpper)(elseif.type), (0, _expr.exprToSQL)(elseif.boolean_expr), 'THEN', (0, _sql.default)(elseif.then.ast || elseif.then), elseif.semicolon].filter(_util.hasVal).join(' ')).join(' '));
+    }
+    if (elseExpr) result.push('ELSE', `${(0, _sql.default)(elseExpr.ast || elseExpr)}${semicolons[1]}`);
+    result.push((0, _util.literalToSQL)(suffix));
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function grantUserOrRoleToSQL(stmt) {
+    const {
+      name,
+      host
+    } = stmt;
+    const result = [(0, _util.literalToSQL)(name)];
+    if (host) result.push('@', (0, _util.literalToSQL)(host));
+    return result.join('');
+  }
+  function grantAndRevokeToSQL(stmt) {
+    const {
+      type,
+      grant_option_for,
+      keyword,
+      objects,
+      on,
+      to_from,
+      user_or_roles,
+      with: withOpt
+    } = stmt;
+    const result = [(0, _util.toUpper)(type), (0, _util.literalToSQL)(grant_option_for)];
+    const objStr = objects.map(obj => {
+      const {
+        priv,
+        columns
+      } = obj;
+      const privSQL = [(0, _expr.exprToSQL)(priv)];
+      if (columns) privSQL.push(`(${columns.map(_column.columnRefToSQL).join(', ')})`);
+      return privSQL.join(' ');
+    }).join(', ');
+    result.push(objStr);
+    if (on) {
+      result.push('ON');
+      switch (keyword) {
+        case 'priv':
+          result.push((0, _util.literalToSQL)(on.object_type), on.priv_level.map(privLevel => [(0, _util.identifierToSql)(privLevel.prefix), (0, _util.identifierToSql)(privLevel.name)].filter(_util.hasVal).join('.')).join(', '));
+          break;
+        case 'proxy':
+          result.push(grantUserOrRoleToSQL(on));
+          break;
+      }
+    }
+    result.push((0, _util.toUpper)(to_from), user_or_roles.map(grantUserOrRoleToSQL).join(', '));
+    result.push((0, _util.literalToSQL)(withOpt));
+    return result.filter(_util.hasVal).join(' ');
+  }
+});

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

@@ -0,0 +1,53 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./column", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./column"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.column, global.util);
+    global.comment = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _column, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.commentOnToSQL = commentOnToSQL;
+  function commentOptionToSQL(stmt) {
+    const {
+      name,
+      type
+    } = stmt;
+    switch (type) {
+      case 'table':
+      case 'view':
+        const fullTableName = [(0, _util.identifierToSql)(name.db), (0, _util.identifierToSql)(name.table)].filter(_util.hasVal).join('.');
+        return `${(0, _util.toUpper)(type)} ${fullTableName}`;
+      case 'column':
+        return `COLUMN ${(0, _column.columnRefToSQL)(name)}`;
+      default:
+        return `${(0, _util.toUpper)(type)} ${(0, _util.literalToSQL)(name)}`;
+    }
+  }
+  function commentIsExprToSQL(stmt) {
+    const {
+      keyword,
+      expr
+    } = stmt;
+    return [(0, _util.toUpper)(keyword), (0, _util.literalToSQL)(expr)].filter(_util.hasVal).join(' ');
+  }
+  function commentOnToSQL(stmt) {
+    const {
+      expr,
+      keyword,
+      target,
+      type
+    } = stmt;
+    const result = [(0, _util.toUpper)(type), (0, _util.toUpper)(keyword), commentOptionToSQL(target), commentIsExprToSQL(expr)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+});

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

@@ -0,0 +1,49 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./util", "./index-definition", "./column"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./util"), require("./index-definition"), require("./column"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.util, global.indexDefinition, global.column);
+    global.constrain = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _util, _indexDefinition, _column) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.constraintDefinitionToSQL = constraintDefinitionToSQL;
+  function constraintDefinitionToSQL(constraintDefinition) {
+    if (!constraintDefinition) return;
+    const {
+      constraint,
+      constraint_type: constraintType,
+      enforced,
+      index,
+      keyword,
+      reference_definition: referenceDefinition,
+      for: forColumn,
+      with_values: withValues
+    } = constraintDefinition;
+    const constraintSQL = [];
+    const {
+      database
+    } = (0, _util.getParserOpt)();
+    constraintSQL.push((0, _util.toUpper)(keyword));
+    constraintSQL.push((0, _util.identifierToSql)(constraint));
+    let constraintTypeStr = (0, _util.toUpper)(constraintType);
+    if (database.toLowerCase() === 'sqlite' && constraintTypeStr === 'UNIQUE KEY') constraintTypeStr = 'UNIQUE';
+    constraintSQL.push(constraintTypeStr);
+    constraintSQL.push(database.toLowerCase() !== 'sqlite' && (0, _util.identifierToSql)(index));
+    constraintSQL.push(...(0, _indexDefinition.indexTypeAndOptionToSQL)(constraintDefinition));
+    constraintSQL.push(...(0, _column.columnReferenceDefinitionToSQL)(referenceDefinition));
+    constraintSQL.push((0, _util.toUpper)(enforced));
+    constraintSQL.push((0, _util.commonOptionConnector)('FOR', _util.identifierToSql, forColumn));
+    constraintSQL.push((0, _util.literalToSQL)(withValues));
+    return constraintSQL.filter(_util.hasVal).join(' ');
+  }
+});