prettier-sql/lib/sqlFormatter.js

Format whitespace in a SQL query to make it more readable

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.format = exports.supportedDialects = exports.formatters = 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 _types = require("./types");

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

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _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;

/**
 * Format whitespace in a query to make it easier to read.
 *
 * @param {string} query - input SQL query string
 * @param {FormatOptions} cfg
 *  @param {string} cfg.language - Query language, default is Standard SQL
 *  @param {string} cfg.indent - Characters used for indentation, default is "  " (2 spaces)
 *  @param {Boolean} cfg.uppercase - Converts keywords to uppercase
 *  @param {KeywordMode} cfg.keywordPosition - Sets main keyword position style, see keywordPosition.md for examples
 *  @param {NewlineMode} cfg.newline - Determines when to break words onto a newline; always | never | lineWidth (break only when > line width) | number (break when > n)
 *  @param {Boolean} cfg.breakBeforeBooleanOperator - Break before boolean operator (AND, OR, XOR) ?
 *  @param {AliasMode} cfg.aliasAs - Whether to use AS in column aliases in only SELECT clause, both SELECT and table aliases, or never
 *  @param {Boolean} cfg.tabulateAlias - Whether to have alias following clause or aligned to right
 *  @param {CommaPosition} cfg.commaPosition - Where to place the comma in listed clauses
 *  @param {ParenOptions} cfg.parenOptions - Various options for parentheses
 *  	@param {Boolean} cfg.parenOptions -.openParenNewline Whether to place opening parenthesis on same line or newline
 *  	@param {Boolean} cfg.parenOptions -.closeParenNewline Whether to place closing parenthesis on same line or newline
 *  //	@param {Boolean} cfg.parenOptions -.reservedFunctionParens Whether to use parenthesis for reserved functions such as COUNT
 *  //	@param {Boolean} cfg.parenOptions -.functionParenSpace Whether to add space before reserved function parens
 *  @param {Integer} cfg.lineWidth - Number of characters in each line before breaking, default: 50
 *  @param {Integer} cfg.linesBetweenQueries - How many line breaks between queries
 *  @param {Boolean} cfg.denseOperators - whether to format operators with spaces
 *  @param {ParamItems} cfg.params - Collection of params for placeholder replacement
 *  @param {Boolean} cfg.semicolonNewline - Whether to place semicolon on newline
 * @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));
  }

  if (cfg.language && !supportedDialects.includes(cfg.language)) {
    throw Error("Unsupported SQL dialect: ".concat(cfg.language));
  }

  if (cfg.keywordPosition === _types.KeywordMode.tenSpaceLeft || cfg.keywordPosition === _types.KeywordMode.tenSpaceRight) {
    cfg.indent = ' '.repeat(10);
  }

  if (cfg.newline && !Number.isNaN(+cfg.newline)) {
    var _cfg$newline;

    if (((_cfg$newline = cfg.newline) !== null && _cfg$newline !== void 0 ? _cfg$newline : 0) < 0) {
      throw new Error('Error: newline must be a positive number.');
    }

    if (cfg.newline === 0) {
      cfg.newline = _types.NewlineMode.always;
    }
  }

  if (cfg.lineWidth && cfg.lineWidth <= 0) {
    console.warn('Warning: cfg.linewidth was <=0, reset to default value');
    cfg.lineWidth = undefined;
  }

  var defaultOptions = {
    language: 'sql',
    indent: '  ',
    uppercase: true,
    keywordPosition: _types.KeywordMode.standard,
    newline: _types.NewlineMode.always,
    breakBeforeBooleanOperator: true,
    aliasAs: _types.AliasMode.select,
    tabulateAlias: false,
    commaPosition: _types.CommaPosition.after,
    parenOptions: {
      openParenNewline: true,
      closeParenNewline: true // reservedFunctionParens: true,
      // functionParenSpace: false,

    },
    lineWidth: 50,
    linesBetweenQueries: 1,
    denseOperators: false,
    semicolonNewline: false
  };
  cfg = _objectSpread(_objectSpread(_objectSpread({}, defaultOptions), cfg), {}, {
    parenOptions: _objectSpread(_objectSpread({}, defaultOptions.parenOptions), cfg.parenOptions)
  });
  var Formatter = formatters[cfg.language];
  return new Formatter(cfg).format(query);
};

exports.format = format;
//# sourceMappingURL=sqlFormatter.js.map