prettier-plugin-sql-cst 0.20.0 → 0.22.0

package/README.md

@@ -119,6 +119,7 @@ The plugin provides the following parsers:
 - `sqlite`
 - `bigquery`
 - `postgresql` (**experimental! expect crashes**)
+- `plpgsql` (**experimental! expect crashes**)
 - `mysql` (**experimental! expect crashes**)
 - `mariadb` (**experimental! expect crashes**)
 
@@ -210,16 +211,12 @@ There are also several SQL-specific options:
 
   _Since 0.13.0_
 
-- **`sqlAcceptUnsupportedGrammar`**: `boolean` (default `false`)
+- **`sqlExperimentalPlpgsql`**: `boolean` (default `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.
+  When enabled, the plugin will attempt to format PL/pgSQL function bodies.
+  This might fail, as the underlying parser support for PL/pgSQL is incomplete.
 
-  **Deprecated:** Use conditional comments `/* sql-parser-cst-disable */` and
-  `/* sql-parser-cst-enable */` instead.
-
-  _Since 0.12.0_
+  _Since 0.21.0_
 
 ## Usage inside VSCode
 
@@ -262,6 +259,7 @@ Currently this plugin supports two SQL dialects:
 It also has experimental support for the following dialects:
 
 - PostgreSQL
+- PL/pgSQL
 - MySQL
 - MariaDB
 

package/dist/index.d.ts

@@ -10,7 +10,7 @@ interface SqlPluginOptions {
     sqlParamTypes: NonNullable<ParserOptions["paramTypes"]>;
     sqlCanonicalSyntax: boolean;
     sqlFinalSemicolon: boolean;
-    sqlAcceptUnsupportedGrammar: boolean;
+    sqlExperimentalPlpgsql: boolean;
 }
 declare const options: SupportOptions;
 

package/dist/index.js

@@ -1082,8 +1082,20 @@ var otherClausesMap = {
   cluster_by_clause: (print) => group([print.spaced("clusterByKw"), indent([line, print("columns")])]),
   // RETURNING clause
   returning_clause: (print) => group([print("returningKw"), indent([line, print("columns")])]),
+  // INTO clause
+  into_variables_clause: (print) => group([
+    print.spaced(["intoKw", "strictKw"]),
+    indent([line, print("variables")])
+  ]),
+  as_clause: (print, node) => {
+    if (isStringLiteral(node.expr) || isDynamicallyLoadedFunction(node.expr)) {
+      return group(print.spaced(["asKw", "expr"]));
+    }
+    return group([print("asKw"), indent([hardline, print("expr")])]);
+  },
+  comma_clause: (print) => group([",", indent([line, print("expr")])]),
   // WHERE CURRENT OF clause
-  where_current_of_clause: (print) => print.spaced(["whereCurrentOfKw", "cursor"])
+  where_current_of_clause: (print) => group(print.spaced(["whereCurrentOfKw", "cursor"]))
 };
 
 // src/syntax/rename_table.ts
@@ -1189,7 +1201,10 @@ var preparedStatementsMap = {
       ...print(["into", "using"]).map((clause) => group(clause))
     ])
   ),
-  execute_into_clause: (print) => print.spaced(["intoKw", "variables"]),
+  execute_expr: (print) => group([
+    print("executeKw"),
+    indent([line, print.separated(line, ["expr", "using"])])
+  ]),
   execute_using_clause: (print) => group([print("usingKw"), indent([line, print("values")])]),
   // PREPARE
   prepare_stmt: (print) => group(
@@ -1207,30 +1222,59 @@ var preparedStatementsMap = {
 
 // src/syntax/procedural_language.ts
 var proceduralLanguageMap = {
+  // labels
+  labeled_stmt: (print, node) => group([
+    print.spaced(["beginLabel", "statement"]),
+    node.endLabel ? [" ", print(["endLabel"])] : []
+  ]),
+  colon_label: (print) => [print("label"), ":"],
+  chevron_label: (print) => ["<<", print("label"), ">>"],
   // BEGIN .. END
   block_stmt: (print, node) => group([
-    print.spaced(["beginKw", "atomicKw"]),
-    indent([hardline, stripTrailingHardline(print("program"))]),
+    stripTrailingHardline(print("declare")),
+    [node.declare ? hardline : [], print.spaced(["beginKw", "atomicKw"])],
+    node.program.statements.length > 0 ? indent([hardline, stripTrailingHardline(print("program"))]) : print("program"),
     node.exception ? [hardline, print("exception")] : [],
     hardline,
     print("endKw")
   ]),
-  exception_clause: (print) => group([
-    print.spaced(["exceptionKw", "whenKw", "condition", "thenKw"]),
-    indent([hardline, stripTrailingHardline(print("program"))])
-  ]),
-  error_category: (print) => print("errorKw"),
   // DECLARE
+  declare_clause: (print, node) => group([print("declareKw"), indent([hardline, print("program")])]),
   declare_stmt: (print) => group(
     join(" ", [
-      print("declareKw"),
+      ...print.spaced(["declareKw"]),
       group(print("names")),
-      ...print.spaced(["dataType", "default"])
+      ...print.spaced(["constantKw", "dataType", "constraints", "init"])
     ])
   ),
-  declare_default: (print) => print.spaced(["defaultKw", "expr"]),
+  declare_init: (print) => print.spaced(["operator", "expr"]),
+  declare_alias_stmt: (print) => group(print.spaced(["newName", "aliasForKw", "oldName"])),
+  // EXCEPTION
+  exception_clause: (print, node) => {
+    if (node.clauses.length === 1) {
+      return group(print.spaced(["exceptionKw", "clauses"]));
+    } else {
+      return group([
+        print("exceptionKw"),
+        indent([
+          hardline,
+          stripTrailingHardline(print("clauses").map((doc2) => [doc2, hardline]))
+        ])
+      ]);
+    }
+  },
+  exception_when_clause: (print, node) => group([
+    join(" ", [print("whenKw"), group(print("condition")), print("thenKw")]),
+    node.program.statements.length > 0 ? indent([hardline, stripTrailingHardline(print("program"))]) : print("program")
+  ]),
+  error_bigquery: (print) => print("errorKw"),
+  error_name: (print) => print("name"),
+  error_sqlstate: (print) => group(print.spaced(["sqlstateKw", "code"])),
+  error_format_string: (print, node) => group(print(["format", "args"])),
   // SET
   set_stmt: (print) => group(print.spaced(["setKw", "assignments"])),
+  // assignment
+  assignment_stmt: (print) => group(print.spaced(["target", "operator", "expr"])),
   // IF
   if_stmt: (print) => group(join(hardline, [...print("clauses"), print.spaced("endIfKw")])),
   if_clause: (print) => [
@@ -1283,6 +1327,8 @@ var proceduralLanguageMap = {
     hardline,
     print.spaced("endWhileKw")
   ]),
+  // WHILE .. LOOP .. END LOOP
+  while_loop_stmt: (print) => group(print.spaced(["whileKw", "condition", "loop"])),
   // FOR .. IN
   for_stmt: (print) => group([
     print.spaced(["forKw", "left", "inKw", "right", "doKw"]),
@@ -1290,26 +1336,53 @@ var proceduralLanguageMap = {
     hardline,
     print.spaced("endForKw")
   ]),
-  // BREAK/CONTINUE
-  break_stmt: (print) => group(print.spaced(["breakKw", "label"])),
-  continue_stmt: (print) => group(print.spaced(["continueKw", "label"])),
-  labeled_stmt: (print, node) => group([
-    print("beginLabel"),
-    ": ",
-    print("statement"),
-    node.endLabel ? [" ", print(["endLabel"])] : []
+  // FOR .. IN range LOOP .. END LOOP
+  for_loop_stmt: (print) => group(print.spaced(["forKw", "left", "inKw", "right", "loop"])),
+  for_range: (print) => group([
+    print.spaced(["reverseKw", "from"]),
+    "..",
+    print.spaced(["to", "by"])
+  ]),
+  for_by_clause: (print) => group(print.spaced(["byKw", "expr"])),
+  // FOREACH
+  foreach_stmt: (print) => group([
+    print.spaced([
+      "foreachKw",
+      "left",
+      "slice",
+      "inArrayKw",
+      "right",
+      "loop"
+    ])
   ]),
+  foreach_slice: (print) => group(print.spaced(["sliceKw", "count"])),
+  // BREAK/CONTINUE
+  break_stmt: (print) => group(print.spaced(["breakKw", "label", "when"])),
+  continue_stmt: (print) => group(print.spaced(["continueKw", "label", "when"])),
   // CALL
   call_stmt: (print) => group(print.spaced(["callKw", "func"])),
   // RETURN
   return_stmt: (print) => group(print.spaced(["returnKw", "expr"])),
+  return_next_stmt: (print) => group(print.spaced(["returnNextKw", "expr"])),
+  return_query_stmt: (print, node) => {
+    if (node.expr.type === "execute_expr") {
+      return group([print.spaced("returnQueryKw"), " ", print("expr")]);
+    } else {
+      return group([print.spaced("returnQueryKw"), " ", indent(print("expr"))]);
+    }
+  },
   // RAISE
-  raise_stmt: (print) => group(print.spaced(["raiseKw", "message"])),
-  raise_message: (print) => [
-    print.spaced("usingMessageKw"),
-    " = ",
-    print("string")
-  ]
+  raise_stmt: (print, node) => group([
+    print.spaced(["raiseKw", "level", "error"]),
+    node.using ? indent([line, print("using")]) : []
+  ]),
+  raise_level: (print) => print("levelKw"),
+  raise_using_clause: (print) => group([print("usingKw"), indent([line, print("options")])]),
+  raise_option_element: (print) => group(print.spaced(["nameKw", "operator", "value"])),
+  // ASSERT
+  assert_stmt: (print) => group(print.spaced(["assertKw", "condition", "message"])),
+  // NULL
+  null_stmt: (print) => group(print.spaced(["nullKw"]))
 };
 
 // src/syntax/procedure.ts
@@ -1356,12 +1429,6 @@ var procClauseMap = {
   returns_clause: (print) => print.spaced(["returnsKw", "dataType"]),
   determinism_clause: (print) => print.spaced("deterministicKw"),
   language_clause: (print) => print.spaced(["languageKw", "name"]),
-  as_clause: (print, node) => {
-    if (isStringLiteral(node.expr) || isDynamicallyLoadedFunction(node.expr)) {
-      return print.spaced(["asKw", "expr"]);
-    }
-    return [print("asKw"), indent([hardline, print("expr")])];
-  },
   with_connection_clause: (print) => print.spaced(["withConnectionKw", "connection"])
 };
 
@@ -1642,7 +1709,6 @@ var selectMap = {
   },
   // INTO clause
   into_table_clause: (print) => print.spaced(["intoKw", "kind", "tableKw", "name"]),
-  into_variables_clause: (print) => group([print("intoKw"), indent([line, print("variables")])]),
   into_dumpfile_clause: (print) => print.spaced(["intoDumpfileKw", "filename"]),
   into_outfile_clause: (print, node) => {
     const hasOptions = node.charset || node.fields || node.lines;
@@ -1839,11 +1905,6 @@ var typeMap = {
   drop_type_stmt: (print) => group(print.spaced(["dropTypeKw", "ifExistsKw", "types", "behaviorKw"]))
 };
 
-// src/syntax/unsupported_grammar.ts
-var unsupportedGrammarMap = {
-  unsupported_grammar_stmt: (print) => group(print("text"))
-};
-
 // src/syntax/update.ts
 var updateMap = {
   update_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
@@ -1989,8 +2050,6 @@ var bigqueryMap = {
       print("actions")
     ])
   ),
-  // ASSERT
-  assert_stmt: (print) => group(print.spaced(["assertKw", "expr", "as"])),
   // EXPORT
   export_data_stmt: (print) => group(
     join(hardline, [
@@ -2079,7 +2138,6 @@ var transformMap = {
   ...triggerMap,
   ...truncateMap,
   ...typeMap,
-  ...unsupportedGrammarMap,
   ...updateMap,
   ...viewMap,
   ...bigqueryMap,
@@ -2221,24 +2279,41 @@ var embedSql = (path, options2) => {
   const node = path.node;
   const parent = path.getParentNode(0);
   const grandParent = path.getParentNode(1);
-  if (isStringLiteral(node) && isAsClause(parent) && (isCreateFunctionStmt(grandParent) || isCreateProcedureStmt(grandParent)) && grandParent.clauses.some(isSqlLanguageClause)) {
-    return async (textToDoc) => {
-      const quote = detectQuote(node);
-      if (!quote) {
-        return void 0;
-      }
-      const sql = await textToDoc(node.value, options2);
-      return [
-        quote,
-        indent([hardline, stripTrailingHardline(sql)]),
-        hardline,
-        quote
-      ];
-    };
+  const pluginOptions = options2;
+  if (isStringLiteral(node) && isAsClause(parent) && (isCreateFunctionStmt(grandParent) || isCreateProcedureStmt(grandParent))) {
+    if (grandParent.clauses.some(isSqlLanguageClause)) {
+      return async (textToDoc) => {
+        const quote = detectQuote(node);
+        if (!quote) {
+          return void 0;
+        }
+        const sql = await textToDoc(node.value, pluginOptions);
+        return [
+          quote,
+          indent([hardline, stripTrailingHardline(sql)]),
+          hardline,
+          quote
+        ];
+      };
+    }
+    if (grandParent.clauses.some(isPlpgsqlLanguageClause) && pluginOptions.sqlExperimentalPlpgsql) {
+      return async (textToDoc) => {
+        const quote = detectQuote(node);
+        if (!quote) {
+          return void 0;
+        }
+        const sql = await textToDoc(node.value, {
+          ...pluginOptions,
+          parser: "plpgsql"
+        });
+        return [quote, [hardline, stripTrailingHardline(sql)], hardline, quote];
+      };
+    }
   }
   return null;
 };
 var isSqlLanguageClause = (clause) => isLanguageClause(clause) && clause.name.name.toLowerCase() === "sql";
+var isPlpgsqlLanguageClause = (clause) => isLanguageClause(clause) && clause.name.name.toLowerCase() === "plpgsql";
 var detectQuote = (node) => {
   const match = node.text.match(/^('|\$[^$]*\$)/);
   const quote = match?.[1];
@@ -2568,12 +2643,12 @@ var options = {
     description: "Enforces a semicolon at the end of last SQL statement"
     // Since 0.13.0
   },
-  sqlAcceptUnsupportedGrammar: {
+  sqlExperimentalPlpgsql: {
     type: "boolean",
     category: "SQL",
     default: false,
-    description: "Skips formatting unsupported SQL statements instead of exiting with an error"
-    // Since 0.12.0
+    description: "Enables formatting for PL/pgSQL in PostgreSQL function bodies"
+    // Since 0.21.0
   }
 };
 
@@ -2603,6 +2678,11 @@ var languages = [
     extensions: [],
     name: "Experimental PostgreSQL SQL",
     parsers: ["postgresql"]
+  },
+  {
+    extensions: [],
+    name: "Experimental PL/pgSQL",
+    parsers: ["plpgsql"]
   }
 ];
 var createParser = (dialect) => ({
@@ -2612,8 +2692,7 @@ var createParser = (dialect) => ({
       includeRange: true,
       includeComments: true,
       filename: options2.filepath,
-      paramTypes: options2.sqlParamTypes,
-      acceptUnsupportedGrammar: options2.sqlAcceptUnsupportedGrammar
+      paramTypes: options2.sqlParamTypes
     }),
     text,
     options2
@@ -2627,7 +2706,8 @@ var parsers = {
   bigquery: createParser("bigquery"),
   mysql: createParser("mysql"),
   mariadb: createParser("mariadb"),
-  postgresql: createParser("postgresql")
+  postgresql: createParser("postgresql"),
+  plpgsql: createParser("plpgsql")
 };
 var printers = {
   "sql-cst": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sql-cst",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Prettier plugin for SQL",
   "contributors": [
     "Barna Magyarkuti <bmagyarkuti@gmail.com>",
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "prettier": "^3.0.3",
-    "sql-parser-cst": "^0.40.0"
+    "sql-parser-cst": "^0.42.0"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",