prettier-plugin-sql-cst 0.14.2 → 0.16.0

package/README.md

@@ -69,6 +69,14 @@ yarn add --dev prettier prettier-plugin-sql-cst
 Then use it on SQL files through Prettier command line tool or Prettier extension
 for your editor of choice.
 
+For a one-off run you can execute:
+
+```
+prettier --plugin prettier-plugin-sql-cst --parser sqlite myfile.sql
+```
+
+But generally you're better off using a configuration file.
+
 ## Choosing an SQL dialect
 
 By default the plugin will determine SQL dialect based on file extension:
@@ -119,14 +127,14 @@ The plugin provides the following parsers:
 The standard Prettier options [printWidth][], [tabWidth][], [useTabs][] apply.
 There are also some SQL-specific options:
 
-| API Option                    | Default | Description                                                                                                                                                                                                                     |
-| ----------------------------- | :-----: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `sqlKeywordCase`              | `upper` | Convert SQL keywords to `upper` or `lower` case, or `preserve` existing. Note that for now `preserve` is somewhat incompatible with `sqlCanonicalSyntax: true` (e.g. the added `AS` keywords will always be in uppercase).      |
-| `sqlLiteralCase`              | `upper` | Convert SQL literals TRUE, FALSE and NULL to `upper` or `lower` case, or `preserve` existing. Also applies to `on` & `off` literals in PostgreSQL SET statements.                                                               |
-| `sqlParamTypes`               |  `[]`   | Array of bound parameter types: `?`, `?nr`, `$nr`, `:name`, `@name`, `$name`.                                                                                                                                                   |
-| `sqlCanonicalSyntax`          | `true`  | When enabled, performs some opinionated changes of keywords and operators, like enforcing the use of `AS` in aliases and replacing `<>` comparisons with `!=`. See [STYLE_GUIDE][] for more details. (Since 0.11.0)             |
-| `sqlFinalSemicolon`           | `true`  | When enabled, enforces a semicolon at the end of last statement. When disabled leaves it up to the author whether to add a final semicolon or not. (Since 0.13.0)                                                               |
-| `sqlAcceptUnsupportedGrammar` | `false` | Normally when the plugin encounters SQL syntax it doesn't support it will throw an error and won't format anything at all. With this option enabled, it will skip over SQL statements it doesn't recognize, leaving them as-is. |
+| API Option                    | Default | Description                                                                                                                                                                                                                                                                                                                                          |
+| ----------------------------- | :-----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `sqlKeywordCase`              | `upper` | Convert SQL keywords to `upper` or `lower` case, or `preserve` existing. Note that for now `preserve` is somewhat incompatible with `sqlCanonicalSyntax: true` (e.g. the added `AS` keywords will always be in uppercase). In most dialects this also applies to data types, but not in PostgreSQL where data type names are treated as identifiers. |
+| `sqlLiteralCase`              | `upper` | Convert SQL literals TRUE, FALSE and NULL to `upper` or `lower` case, or `preserve` existing. Also applies to `on` & `off` literals in PostgreSQL SET statements.                                                                                                                                                                                    |
+| `sqlParamTypes`               |  `[]`   | Array of bound parameter types: `?`, `?nr`, `$nr`, `:name`, `@name`, `$name`.                                                                                                                                                                                                                                                                        |
+| `sqlCanonicalSyntax`          | `true`  | When enabled, performs some opinionated changes of keywords and operators, like enforcing the use of `AS` in aliases and replacing `<>` comparisons with `!=`. See [STYLE_GUIDE][] for more details. (Since 0.11.0)                                                                                                                                  |
+| `sqlFinalSemicolon`           | `true`  | When enabled, enforces a semicolon at the end of last statement. When disabled leaves it up to the author whether to add a final semicolon or not. (Since 0.13.0)                                                                                                                                                                                    |
+| `sqlAcceptUnsupportedGrammar` | `false` | Normally when the plugin encounters SQL syntax it doesn't support it will throw an error and won't format anything at all. With this option enabled, it will skip over SQL statements it doesn't recognize, leaving them as-is.                                                                                                                      |
 
 ## Usage inside VSCode
 

package/dist/syntax/alter_action.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.alterActionMap = void 0;
 var print_utils_1 = require("../print_utils");
+var constraint_1 = require("./constraint");
 exports.alterActionMap = {
     alter_action_rename: function (print) { return print.spaced(["renameKw", "newName"]); },
     alter_action_rename_column: function (print) {
@@ -19,8 +20,12 @@ exports.alterActionMap = {
     alter_action_set_default_collate: function (print) {
         return print.spaced(["setDefaultCollateKw", "collation"]);
     },
-    alter_action_add_constraint: function (print) {
-        return print.spaced(["addKw", "name", "constraint", "modifiers"]);
+    /** cst-ignore: constraint, modifiers */
+    alter_action_add_constraint: function (print, node) {
+        return (0, print_utils_1.group)([
+            print.spaced(["addKw", "name"]),
+            (0, print_utils_1.indent)([print_utils_1.line, (0, constraint_1.printUnnamedConstraint)(print, node)]),
+        ]);
     },
     alter_action_add_constraint_constraint_name: function (print) {
         return print.spaced(["constraintKw", "ifNotExistsKw", "name"]);

package/dist/syntax/base.js

@@ -4,6 +4,12 @@ exports.baseMap = void 0;
 exports.baseMap = {
     /** cst-ignore: name */
     keyword: function (print, node, path, options) {
+        var _a;
+        // Treat PostgreSQL "WITH TIME ZONE" as part of data type, not keyword,
+        // so skip keyword case conversion for it
+        if (((_a = path.parent) === null || _a === void 0 ? void 0 : _a.type) === "with_time_zone_data_type") {
+            return path.node.text;
+        }
         switch (options.sqlKeywordCase) {
             case "preserve":
                 return path.node.text;

package/dist/syntax/constraint.d.ts

@@ -1,3 +1,6 @@
-import { AllConstraintNodes } from "sql-parser-cst";
+import { Doc } from "prettier";
+import { AllConstraintNodes, AlterActionAddConstraint, Constraint } from "sql-parser-cst";
 import { CstToDocMap } from "../CstToDocMap";
+import { PrintFn } from "../PrintFn";
 export declare const constraintMap: CstToDocMap<AllConstraintNodes>;
+export declare const printUnnamedConstraint: <T>(print: PrintFn<Constraint<T>, "name" | "modifiers" | "constraint"> | PrintFn<AlterActionAddConstraint, "name" | "modifiers" | "constraint" | "addKw">, node: AlterActionAddConstraint | Constraint<T>) => Doc;

package/dist/syntax/constraint.js

@@ -9,7 +9,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.constraintMap = void 0;
+exports.printUnnamedConstraint = exports.constraintMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.constraintMap = {
     /** cst-ignore: constraint, modifiers */
@@ -17,11 +17,11 @@ exports.constraintMap = {
         if (node.name) {
             return (0, print_utils_1.group)([
                 print("name"),
-                (0, print_utils_1.indent)([print_utils_1.line, printUnnamedConstraint(print, node)]),
+                (0, print_utils_1.indent)([print_utils_1.line, (0, exports.printUnnamedConstraint)(print, node)]),
             ]);
         }
         else {
-            return printUnnamedConstraint(print, node);
+            return (0, exports.printUnnamedConstraint)(print, node);
         }
     },
     constraint_name: function (print) { return print.spaced(["constraintKw", "name"]); },
@@ -113,3 +113,4 @@ var printUnnamedConstraint = function (print, node) {
         return print("constraint");
     }
 };
+exports.printUnnamedConstraint = printUnnamedConstraint;

package/dist/syntax/data_type.js

@@ -6,8 +6,10 @@ var print_utils_1 = require("../print_utils");
 exports.dataTypeMap = {
     // print single-word types as `TYPE(10)` and multi-word types as `MY TYPE (10)`
     named_data_type: function (print, node) {
-        return ((0, utils_1.isArray)(node.name) ? print.spaced : print)(["name", "params"]);
+        return (isMultiWordTypeName(node) ? print.spaced : print)(["name", "params"]);
     },
+    data_type_identifier: function (print) { return print.spaced("name"); },
+    setof_data_type: function (print) { return print.spaced(["setofKw", "dataType"]); },
     array_data_type: function (print) { return print(["dataType", "bounds"]); },
     array_bounds: function (print) { return ["[", print("bounds"), "]"]; },
     with_time_zone_data_type: function (print) {
@@ -22,3 +24,7 @@ exports.dataTypeMap = {
     },
     table_data_type: function (print) { return print.spaced(["tableKw", "columns"]); },
 };
+function isMultiWordTypeName(node) {
+    return ((0, utils_1.isArray)(node.name) ||
+        (node.name.type === "data_type_identifier" && (0, utils_1.isArray)(node.name.name)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sql-cst",
-  "version": "0.14.2",
+  "version": "0.16.0",
   "description": "Prettier plugin for SQL",
   "contributors": [
     "Barna Magyarkuti <bmagyarkuti@gmail.com>",
@@ -37,7 +37,7 @@
   ],
   "dependencies": {
     "prettier": "^3.0.3",
-    "sql-parser-cst": "^0.35.1"
+    "sql-parser-cst": "^0.36.1"
   },
   "devDependencies": {
     "@types/jest": "^29.2.5",