prettier-plugin-sql-cst 0.10.2 → 0.11.1

package/README.md

@@ -98,10 +98,11 @@ 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` | Converts SQL keywords to `upper` or `lower` case, or `preserve` existing. |
-| `sqlParamTypes`  |  `[]`   | Array of bound parameter types: `?`, `?nr`, `:name`, `@name`, `$name`.    |
+| API Option           | Default | Description                                                                                                                                                                                                                 |
+| -------------------- | :-----: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `sqlKeywordCase`     | `upper` | Converts 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). |
+| `sqlParamTypes`      |  `[]`   | Array of bound parameter types: `?`, `?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)         |
 
 ## FAQ
 
@@ -133,8 +134,8 @@ It also has experimental support for the following dialects:
 The main limitation is that [the parser][sql-parser-cst] does not support full syntax of
 these dialects. One should expect the parser to crash for syntax that's more specific to
 these dialects. But as long as the parsing succeeds, the formatting should also succeed.
-Mainly one can expect the formatting of SELECT statements to work. But beyond that you should
-keep your expectations low. You have been warned.
+Mainly one can expect the formatting of SELECT, INSERT, UPDATE, DELETE statements to work.
+But beyond that you should keep your expectations low. You have been warned.
 
 The specifics of the [SQL formatting style][STYLE_GUIDE] are still very much subject to change.
 Though the general principles should be mostly in place by now.

package/dist/PrintFn.d.ts

@@ -10,6 +10,7 @@ export type PrintFn<T, K = PrintableKey<T>> = {
     spaced(path: K[]): Doc[];
     separated(separator: Doc, path: K): Doc[];
     separated(separator: Doc, path: K[]): Doc[];
+    dynamicLine(): Doc;
 };
 export type PrintableKey<T> = Exclude<keyof T, ReservedKey>;
 type ReservedKey = "type" | "range" | "leading" | "trailing";

package/dist/embedJs.js

@@ -51,7 +51,7 @@ exports.embedJs = void 0;
 var node_utils_1 = require("./node_utils");
 var print_utils_1 = require("./print_utils");
 var embedJs = function (path, options) {
-    var node = path.getValue(); // TODO: Don't use deprecated method
+    var node = path.node;
     var parent = path.getParentNode(0);
     var grandParent = path.getParentNode(1);
     if ((0, node_utils_1.isStringLiteral)(node) &&

package/dist/embedJson.js

@@ -51,7 +51,7 @@ exports.embedJson = void 0;
 var node_utils_1 = require("./node_utils");
 var print_utils_1 = require("./print_utils");
 var embedJson = function (path, options) {
-    var node = path.getValue(); // TODO: Don't use deprecated method
+    var node = path.node;
     var parent = path.getParentNode();
     if ((0, node_utils_1.isStringLiteral)(node) &&
         ((0, node_utils_1.isJsonLiteral)(parent) || (0, node_utils_1.isJsonbLiteral)(parent))) {

package/dist/index.js

@@ -44,7 +44,7 @@ var createParser = function (dialect) { return ({
             includeComments: true,
             filename: options.filepath,
             paramTypes: options.sqlParamTypes,
-        }), text);
+        }), text, options);
     },
     astFormat: "sql-cst",
     locStart: function (node) { var _a; return (_a = node.range) === null || _a === void 0 ? void 0 : _a[0]; },

package/dist/node_utils.d.ts

@@ -15,3 +15,4 @@ export declare const isParenExpr: (node: any) => node is import("sql-parser-cst"
 export declare const isListExpr: (node: any) => node is import("sql-parser-cst").ListExpr<Node>;
 export declare const isCreateFunctionStmt: (node: any) => node is import("sql-parser-cst").CreateFunctionStmt;
 export declare const isLanguageClause: (node: any) => node is import("sql-parser-cst").LanguageClause;
+export declare const isDynamicallyLoadedFunction: (node: any) => node is import("sql-parser-cst").DynamicallyLoadedFunction;

package/dist/node_utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLanguageClause = exports.isCreateFunctionStmt = exports.isListExpr = exports.isParenExpr = exports.isAsClause = exports.isArraySubscript = exports.isStringLiteral = exports.isJsonbLiteral = exports.isJsonLiteral = exports.isEmpty = exports.isKeyword = exports.isCreateTableStmt = exports.isFuncArgs = exports.isFuncCall = exports.isValuesClause = exports.isProgram = void 0;
+exports.isDynamicallyLoadedFunction = exports.isLanguageClause = exports.isCreateFunctionStmt = exports.isListExpr = exports.isParenExpr = exports.isAsClause = exports.isArraySubscript = exports.isStringLiteral = exports.isJsonbLiteral = exports.isJsonLiteral = exports.isEmpty = exports.isKeyword = exports.isCreateTableStmt = exports.isFuncArgs = exports.isFuncCall = exports.isValuesClause = exports.isProgram = void 0;
 var utils_1 = require("./utils");
 var is = function (type) {
     return function (node) {
@@ -23,3 +23,4 @@ exports.isParenExpr = is("paren_expr");
 exports.isListExpr = is("list_expr");
 exports.isCreateFunctionStmt = is("create_function_stmt");
 exports.isLanguageClause = is("language_clause");
+exports.isDynamicallyLoadedFunction = is("dynamically_loaded_function");

package/dist/options.d.ts

@@ -3,6 +3,7 @@ import { Node, ParserOptions as CstParserOptions } from "sql-parser-cst";
 export interface SqlPluginOptions {
     sqlKeywordCase: "preserve" | "upper" | "lower";
     sqlParamTypes: NonNullable<CstParserOptions["paramTypes"]>;
+    sqlCanonicalSyntax: boolean;
 }
 export type AllPrettierOptions<T = Node> = ParserOptions<T> & SqlPluginOptions;
 export declare const options: SupportOptions;

package/dist/options.js

@@ -34,4 +34,11 @@ exports.options = {
         // Since 0.7.0
         // Possible values in array: "?" | "?nr" | ":name" | "$name" | "@name"
     },
+    sqlCanonicalSyntax: {
+        type: "boolean",
+        category: "SQL",
+        default: true,
+        description: "Enforces one true style of SQL syntax (adds and removes keywords)",
+        // Since 0.11.0
+    },
 };

package/dist/printComment.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printComment = void 0;
 var printComment = function (path) {
-    var node = path.getValue();
+    var node = path.node;
     if (node.type === "line_comment") {
         if (/^--[^ \t]/.test(node.text)) {
             return node.text.replace(/^--/, "-- ");

package/dist/printSql.js

@@ -5,12 +5,12 @@ var utils_1 = require("./utils");
 var transformMap_1 = require("./syntax/transformMap");
 var print_utils_1 = require("./print_utils");
 function printSql(path, options, oldPrint) {
-    return printNode(path, options, createPrintFn(path, oldPrint));
+    return printNode(path, options, createPrintFn(path, oldPrint, options));
 }
 exports.printSql = printSql;
 var cachedPrintFn;
 var cachedPath;
-function createPrintFn(path, oldPrint) {
+function createPrintFn(path, oldPrint, opts) {
     // The path parameter will reference the same AstPath instance
     // during the whole printing cycle.
     // So we can keep using the same print function as long as
@@ -21,7 +21,7 @@ function createPrintFn(path, oldPrint) {
     cachedPath = path;
     cachedPrintFn = (function (selector) {
         if ((0, utils_1.isArray)(selector)) {
-            var node_1 = path.getValue();
+            var node_1 = path.node;
             return selector.filter(function (sel) { return (0, utils_1.isDefined)(node_1[sel]); }).map(oldPrint);
         }
         else {
@@ -29,7 +29,7 @@ function createPrintFn(path, oldPrint) {
         }
     });
     cachedPrintFn.separated = function (separator, selector) {
-        var node = path.getValue();
+        var node = path.node;
         var docs = (0, utils_1.arrayWrap)(selector)
             .filter(function (sel) { return (0, utils_1.isDefined)(node[sel]); })
             .map(function (sel) { return [sel, oldPrint(sel)]; })
@@ -46,10 +46,14 @@ function createPrintFn(path, oldPrint) {
         return docs.length > 0 ? [(0, print_utils_1.join)(separator, docs)] : [];
     };
     cachedPrintFn.spaced = function (selector) { return cachedPrintFn.separated(" ", selector); };
+    cachedPrintFn.dynamicLine = function () {
+        var node = path.node;
+        return (0, print_utils_1.containsNewline)(node, opts) ? print_utils_1.hardline : print_utils_1.line;
+    };
     return cachedPrintFn;
 }
 function printNode(path, options, print) {
-    var node = path.getValue();
+    var node = path.node;
     if ((0, utils_1.isArray)(node)) {
         return path.map(print);
     }

package/dist/syntax/alter_table.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.alterTableMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.alterTableMap = {
-    alter_table_stmt: function (print) { return [
-        print.spaced(["alterTableKw", "ifExistsKw", "table"]),
-        print_utils_1.hardline,
-        print("actions"),
-    ]; },
+    alter_table_stmt: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["alterTableKw", "ifExistsKw", "table"]),
+            print.dynamicLine(),
+            print("actions"),
+        ]);
+    },
     alter_action_rename_table: function (print) { return print.spaced(["renameKw", "newName"]); },
     alter_action_rename_column: function (print) {
         return print.spaced(["renameKw", "ifExistsKw", "oldName", "toKw", "newName"]);
@@ -16,19 +18,45 @@ exports.alterTableMap = {
         return print.spaced(["addKw", "ifNotExistsKw", "column"]);
     },
     alter_action_drop_column: function (print) {
-        return print.spaced(["dropKw", "ifExistsKw", "column"]);
+        return print.spaced(["dropKw", "ifExistsKw", "column", "behaviorKw"]);
     },
     alter_action_set_options: function (print) { return print.spaced(["setKw", "options"]); },
     alter_action_set_default_collate: function (print) {
         return print.spaced(["setDefaultCollateKw", "collation"]);
     },
-    alter_action_alter_column: function (print) { return [
-        print.spaced(["alterKw", "ifExistsKw", "column"]),
-        print_utils_1.hardline,
-        print("action"),
-    ]; },
+    alter_action_add_constraint: function (print) {
+        return print.spaced(["addKw", "constraint"]);
+    },
+    alter_action_drop_constraint: function (print) {
+        return print.spaced([
+            "dropConstraintKw",
+            "ifExistsKw",
+            "constraint",
+            "behaviorKw",
+        ]);
+    },
+    alter_action_alter_constraint: function (print) {
+        return print.spaced(["alterConstraintKw", "constraint", "modifiers"]);
+    },
+    alter_action_rename_constraint: function (print) {
+        return print.spaced(["renameConstraintKw", "oldName", "toKw", "newName"]);
+    },
+    alter_action_validate_constraint: function (print) {
+        return print.spaced(["validateConstraintKw", "constraint"]);
+    },
+    alter_action_set_visible: function (print) { return print.spaced("setVisibleKw"); },
+    alter_action_set_invisible: function (print) { return print.spaced("setInvisibleKw"); },
+    // ALTER COLUMN
+    alter_action_alter_column: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["alterKw", "ifExistsKw", "column"]),
+            print.dynamicLine(),
+            print("action"),
+        ]);
+    },
     alter_action_set_default: function (print) { return print.spaced(["setDefaultKw", "expr"]); },
     alter_action_drop_default: function (print) { return print.spaced("dropDefaultKw"); },
+    alter_action_set_not_null: function (print) { return print.spaced("setNotNullKw"); },
     alter_action_drop_not_null: function (print) { return print.spaced("dropNotNullKw"); },
     alter_action_set_data_type: function (print) {
         return print.spaced(["setDataTypeKw", "dataType"]);

package/dist/syntax/base.js

@@ -2,14 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.baseMap = void 0;
 exports.baseMap = {
+    /** cst-ignore: name */
     keyword: function (print, node, path, options) {
         switch (options.sqlKeywordCase) {
             case "preserve":
-                return path.getValue().text;
+                return path.node.text;
             case "upper":
-                return path.getValue().text.toUpperCase();
+                return path.node.text.toUpperCase();
             case "lower":
-                return path.getValue().text.toLowerCase();
+                return path.node.text.toLowerCase();
         }
     },
     all_columns: function () { return "*"; },

package/dist/syntax/constraint.js

@@ -1,8 +1,18 @@
 "use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.constraintMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.constraintMap = {
+    /** cst-ignore: constraint, modifiers */
     constraint: function (print, node) {
         if (node.name) {
             return (0, print_utils_1.group)([
@@ -15,26 +25,24 @@ exports.constraintMap = {
         }
     },
     constraint_name: function (print) { return print.spaced(["constraintKw", "name"]); },
-    constraint_deferrable: function (print) {
-        return print.spaced(["deferrableKw", "initiallyKw"]);
-    },
+    constraint_modifier: function (print) { return print.spaced("kw"); },
     constraint_null: function (print) { return print("nullKw"); },
-    constraint_not_null: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["notNullKw", "onConflict"]));
-    },
+    constraint_not_null: function (print) { return (0, print_utils_1.group)(print.spaced(["notNullKw", "clauses"])); },
     constraint_default: function (print) { return (0, print_utils_1.group)(print.spaced(["defaultKw", "expr"])); },
     constraint_primary_key: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["primaryKeyKw", "direction", "columns", "onConflict"]));
+        return (0, print_utils_1.group)(print.spaced(["primaryKeyKw", "direction", "columns", "clauses"]));
     },
     constraint_unique: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["uniqueKw", "columns", "onConflict"]));
+        return (0, print_utils_1.group)(print.spaced(["uniqueKw", "columns", "nullsKw", "clauses"]));
+    },
+    constraint_check: function (print) {
+        return (0, print_utils_1.group)(print.spaced(["checkKw", "expr", "clauses"]));
     },
-    constraint_check: function (print) { return (0, print_utils_1.group)(print.spaced(["checkKw", "expr"])); },
     constraint_collate: function (print) {
         return (0, print_utils_1.group)(print.spaced(["collateKw", "collation"]));
     },
     constraint_foreign_key: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["foreignKeyKw", "columns", "references"]));
+        return (0, print_utils_1.group)(print.spaced(["foreignKeyKw", "indexName", "columns", "references"]));
     },
     references_specification: function (print, node) {
         var baseDoc = print.spaced(["referencesKw", "table", "columns"]);
@@ -48,11 +56,17 @@ exports.constraintMap = {
             return baseDoc;
         }
     },
-    referential_action: function (print) { return print.spaced(["onKw", "eventKw", "actionKw"]); },
+    index_specification: function (print) {
+        return print.spaced(["expr", "opclass", "direction", "nullHandlingKw"]);
+    },
+    referential_action: function (print) {
+        return print.spaced(["onKw", "eventKw", "actionKw", "columns"]);
+    },
     referential_match: function (print) { return print.spaced(["matchKw", "typeKw"]); },
     constraint_generated: function (print) {
         return print.spaced(["generatedKw", "asKw", "expr", "storageKw"]);
     },
+    identity_column: function (print) { return print("identityKw"); },
     constraint_auto_increment: function (print) { return print("autoIncrementKw"); },
     on_conflict_clause: function (print) { return print.spaced(["onConflictKw", "resolutionKw"]); },
     constraint_comment: function (print) { return print.spaced(["commentKw", "value"]); },
@@ -67,12 +81,29 @@ exports.constraintMap = {
     constraint_engine_attribute: function (print, node) {
         return (0, print_utils_1.join)(node.hasEq ? " = " : " ", print(["engineAttributeKw", "value"]));
     },
+    constraint_compression: function (print) { return print.spaced(["compressionKw", "method"]); },
+    constraint_exclude: function (print, node) {
+        return (0, print_utils_1.group)([
+            print("excludeKw"),
+            (0, print_utils_1.indent)([
+                print_utils_1.line,
+                (0, print_utils_1.join)(print_utils_1.line, __spreadArray([
+                    print.separated(print_utils_1.line, ["using", "params"])
+                ], print("clauses"), true)),
+            ]),
+        ]);
+    },
+    exclusion_param: function (print) { return print.spaced(["index", "withKw", "operator"]); },
+    index_include_clause: function (print) { return print.spaced(["includeKw", "columns"]); },
+    index_tablespace_clause: function (print) {
+        return print.spaced(["usingIndexTablespaceKw", "name"]);
+    },
 };
 var printUnnamedConstraint = function (print, node) {
-    if (node.deferrable) {
+    if (node.modifiers.length > 0) {
         return (0, print_utils_1.group)([
             print("constraint"),
-            (0, print_utils_1.indent)([print_utils_1.hardline, print("deferrable")]),
+            (0, print_utils_1.indent)([print_utils_1.line, print.spaced("modifiers")]),
         ]);
     }
     else {

package/dist/syntax/create_table.js

@@ -13,6 +13,7 @@ exports.createTableMap = void 0;
 var node_utils_1 = require("../node_utils");
 var print_utils_1 = require("../print_utils");
 exports.createTableMap = {
+    /** cst-ignore: clauses */
     create_table_stmt: function (print, node) {
         var rest = [];
         for (var _i = 2; _i < arguments.length; _i++) {
@@ -22,21 +23,21 @@ exports.createTableMap = {
             print.spaced([
                 "createKw",
                 "orReplaceKw",
-                "temporaryKw",
-                "externalKw",
-                "snapshotKw",
-                "virtualKw",
+                "kind",
                 "tableKw",
                 "ifNotExistsKw",
                 "name",
+                "partitionOf",
+                "ofType",
                 "columns",
             ]),
             printClauses.apply(void 0, __spreadArray([print, node], rest, false)),
             node.options ? [print_utils_1.line, (0, print_utils_1.group)(print("options"))] : [],
         ];
     },
+    table_kind: function (print) { return print.spaced("kindKw"); },
     column_definition: function (print) {
-        return print.spaced(["name", "dataType", "constraints"]);
+        return print.spaced(["name", "dataType", "withOptionsKw", "constraints"]);
     },
     table_option: function (print, node) {
         if (node.value && node.hasEq) {
@@ -49,13 +50,53 @@ exports.createTableMap = {
             return print.spaced("name");
         }
     },
-    create_table_like_clause: function (print) { return print.spaced(["likeKw", "name"]); },
+    create_table_like_clause: function (print) {
+        return print.spaced(["likeKw", "name", "options"]);
+    },
+    table_like_option: function (print) {
+        return print.spaced(["includingOrExcludingKw", "optionKw"]);
+    },
     create_table_copy_clause: function (print) { return print.spaced(["copyKw", "name"]); },
     create_table_clone_clause: function (print) { return print.spaced(["cloneKw", "table"]); },
     with_partition_columns_clause: function (print) {
         return print.spaced(["withPartitionColumnsKw", "columns"]);
     },
     create_table_using_clause: function (print) { return print.spaced(["usingKw", "module"]); },
+    create_table_inherits_clause: function (print) {
+        return print.spaced(["inheritsKw", "tables"]);
+    },
+    create_table_partition_by_clause: function (print) {
+        return print.spaced(["partitionByKw", "strategyKw", "columns"]);
+    },
+    create_table_partition_of_clause: function (print) {
+        return print.spaced(["partitionOfKw", "table"]);
+    },
+    create_table_partition_bound_clause: function (print) {
+        return print.spaced(["forValuesKw", "bound"]);
+    },
+    partition_bound_in: function (print) { return print.spaced(["inKw", "values"]); },
+    partition_bound_from_to: function (print) {
+        return print.spaced(["fromKw", "from", "toKw", "to"]);
+    },
+    partition_bound_minvalue: function (print) { return print.spaced("minvalueKw"); },
+    partition_bound_maxvalue: function (print) { return print.spaced("maxvalueKw"); },
+    partition_bound_with: function (print) { return print.spaced(["withKw", "values"]); },
+    partition_bound_modulus: function (print) { return print.spaced(["modulusKw", "value"]); },
+    partition_bound_remainder: function (print) { return print.spaced(["remainderKw", "value"]); },
+    create_table_default_partition_clause: function (print) { return print.spaced("defaultKw"); },
+    create_table_of_type_clause: function (print) { return print.spaced(["ofKw", "typeName"]); },
+    using_access_method_clause: function (print) { return print.spaced(["usingKw", "method"]); },
+    create_table_tablespace_clause: function (print) {
+        return print.spaced(["tablespaceKw", "name"]);
+    },
+    with_storage_parameters_clause: function (print) {
+        return print.spaced(["withKw", "options"]);
+    },
+    create_table_without_oids_clause: function (print) { return print.spaced("withoutOidsKw"); },
+    create_table_on_commit_clause: function (print) {
+        return print.spaced(["onCommitKw", "actionKw"]);
+    },
+    create_table_with_data_clause: function (print) { return print.spaced("withDataKw"); },
 };
 var printClauses = function (print, node) {
     if (node.clauses.length === 1 && (0, node_utils_1.isAsClause)(node.clauses[0])) {

package/dist/syntax/data_type.js

@@ -20,4 +20,5 @@ exports.dataTypeMap = {
     struct_type_param: function (print) {
         return print.spaced(["name", "dataType", "constraints"]);
     },
+    table_data_type: function (print) { return print.spaced(["tableKw", "columns"]); },
 };

package/dist/syntax/dcl.js

@@ -4,17 +4,17 @@ exports.dclMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.dclMap = {
     grant_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, [
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), [
             (0, print_utils_1.group)([print("grantKw"), (0, print_utils_1.indent)([print_utils_1.line, print("roles")])]),
             (0, print_utils_1.group)(print.spaced(["onKw", "resourceType", "resourceName"])),
             (0, print_utils_1.group)([print("toKw"), (0, print_utils_1.indent)([print_utils_1.line, print("users")])]),
-        ]);
+        ]));
     },
     revoke_stmt: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, [
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), [
             (0, print_utils_1.group)([print("revokeKw"), (0, print_utils_1.indent)([print_utils_1.line, print("roles")])]),
             (0, print_utils_1.group)(print.spaced(["onKw", "resourceType", "resourceName"])),
             (0, print_utils_1.group)([print("fromKw"), (0, print_utils_1.indent)([print_utils_1.line, print("users")])]),
-        ]);
+        ]));
     },
 };

package/dist/syntax/delete.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.deleteMap = {
-    delete_stmt: function (print) { return (0, print_utils_1.join)(print_utils_1.hardline, print("clauses")); },
+    delete_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
     delete_clause: function (print) {
         return print.spaced(["deleteKw", "modifiers", "fromKw", "tables"]);
     },

package/dist/syntax/dialects/postgresql.js

@@ -4,4 +4,5 @@ exports.postgresqlMap = void 0;
 exports.postgresqlMap = {
     postgresql_operator_expr: function (print) { return print(["operatorKw", "expr"]); },
     postgresql_operator: function (print) { return print("operator"); },
+    postgresql_operator_class: function (print) { return print("name"); },
 };

package/dist/syntax/drop_table.js

@@ -5,11 +5,11 @@ exports.dropTableMap = {
     drop_table_stmt: function (print) {
         return print.spaced([
             "dropKw",
-            "externalKw",
-            "snapshotKw",
+            "kind",
             "tableKw",
             "ifExistsKw",
             "tables",
+            "behaviorKw",
         ]);
     },
 };

package/dist/syntax/explain.js

@@ -5,7 +5,7 @@ var print_utils_1 = require("../print_utils");
 exports.explainMap = {
     explain_stmt: function (print) {
         return (0, print_utils_1.group)([
-            print.spaced(["explainKw", "queryPlanKw"]),
+            print.spaced(["explainKw", "analyzeKw", "queryPlanKw"]),
             (0, print_utils_1.indent)([print_utils_1.line, print("statement")]),
         ]);
     },

package/dist/syntax/expr.js

@@ -115,7 +115,12 @@ exports.exprMap = {
     over_arg: function (print) { return print.spaced(["overKw", "window"]); },
     having_arg: function (print) { return print.spaced(["havingKw", "minMaxKw", "expr"]); },
     named_arg: function (print) {
-        return (0, print_utils_1.group)([print("name"), " ", "=>", (0, print_utils_1.indent)([print_utils_1.line, print("value")])]);
+        return (0, print_utils_1.group)([
+            print("name"),
+            " ",
+            print("operator"),
+            (0, print_utils_1.indent)([print_utils_1.line, print("value")]),
+        ]);
     },
     cast_expr: function (print) { return print(["castKw", "args"]); },
     cast_arg: function (print) { return print.spaced(["expr", "asKw", "dataType", "format"]); },
@@ -145,10 +150,15 @@ exports.exprMap = {
         return print.spaced(["matchKw", "columns", "againstKw", "args"]);
     },
     full_text_match_args: function (print) { return print.spaced(["expr", "modifier"]); },
+    /** cst-ignore: value */
     number_literal: function (print) { return print("text"); },
+    /** cst-ignore: value */
     boolean_literal: function (print) { return print("valueKw"); },
+    /** cst-ignore: value */
     string_literal: function (print) { return print("text"); },
+    /** cst-ignore: value */
     blob_literal: function (print) { return print("text"); },
+    /** cst-ignore: value */
     null_literal: function (print) { return print("nullKw"); },
     numeric_literal: function (print) { return print.spaced(["numericKw", "string"]); },
     bignumeric_literal: function (print) { return print.spaced(["bignumericKw", "string"]); },
@@ -158,7 +168,9 @@ exports.exprMap = {
     timestamp_literal: function (print) { return print.spaced(["timestampKw", "string"]); },
     json_literal: function (print) { return print.spaced(["jsonKw", "string"]); },
     jsonb_literal: function (print) { return print.spaced(["jsonbKw", "string"]); },
+    /** cst-ignore: name */
     identifier: function (print) { return print("text"); },
+    /** cst-ignore: name */
     variable: function (print) { return print("text"); },
     parameter: function (print) { return print("text"); },
 };

package/dist/syntax/function.js

@@ -22,9 +22,35 @@ exports.functionMap = {
                 (0, print_utils_1.join)(print_utils_1.hardline, print("clauses").map(function (cls) { return (0, print_utils_1.group)(cls); })),
             ],
     ]; },
-    function_param: function (print) { return print.spaced(["name", "dataType"]); },
+    function_param: function (print) {
+        return print.spaced(["mode", "name", "dataType", "default"]);
+    },
+    function_param_default: function (print) { return print.spaced(["operator", "expr"]); },
+    return_clause: function (print) { return print.spaced(["returnKw", "expr"]); },
+    function_behavior_clause: function (print) { return print.spaced(["behaviorKw"]); },
+    function_security_clause: function (print) {
+        return print.spaced(["externalKw", "securityKw"]);
+    },
+    function_cost_clause: function (print) { return print.spaced(["costKw", "cost"]); },
+    function_rows_clause: function (print) { return print.spaced(["rowsKw", "rows"]); },
+    function_support_clause: function (print) { return print.spaced(["supportKw", "name"]); },
+    function_window_clause: function (print) { return print.spaced("windowKw"); },
+    function_transform_clause: function (print) { return print.spaced(["transformKw", "types"]); },
+    transform_type: function (print) { return print.spaced(["forTypeKw", "dataType"]); },
+    set_parameter_clause: function (print) {
+        return print.spaced(["setKw", "name", "operator", "value"]);
+    },
+    set_parameter_from_current_clause: function (print) {
+        return print.spaced(["setKw", "name", "fromCurrentKw"]);
+    },
+    dynamically_loaded_function: function (print) {
+        return (0, print_utils_1.join)(", ", print(["objectFile", "symbol"]));
+    },
     drop_function_stmt: function (print) {
-        return print.spaced(["dropKw", "tableKw", "functionKw", "ifExistsKw", "name"]);
+        return (0, print_utils_1.group)([
+            print.spaced(["dropKw", "tableKw", "functionKw", "ifExistsKw", "name"]),
+            print.spaced(["params", "behaviorKw"]),
+        ]);
     },
 };
 var hasOnlyAsClause = function (node) {

package/dist/syntax/index.js

@@ -12,8 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.indexMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.indexMap = {
-    create_index_stmt: function (print, node) {
-        return (0, print_utils_1.join)(print_utils_1.hardline, __spreadArray([
+    create_index_stmt: function (print) {
+        return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), __spreadArray([
             print.spaced([
                 "createKw",
                 "indexTypeKw",
@@ -24,7 +24,7 @@ exports.indexMap = {
                 "table",
                 "columns",
             ])
-        ], (node.clauses.length > 0 ? [(0, print_utils_1.join)(print_utils_1.hardline, print("clauses"))] : []), true));
+        ], print("clauses"), true)));
     },
     drop_index_stmt: function (print) {
         return print.spaced([

package/dist/syntax/insert.js

@@ -3,15 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.insertMap = {
-    insert_stmt: function (print) { return (0, print_utils_1.join)(print_utils_1.hardline, print("clauses")); },
+    insert_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
     insert_clause: function (print, node) {
         return (0, print_utils_1.group)([
             print.spaced(["insertKw", "modifiers", "orAction", "intoKw", "table"]),
-            node.columns ? (0, print_utils_1.indent)([print_utils_1.hardline, print("columns")]) : [],
+            node.columns ? (0, print_utils_1.indent)([print.dynamicLine(), print("columns")]) : [],
         ]);
     },
     values_clause: function (print) {
-        return (0, print_utils_1.group)([print("valuesKw"), (0, print_utils_1.indent)([print_utils_1.hardline, print("values")])]);
+        return (0, print_utils_1.group)([print("valuesKw"), (0, print_utils_1.indent)([print.dynamicLine(), print("values")])]);
     },
     or_alternate_action: function (print) { return print.spaced(["orKw", "actionKw"]); },
     default: function (print) { return print("defaultKw"); },
@@ -23,17 +23,28 @@ exports.insertMap = {
         return print.spaced(["onConstraintKw", "constraint"]);
     },
     upsert_action_nothing: function (print) { return print("nothingKw"); },
-    upsert_action_update: function (print) { return [
-        print("updateKw"),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, print(["set", "where"]))]),
-    ]; },
-    row_alias_clause: function (print, node) { return [
-        print.spaced(["asKw", "rowAlias"]),
-        node.columnAliases ? (0, print_utils_1.indent)([print_utils_1.hardline, print("columnAliases")]) : [],
-    ]; },
-    on_duplicate_key_update_clause: function (print) { return [
-        print.spaced("onDuplicateKeyUpdateKw"),
-        (0, print_utils_1.indent)([print_utils_1.hardline, print("assignments")]),
-    ]; },
+    upsert_action_update: function (print) {
+        return (0, print_utils_1.group)([
+            print("updateKw"),
+            (0, print_utils_1.indent)([
+                print.dynamicLine(),
+                (0, print_utils_1.join)(print.dynamicLine(), print(["set", "where"])),
+            ]),
+        ]);
+    },
+    row_alias_clause: function (print, node) {
+        return (0, print_utils_1.group)([
+            print.spaced(["asKw", "rowAlias"]),
+            node.columnAliases
+                ? (0, print_utils_1.indent)([print.dynamicLine(), print("columnAliases")])
+                : [],
+        ]);
+    },
+    on_duplicate_key_update_clause: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced("onDuplicateKeyUpdateKw"),
+            (0, print_utils_1.indent)([print.dynamicLine(), print("assignments")]),
+        ]);
+    },
     overriding_clause: function (print) { return print.spaced("overridingKw"); },
 };

package/dist/syntax/proc_clause.js

@@ -8,7 +8,7 @@ exports.procClauseMap = {
     determinism_clause: function (print) { return print.spaced("deterministicKw"); },
     language_clause: function (print) { return print.spaced(["languageKw", "name"]); },
     as_clause: function (print, node) {
-        if ((0, node_utils_1.isStringLiteral)(node.expr)) {
+        if ((0, node_utils_1.isStringLiteral)(node.expr) || (0, node_utils_1.isDynamicallyLoadedFunction)(node.expr)) {
             return print.spaced(["asKw", "expr"]);
         }
         return [print("asKw"), (0, print_utils_1.indent)([print_utils_1.hardline, print("expr")])];

package/dist/syntax/procedural_language.js

@@ -14,7 +14,7 @@ var print_utils_1 = require("../print_utils");
 exports.proceduralLanguageMap = {
     // BEGIN .. END
     block_stmt: function (print, node) { return [
-        print("beginKw"),
+        print.spaced(["beginKw", "atomicKw"]),
         (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("program"))]),
         node.exception ? [print_utils_1.hardline, print("exception")] : [],
         print_utils_1.hardline,
@@ -108,7 +108,7 @@ exports.proceduralLanguageMap = {
     // CALL
     call_stmt: function (print) { return print.spaced(["callKw", "func"]); },
     // RETURN
-    return_stmt: function (print) { return print("returnKw"); },
+    return_stmt: function (print) { return print.spaced(["returnKw", "expr"]); },
     // RAISE
     raise_stmt: function (print) { return print.spaced(["raiseKw", "message"]); },
     raise_message: function (print) { return [

package/dist/syntax/procedure.js

@@ -15,8 +15,10 @@ exports.procedureMap = {
         print_utils_1.hardline,
         (0, print_utils_1.join)(print_utils_1.hardline, print("clauses").map(function (clause) { return (0, print_utils_1.group)(clause); })),
     ]; },
-    procedure_param: function (print) { return print.spaced(["mode", "name", "dataType"]); },
     drop_procedure_stmt: function (print) {
-        return print.spaced(["dropKw", "procedureKw", "ifExistsKw", "name"]);
+        return (0, print_utils_1.group)([
+            print.spaced(["dropKw", "procedureKw", "ifExistsKw", "name"]),
+            print.spaced(["params", "behaviorKw"]),
+        ]);
     },
 };

package/dist/syntax/select.js

@@ -7,10 +7,7 @@ exports.selectMap = {
     compound_select_stmt: function (print) {
         return (0, print_utils_1.join)(print_utils_1.hardline, [print("left"), print.spaced("operator"), print("right")]);
     },
-    select_stmt: function (print, node, path, opts) {
-        var lineType = (0, print_utils_1.containsNewline)(node, opts) ? print_utils_1.hardline : print_utils_1.line;
-        return (0, print_utils_1.group)((0, print_utils_1.join)(lineType, print("clauses")));
-    },
+    select_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
     // WITH clause
     with_clause: function (print) {
         return (0, print_utils_1.group)([
@@ -191,6 +188,7 @@ exports.selectMap = {
         return (0, print_utils_1.group)([print("qualifyKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
     },
     // LIMIT clause
+    /** cst-ignore: count, offsetKw, offset */
     limit_clause: function (print, node) {
         return (0, print_utils_1.group)([
             print("limitKw"),
@@ -235,7 +233,7 @@ exports.selectMap = {
     },
     // INTO clause
     into_table_clause: function (print) {
-        return print.spaced(["intoKw", "temporaryKw", "unloggedKw", "tableKw", "name"]);
+        return print.spaced(["intoKw", "kind", "tableKw", "name"]);
     },
     into_variables_clause: function (print) {
         return (0, print_utils_1.group)([print("intoKw"), (0, print_utils_1.indent)([print_utils_1.line, print("variables")])]);

package/dist/syntax/update.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateMap = void 0;
 var print_utils_1 = require("../print_utils");
 exports.updateMap = {
-    update_stmt: function (print) { return (0, print_utils_1.join)(print_utils_1.hardline, print("clauses")); },
+    update_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
     update_clause: function (print) {
         return print.spaced(["updateKw", "modifiers", "orAction", "tables"]);
     },

package/dist/syntax/view.js

@@ -22,10 +22,24 @@ exports.viewMap = {
         ];
     },
     drop_view_stmt: function (print) {
-        return print.spaced(["dropKw", "materializedKw", "viewKw", "ifExistsKw", "views"]);
+        return print.spaced([
+            "dropKw",
+            "materializedKw",
+            "viewKw",
+            "ifExistsKw",
+            "views",
+            "behaviorKw",
+        ]);
     },
     alter_view_stmt: function (print) { return [
-        print.spaced(["alterKw", "materializedKw", "viewKw", "ifExistsKw", "name"]),
+        print.spaced([
+            "alterKw",
+            "materializedKw",
+            "viewKw",
+            "ifExistsKw",
+            "name",
+            "columns",
+        ]),
         print_utils_1.hardline,
         (0, print_utils_1.join)(print_utils_1.hardline, print("actions")),
     ]; },

package/dist/transform/aliasAs.js

@@ -4,12 +4,11 @@ exports.processAliasAs = void 0;
 var sql_parser_cst_1 = require("sql-parser-cst");
 // Adds AS keyword to aliases if none exists
 var processAliasAs = function (cst) {
-    var mutateAliases = (0, sql_parser_cst_1.cstVisitor)({
+    (0, sql_parser_cst_1.cstVisitor)({
         alias: function (node) {
             node.asKw = node.asKw || { type: "keyword", name: "AS", text: "AS" };
         },
-    });
-    mutateAliases(cst);
+    })(cst);
     return cst;
 };
 exports.processAliasAs = processAliasAs;

package/dist/transform/canonicKeywords.d.ts

@@ -0,0 +1,2 @@
+import { Program } from "sql-parser-cst";
+export declare const canonicKeywords: (cst: Program) => Program;

package/dist/transform/canonicKeywords.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicKeywords = void 0;
+var sql_parser_cst_1 = require("sql-parser-cst");
+var transformUtils_1 = require("./transformUtils");
+var canonicKeywords = function (cst) {
+    (0, sql_parser_cst_1.cstVisitor)({
+        // Replaces TEMP with TEMPORARY
+        table_kind: function (node) {
+            if (Array.isArray(node.kindKw)) {
+                // TODO...
+            }
+            else {
+                if (node.kindKw.name === "TEMP") {
+                    node.kindKw.name = "TEMPORARY";
+                    node.kindKw.text = "TEMPORARY";
+                }
+            }
+        },
+        // Replaces MySQL SELECT DISTINCTROW with SELECT DISTINCT
+        select_distinct: function (node) {
+            if (node.distinctKw.name === "DISTINCTROW") {
+                node.distinctKw.name = "DISTINCT";
+                node.distinctKw.text = "DISTINCT";
+            }
+        },
+        // Replaces RENAME & RENAME AS with RENAME TO
+        alter_action_rename_table: function (node) {
+            if (Array.isArray(node.renameKw)) {
+                if (node.renameKw[1].name === "AS") {
+                    node.renameKw[1].name = "TO";
+                    node.renameKw[1].text = "TO";
+                }
+            }
+            else {
+                node.renameKw = [node.renameKw, (0, transformUtils_1.keyword)("TO")];
+            }
+        },
+        // Replaces INSERT with INSERT INTO
+        insert_clause: function (node) {
+            if (!node.intoKw) {
+                node.intoKw = (0, transformUtils_1.keyword)("INTO");
+            }
+        },
+        // Replaces MERGE with MERGE INTO
+        merge_clause: function (node) {
+            if (!node.intoKw) {
+                node.intoKw = (0, transformUtils_1.keyword)("INTO");
+            }
+        },
+        // Replaces DELETE with DELETE FROM
+        delete_clause: function (node) {
+            if (!node.fromKw) {
+                node.fromKw = (0, transformUtils_1.keyword)("FROM");
+            }
+        },
+        // Replaces TRUNCATE with TRUNCATE TABLE
+        truncate_stmt: function (node) {
+            if (!node.tableKw) {
+                node.tableKw = (0, transformUtils_1.keyword)("TABLE");
+            }
+        },
+    })(cst);
+    return cst;
+};
+exports.canonicKeywords = canonicKeywords;

package/dist/transform/canonicOperators.d.ts

@@ -0,0 +1,3 @@
+import { Program } from "sql-parser-cst";
+import { AllPrettierOptions } from "src/options";
+export declare const canonicOperators: (cst: Program, originalText: string, options: AllPrettierOptions) => Program;

package/dist/transform/canonicOperators.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicOperators = void 0;
+var sql_parser_cst_1 = require("sql-parser-cst");
+var transformUtils_1 = require("./transformUtils");
+var canonicOperators = function (cst, originalText, options) {
+    (0, sql_parser_cst_1.cstVisitor)({
+        binary_expr: function (node) {
+            // Replaces <> operator with !=
+            if (node.operator === "<>") {
+                node.operator = "!=";
+            }
+            // Replace MySQL && and || operators with AND and OR
+            if (options.parser === "mysql" || options.parser === "mariadb") {
+                if (node.operator === "&&") {
+                    node.operator = (0, transformUtils_1.keyword)("AND");
+                }
+                if (node.operator === "||") {
+                    node.operator = (0, transformUtils_1.keyword)("OR");
+                }
+            }
+        },
+        // Replaces PostgreSQL deprecated := operator with =>
+        named_arg: function (node) {
+            if (node.operator === ":=") {
+                node.operator = "=>";
+            }
+        },
+    })(cst);
+    return cst;
+};
+exports.canonicOperators = canonicOperators;

package/dist/transform/stripTrailingCommas.js

@@ -7,14 +7,13 @@ var utils_1 = require("../utils");
 // Removes trailing comma from SELECT clauses
 var stripTrailingCommas = function (cst) {
     // Trailing comma is represented as an empty element at the end of column list
-    var removeLastEmptyColumn = (0, sql_parser_cst_1.cstVisitor)({
+    (0, sql_parser_cst_1.cstVisitor)({
         select_clause: function (node) {
             if (node.columns && (0, node_utils_1.isEmpty)((0, utils_1.last)(node.columns.items))) {
                 node.columns.items = node.columns.items.slice(0, -1);
             }
         },
-    });
-    removeLastEmptyColumn(cst);
+    })(cst);
     return cst;
 };
 exports.stripTrailingCommas = stripTrailingCommas;

package/dist/transform/transformCst.d.ts

@@ -1,2 +1,5 @@
 import { Program } from "sql-parser-cst";
-export declare const transformCst: (cst: Program, originalText: string) => Program;
+import { AllPrettierOptions } from "src/options";
+export declare const transformCst: TransformFn;
+type TransformFn = (cst: Program, originalText: string, options: AllPrettierOptions) => Program;
+export {};

package/dist/transform/transformCst.js

@@ -5,9 +5,19 @@ var comments_1 = require("./comments");
 var aliasAs_1 = require("./aliasAs");
 var stripTrailingCommas_1 = require("./stripTrailingCommas");
 var addFinalSemicolon_1 = require("./addFinalSemicolon");
-// Note that we first perform moveCommentsToRoot transform,
-// so we don't need to worry about comments interfering with other transforms
-var transformCst = function (cst, originalText) {
-    return (0, addFinalSemicolon_1.addFinalSemicolon)((0, stripTrailingCommas_1.stripTrailingCommas)((0, aliasAs_1.processAliasAs)((0, comments_1.moveCommentsToRoot)(cst))), originalText);
+var canonicKeywords_1 = require("./canonicKeywords");
+var canonicOperators_1 = require("./canonicOperators");
+var transformCst = function (cst, originalText, options) {
+    var transforms = [
+        // Note that we first perform moveCommentsToRoot transform,
+        // so we don't need to worry about comments interfering with other transforms
+        comments_1.moveCommentsToRoot,
+        stripTrailingCommas_1.stripTrailingCommas,
+        addFinalSemicolon_1.addFinalSemicolon,
+    ];
+    if (options.sqlCanonicalSyntax) {
+        transforms.push(aliasAs_1.processAliasAs, canonicOperators_1.canonicOperators, canonicKeywords_1.canonicKeywords);
+    }
+    return transforms.reduce(function (cst, transform) { return transform(cst, originalText, options); }, cst);
 };
 exports.transformCst = transformCst;

package/dist/transform/transformUtils.d.ts

@@ -0,0 +1,2 @@
+import { Keyword } from "sql-parser-cst";
+export declare function keyword<T extends string>(name: T): Keyword<T>;

package/dist/transform/transformUtils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyword = void 0;
+function keyword(name) {
+    return { type: "keyword", name: name, text: name };
+}
+exports.keyword = keyword;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sql-cst",
-  "version": "0.10.2",
+  "version": "0.11.1",
   "description": "Prettier plugin for SQL",
   "author": "Rene Saarsoo <nene@triin.net>",
   "license": "GPL-3.0-or-later",
@@ -18,12 +18,13 @@
     "dist/"
   ],
   "scripts": {
-    "prepublishOnly": "yarn test && yarn build",
+    "prepublishOnly": "yarn analyze-field-access && yarn test && yarn build",
     "clean": "rm -rf dist",
     "build": "yarn clean && tsc",
     "test": "yarn node --experimental-vm-modules $(yarn bin jest)",
     "pretty": "prettier -w src/ test/",
-    "ts:check": "tsc --noEmit"
+    "ts:check": "tsc --noEmit",
+    "analyze-field-access": "ts-node scripts/analyze-field-access.ts src/index.ts"
   },
   "keywords": [
     "prettier",
@@ -32,13 +33,14 @@
   ],
   "dependencies": {
     "prettier": "^3.0.3",
-    "sql-parser-cst": "^0.22.1"
+    "sql-parser-cst": "^0.24.0"
   },
   "devDependencies": {
     "@types/jest": "^29.2.5",
     "dedent-js": "^1.0.1",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.2",
     "typescript": "^4.9.4"
   }
 }