sql-formatter/lib/sqlFormatter.js

Format whitespace in a SQL query to make it more readable

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.supportedDialects = exports.formatters = exports.format = exports.ConfigError = void 0;

var _bigquery = _interopRequireDefault(require("./languages/bigquery.formatter"));

var _db = _interopRequireDefault(require("./languages/db2.formatter"));

var _hive = _interopRequireDefault(require("./languages/hive.formatter"));

var _mariadb = _interopRequireDefault(require("./languages/mariadb.formatter"));

var _mysql = _interopRequireDefault(require("./languages/mysql.formatter"));

var _n1ql = _interopRequireDefault(require("./languages/n1ql.formatter"));

var _plsql = _interopRequireDefault(require("./languages/plsql.formatter"));

var _postgresql = _interopRequireDefault(require("./languages/postgresql.formatter"));

var _redshift = _interopRequireDefault(require("./languages/redshift.formatter"));

var _sparksql = _interopRequireDefault(require("./languages/sparksql.formatter"));

var _standardsql = _interopRequireDefault(require("./languages/standardsql.formatter"));

var _tsql = _interopRequireDefault(require("./languages/tsql.formatter"));

var _utils = require("./utils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }

function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }

var formatters = {
  bigquery: _bigquery["default"],
  db2: _db["default"],
  hive: _hive["default"],
  mariadb: _mariadb["default"],
  mysql: _mysql["default"],
  n1ql: _n1ql["default"],
  plsql: _plsql["default"],
  postgresql: _postgresql["default"],
  redshift: _redshift["default"],
  spark: _sparksql["default"],
  sql: _standardsql["default"],
  tsql: _tsql["default"]
};
exports.formatters = formatters;
var supportedDialects = Object.keys(formatters);
exports.supportedDialects = supportedDialects;
var defaultOptions = {
  language: 'sql',
  tabWidth: 2,
  useTabs: false,
  keywordCase: 'preserve',
  indentStyle: 'standard',
  multilineLists: 'always',
  logicalOperatorNewline: 'before',
  aliasAs: 'preserve',
  tabulateAlias: false,
  commaPosition: 'after',
  newlineBeforeOpenParen: true,
  newlineBeforeCloseParen: true,
  expressionWidth: 50,
  linesBetweenQueries: 1,
  denseOperators: false,
  newlineBeforeSemicolon: false
};
/**
 * Format whitespace in a query to make it easier to read.
 *
 * @param {string} query - input SQL query string
 * @param {FormatOptions} cfg Configuration options (see docs in README)
 * @return {string} formatted query
 */

var format = function format(query) {
  var cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  if (typeof query !== 'string') {
    throw new Error('Invalid query argument. Expected string, instead got ' + _typeof(query));
  }

  var options = validateConfig(_objectSpread(_objectSpread({}, defaultOptions), cfg));
  var Formatter = formatters[options.language];
  return new Formatter(options).format(query);
};

exports.format = format;

var ConfigError = /*#__PURE__*/function (_Error) {
  _inherits(ConfigError, _Error);

  var _super = _createSuper(ConfigError);

  function ConfigError() {
    _classCallCheck(this, ConfigError);

    return _super.apply(this, arguments);
  }

  return _createClass(ConfigError);
}( /*#__PURE__*/_wrapNativeSuper(Error));

exports.ConfigError = ConfigError;

function validateConfig(cfg) {
  if (!supportedDialects.includes(cfg.language)) {
    throw new ConfigError("Unsupported SQL dialect: ".concat(cfg.language));
  }

  if ((0, _utils.isNumber)(cfg.multilineLists) && cfg.multilineLists <= 0) {
    throw new ConfigError('multilineLists config must be a positive number.');
  }

  if (cfg.expressionWidth <= 0) {
    throw new ConfigError("expressionWidth config must be positive number. Received ".concat(cfg.expressionWidth, " instead."));
  }

  if (cfg.commaPosition === 'before' && cfg.useTabs) {
    throw new ConfigError('commaPosition: before does not work when tabs are used for indentation.');
  }

  return cfg;
}
//# sourceMappingURL=sqlFormatter.js.map