prettier-plugin-sql-cst 0.18.0 → 0.19.1

package/dist/printSql.js

@@ -1,15 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printSql = void 0;
-var utils_1 = require("./utils");
-var transformMap_1 = require("./syntax/transformMap");
-var print_utils_1 = require("./print_utils");
-function printSql(path, options, oldPrint) {
+import { arrayWrap, isArray, isDefined, isEmptyArray, isString } from "./utils";
+import { transformMap } from "./syntax/transformMap";
+import { containsNewline, hardline, join, line } from "./print_utils";
+export function printSql(path, options, oldPrint) {
     return printNode(path, options, createPrintFn(path, oldPrint, options));
 }
-exports.printSql = printSql;
-var cachedPrintFn;
-var cachedPath;
+let cachedPrintFn;
+let cachedPath;
 function createPrintFn(path, oldPrint, opts) {
     // The path parameter will reference the same AstPath instance
     // during the whole printing cycle.
@@ -19,53 +15,47 @@ function createPrintFn(path, oldPrint, opts) {
         return cachedPrintFn;
     }
     cachedPath = path;
-    cachedPrintFn = (function (selector) {
-        if ((0, utils_1.isArray)(selector)) {
-            var node_1 = path.node;
-            return selector.filter(function (sel) { return (0, utils_1.isDefined)(node_1[sel]); }).map(oldPrint);
+    cachedPrintFn = ((selector) => {
+        if (isArray(selector)) {
+            const node = path.node;
+            return selector.filter((sel) => isDefined(node[sel])).map(oldPrint);
         }
         else {
             return oldPrint(selector);
         }
     });
-    cachedPrintFn.separated = function (separator, selector) {
-        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)]; })
+    cachedPrintFn.separated = (separator, selector) => {
+        const node = path.node;
+        const docs = arrayWrap(selector)
+            .filter((sel) => isDefined(node[sel]))
+            .map((sel) => [sel, oldPrint(sel)])
             // skip empty arrays
-            .filter(function (_a) {
-            var sel = _a[0], doc = _a[1];
-            return !(0, utils_1.isEmptyArray)(doc);
-        })
+            .filter(([sel, doc]) => !isEmptyArray(doc))
             // only join with spaces when input to print was Node[]
-            .map(function (_a) {
-            var sel = _a[0], doc = _a[1];
-            return ((0, utils_1.isArray)(node[sel]) ? (0, print_utils_1.join)(" ", doc) : doc);
-        });
-        return docs.length > 0 ? [(0, print_utils_1.join)(separator, docs)] : [];
+            .map(([sel, doc]) => (isArray(node[sel]) ? join(" ", doc) : doc));
+        return docs.length > 0 ? [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;
+    cachedPrintFn.spaced = (selector) => cachedPrintFn.separated(" ", selector);
+    cachedPrintFn.dynamicLine = () => {
+        const node = path.node;
+        return containsNewline(node, opts) ? hardline : line;
     };
     return cachedPrintFn;
 }
 function printNode(path, options, print) {
-    var node = path.node;
-    if ((0, utils_1.isArray)(node)) {
+    const node = path.node;
+    if (isArray(node)) {
         return path.map(print);
     }
-    if ((0, utils_1.isString)(node)) {
+    if (isString(node)) {
         return node;
     }
-    if (!(node === null || node === void 0 ? void 0 : node.type)) {
-        throw new Error("No type field on node: ".concat(JSON.stringify(node)));
+    if (!node?.type) {
+        throw new Error(`No type field on node: ${JSON.stringify(node)}`);
     }
-    var fn = transformMap_1.transformMap[node.type];
+    const fn = transformMap[node.type];
     if (!fn) {
-        throw new Error("Unexpected node type: ".concat(node.type));
+        throw new Error(`Unexpected node type: ${node.type}`);
     }
     return fn(print, node, path, options);
 }

package/dist/print_utils.js

@@ -1,57 +1,38 @@
-"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));
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasEmptyLineBetweenNodes = exports.containsNewline = exports.join = exports.stripTrailingHardline = exports.breakParent = exports.ifBreak = exports.lineSuffix = exports.group = exports.indent = exports.softline = exports.hardline = exports.line = void 0;
-var prettier_1 = require("prettier");
-var utils_1 = require("./utils");
-exports.line = (_a = prettier_1.doc.builders, _a.line), exports.hardline = _a.hardline, exports.softline = _a.softline, exports.indent = _a.indent, exports.group = _a.group, exports.lineSuffix = _a.lineSuffix, exports.ifBreak = _a.ifBreak, exports.breakParent = _a.breakParent;
-var origJoin = prettier_1.doc.builders.join;
-exports.stripTrailingHardline = prettier_1.doc.utils.stripTrailingHardline;
+import { doc, util } from "prettier";
+import { isArray } from "./utils";
+export const { line, hardline, softline, indent, group, lineSuffix, ifBreak, breakParent, } = doc.builders;
+const { join: origJoin } = doc.builders;
+export const { stripTrailingHardline } = doc.utils;
 /** Improved join() that also accepts a non-array docs parameter */
-var join = function (sep, docs) {
-    return (0, utils_1.isArray)(docs) ? origJoin(sep, docs) : docs;
-};
-exports.join = join;
+export const join = (sep, docs) => isArray(docs) ? origJoin(sep, docs) : docs;
 /** True when the Node contains a newline in original source code */
-var containsNewline = function (node, opts) {
+export const containsNewline = (node, opts) => {
     if (!node.range) {
         throw new Error("containsNewline() expected a Node with range info");
     }
-    return prettier_1.util.hasNewlineInRange(opts.originalText, node.range[0], node.range[1]);
+    return util.hasNewlineInRange(opts.originalText, node.range[0], node.range[1]);
 };
-exports.containsNewline = containsNewline;
-var hasEmptyLineBetweenNodes = function (node1, node2, opts) {
-    var _a, _b;
+export const hasEmptyLineBetweenNodes = (node1, node2, opts) => {
     if (!node1.range || !node2.range) {
         throw new Error("emptyLineBetweenNodes() expects Nodes with range info");
     }
-    var start = node1.range[1];
-    var end = node2.range[0];
-    var indexes = emptyLineIndexes(opts.originalText.slice(start, end)).map(function (i) { return start + i; });
+    const start = node1.range[1];
+    const end = node2.range[0];
+    const indexes = emptyLineIndexes(opts.originalText.slice(start, end)).map((i) => start + i);
     // when no empty lines between nodes, we can return early
     if (indexes.length === 0) {
         return false;
     }
     // otherwise we need to check whether the empty line happens to be
     // inside a comment or between comments
-    var comments = __spreadArray(__spreadArray([], ((_a = node1.trailing) !== null && _a !== void 0 ? _a : []), true), ((_b = node2.leading) !== null && _b !== void 0 ? _b : []), true);
-    return (indexes.filter(function (index) { return !isIndexInsideOrBetweenComments(index, comments); })
+    const comments = [...(node1.trailing ?? []), ...(node2.leading ?? [])];
+    return (indexes.filter((index) => !isIndexInsideOrBetweenComments(index, comments))
         .length > 0);
 };
-exports.hasEmptyLineBetweenNodes = hasEmptyLineBetweenNodes;
 function emptyLineIndexes(text) {
-    var indexes = [];
-    var re = /\n[ \t]*\r?\n/g;
-    var match;
+    const indexes = [];
+    const re = /\n[ \t]*\r?\n/g;
+    let match;
     while ((match = re.exec(text))) {
         indexes.push(match.index);
     }
@@ -62,7 +43,7 @@ function isIndexInsideOrBetweenComments(index, comments) {
         return false;
     }
     // Assume all nodes have range info
-    var start = comments[0].range[0];
-    var end = comments[comments.length - 1].range[1];
+    const start = comments[0].range[0];
+    const end = comments[comments.length - 1].range[1];
     return start <= index && index <= end;
 }

package/dist/syntax/alias.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.aliasMap = void 0;
-exports.aliasMap = {
-    alias: function (print) { return print.spaced(["expr", "asKw", "alias", "columnAliases"]); },
+export const aliasMap = {
+    alias: (print) => print.spaced(["expr", "asKw", "alias", "columnAliases"]),
 };

package/dist/syntax/alter_action.js

@@ -1,213 +1,120 @@
-"use strict";
-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) {
-        return print.spaced(["renameKw", "ifExistsKw", "oldName", "toKw", "newName"]);
-    },
-    alter_action_add_column: function (print) {
-        return print.spaced(["addKw", "ifNotExistsKw", "column"]);
-    },
-    alter_action_drop_column: function (print) {
-        return print.spaced(["dropKw", "ifExistsKw", "column", "behaviorKw"]);
-    },
-    alter_action_set_bigquery_options: function (print) {
-        return print.spaced(["setKw", "options"]);
-    },
-    alter_action_set_default_collate: function (print) {
-        return print.spaced(["setDefaultCollateKw", "collation"]);
-    },
+import { group, indent, join, line } from "../print_utils";
+import { printUnnamedConstraint } from "./constraint";
+export const alterActionMap = {
+    alter_action_rename: (print) => print.spaced(["renameKw", "newName"]),
+    alter_action_rename_column: (print) => print.spaced(["renameKw", "ifExistsKw", "oldName", "toKw", "newName"]),
+    alter_action_add_column: (print) => print.spaced(["addKw", "ifNotExistsKw", "column"]),
+    alter_action_drop_column: (print) => print.spaced(["dropKw", "ifExistsKw", "column", "behaviorKw"]),
+    alter_action_set_bigquery_options: (print) => print.spaced(["setKw", "options"]),
+    alter_action_set_default_collate: (print) => print.spaced(["setDefaultCollateKw", "collation"]),
     /** 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"]);
-    },
-    alter_action_drop_constraint: function (print) {
-        return print.spaced([
-            "dropConstraintKw",
-            "ifExistsKw",
-            "constraint",
-            "behaviorKw",
-        ]);
-    },
-    alter_action_drop_primary_key: function (print) {
-        return print.spaced(["dropPrimaryKeyKw", "ifExistsKw"]);
-    },
-    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_action_set_tablespace: function (print) {
-        return print.spaced(["setTablespaceKw", "tablespace", "nowaitKw"]);
-    },
-    alter_action_set_schema: function (print) { return print.spaced(["setSchemaKw", "schema"]); },
-    alter_action_enable: function (print) { return print.spaced(["enableKw", "modeKw", "item"]); },
-    alter_action_disable: function (print) { return print.spaced(["disableKw", "item"]); },
-    alter_action_force: function (print) { return print.spaced(["forceKw", "item"]); },
-    alter_action_no_force: function (print) { return print.spaced(["noForceKw", "item"]); },
-    alter_action_cluster_on: function (print) { return print.spaced(["clusterOnKw", "index"]); },
-    alter_action_set_without_cluster: function (print) {
-        return print.spaced("setWithoutClusterKw");
-    },
-    alter_action_set_without_oids: function (print) { return print.spaced("setWithoutOidsKw"); },
-    alter_action_set_access_method: function (print) {
-        return print.spaced(["setAccessMethodKw", "method"]);
-    },
-    alter_action_set_logged: function (print) { return print.spaced("setLoggedKw"); },
-    alter_action_set_unlogged: function (print) { return print.spaced("setUnloggedKw"); },
-    alter_action_inherit: function (print) { return print.spaced(["inheritKw", "table"]); },
-    alter_action_no_inherit: function (print) { return print.spaced(["noInheritKw", "table"]); },
-    alter_action_of_type: function (print) { return print.spaced(["ofKw", "typeName"]); },
-    alter_action_not_of_type: function (print) { return print.spaced("notOfKw"); },
-    alter_action_owner_to: function (print) { return print.spaced(["ownerToKw", "owner"]); },
-    alter_action_replica_identity: function (print) {
-        return print.spaced(["replicaIdentityKw", "identity"]);
-    },
-    replica_identity_using_index: function (print) {
-        return print.spaced(["usingIndexKw", "index"]);
-    },
-    alter_action_set_postgresql_options: function (print) {
-        return print.spaced(["setKw", "options"]);
-    },
-    alter_action_reset_postgresql_options: function (print) {
-        return print.spaced(["resetKw", "options"]);
-    },
-    alter_action_depends_on_extension: function (print) {
-        return print.spaced(["dependsOnExtensionKw", "extension"]);
-    },
-    alter_action_no_depends_on_extension: function (print) {
-        return print.spaced(["noDependsOnExtensionKw", "extension"]);
-    },
-    alter_action_attach_partition: function (print) {
-        return print.spaced(["attachPartitionKw", "index"]);
-    },
-    alter_action_add_enum_value: function (print) {
-        return print.spaced(["addValueKw", "ifNotExistsKw", "value", "position"]);
-    },
-    alter_action_add_enum_value_position: function (print) {
-        return print.spaced(["positionKw", "value"]);
-    },
-    alter_action_rename_enum_value: function (print) {
-        return print.spaced(["renameValueKw", "oldValue", "toKw", "newValue"]);
-    },
-    alter_action_add_attribute: function (print) {
-        return print.spaced([
-            "addAttributeKw",
-            "name",
-            "dataType",
-            "constraint",
-            "behaviorKw",
-        ]);
-    },
-    alter_action_drop_attribute: function (print) {
-        return print.spaced(["dropAttributeKw", "ifExistsKw", "name", "behaviorKw"]);
-    },
-    alter_action_alter_attribute: function (print) {
-        return print.spaced([
-            "alterAttributeKw",
-            "name",
-            "setDataTypeKw",
-            "dataType",
-            "constraint",
-            "behaviorKw",
-        ]);
-    },
-    alter_action_rename_attribute: function (print) {
-        return print.spaced([
-            "renameAttributeKw",
-            "oldName",
-            "toKw",
-            "newName",
-            "behaviorKw",
-        ]);
-    },
+    alter_action_add_constraint: (print, node) => group([
+        print.spaced(["addKw", "name"]),
+        indent([line, printUnnamedConstraint(print, node)]),
+    ]),
+    alter_action_add_constraint_constraint_name: (print) => print.spaced(["constraintKw", "ifNotExistsKw", "name"]),
+    alter_action_drop_constraint: (print) => print.spaced([
+        "dropConstraintKw",
+        "ifExistsKw",
+        "constraint",
+        "behaviorKw",
+    ]),
+    alter_action_drop_primary_key: (print) => print.spaced(["dropPrimaryKeyKw", "ifExistsKw"]),
+    alter_action_alter_constraint: (print) => print.spaced(["alterConstraintKw", "constraint", "modifiers"]),
+    alter_action_rename_constraint: (print) => print.spaced(["renameConstraintKw", "oldName", "toKw", "newName"]),
+    alter_action_validate_constraint: (print) => print.spaced(["validateConstraintKw", "constraint"]),
+    alter_action_set_visible: (print) => print.spaced("setVisibleKw"),
+    alter_action_set_invisible: (print) => print.spaced("setInvisibleKw"),
+    alter_action_set_tablespace: (print) => print.spaced(["setTablespaceKw", "tablespace", "nowaitKw"]),
+    alter_action_set_schema: (print) => print.spaced(["setSchemaKw", "schema"]),
+    alter_action_enable: (print) => print.spaced(["enableKw", "modeKw", "item"]),
+    alter_action_disable: (print) => print.spaced(["disableKw", "item"]),
+    alter_action_force: (print) => print.spaced(["forceKw", "item"]),
+    alter_action_no_force: (print) => print.spaced(["noForceKw", "item"]),
+    alter_action_cluster_on: (print) => print.spaced(["clusterOnKw", "index"]),
+    alter_action_set_without_cluster: (print) => print.spaced("setWithoutClusterKw"),
+    alter_action_set_without_oids: (print) => print.spaced("setWithoutOidsKw"),
+    alter_action_set_access_method: (print) => print.spaced(["setAccessMethodKw", "method"]),
+    alter_action_set_logged: (print) => print.spaced("setLoggedKw"),
+    alter_action_set_unlogged: (print) => print.spaced("setUnloggedKw"),
+    alter_action_inherit: (print) => print.spaced(["inheritKw", "table"]),
+    alter_action_no_inherit: (print) => print.spaced(["noInheritKw", "table"]),
+    alter_action_of_type: (print) => print.spaced(["ofKw", "typeName"]),
+    alter_action_not_of_type: (print) => print.spaced("notOfKw"),
+    alter_action_owner_to: (print) => print.spaced(["ownerToKw", "owner"]),
+    alter_action_replica_identity: (print) => print.spaced(["replicaIdentityKw", "identity"]),
+    replica_identity_using_index: (print) => print.spaced(["usingIndexKw", "index"]),
+    alter_action_set_postgresql_options: (print) => print.spaced(["setKw", "options"]),
+    alter_action_reset_postgresql_options: (print) => print.spaced(["resetKw", "options"]),
+    alter_action_depends_on_extension: (print) => print.spaced(["dependsOnExtensionKw", "extension"]),
+    alter_action_no_depends_on_extension: (print) => print.spaced(["noDependsOnExtensionKw", "extension"]),
+    alter_action_attach_partition: (print) => print.spaced(["attachPartitionKw", "index"]),
+    alter_action_add_enum_value: (print) => print.spaced(["addValueKw", "ifNotExistsKw", "value", "position"]),
+    alter_action_add_enum_value_position: (print) => print.spaced(["positionKw", "value"]),
+    alter_action_rename_enum_value: (print) => print.spaced(["renameValueKw", "oldValue", "toKw", "newValue"]),
+    alter_action_add_attribute: (print) => print.spaced([
+        "addAttributeKw",
+        "name",
+        "dataType",
+        "constraint",
+        "behaviorKw",
+    ]),
+    alter_action_drop_attribute: (print) => print.spaced(["dropAttributeKw", "ifExistsKw", "name", "behaviorKw"]),
+    alter_action_alter_attribute: (print) => print.spaced([
+        "alterAttributeKw",
+        "name",
+        "setDataTypeKw",
+        "dataType",
+        "constraint",
+        "behaviorKw",
+    ]),
+    alter_action_rename_attribute: (print) => print.spaced([
+        "renameAttributeKw",
+        "oldName",
+        "toKw",
+        "newName",
+        "behaviorKw",
+    ]),
     // 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", "clauses"]);
-    },
-    alter_action_set_statistics: function (print) {
-        return print.spaced(["setStatisticsKw", "value"]);
-    },
-    alter_action_set_compression: function (print) {
-        return print.spaced(["setCompressionKw", "method"]);
-    },
-    alter_action_set_storage: function (print) { return print.spaced(["setStorageKw", "typeKw"]); },
-    alter_action_drop_expression: function (print) {
-        return print.spaced(["dropExpressionKw", "ifExistsKw"]);
-    },
-    alter_action_drop_identity: function (print) {
-        return print.spaced(["dropIdentityKw", "ifExistsKw"]);
-    },
-    alter_action_add_identity: function (print) {
-        return print.spaced([
-            "addGeneratedKw",
-            "whenKw",
-            "asIdentityKw",
-            "sequenceOptions",
-        ]);
-    },
-    alter_action_alter_identity: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.line, print("actions"))); },
-    alter_action_set_generated: function (print) {
-        return print.spaced(["setGeneratedKw", "whenKw"]);
-    },
-    alter_action_restart: function (print) {
-        return print.spaced(["restartKw", "withKw", "value"]);
-    },
-    alter_action_set_sequence_option: function (print) {
-        return print.spaced(["setKw", "option"]);
-    },
-    alter_action_with_role_options: function (print, node) {
-        return node.withKw
-            ? (0, print_utils_1.group)([print("withKw"), (0, print_utils_1.indent)([print_utils_1.line, (0, print_utils_1.join)(print_utils_1.line, print("options"))])])
-            : // This works in tandem with the logic inside alter_role_stmt
-                (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.line, print("options")));
-    },
-    alter_action_set_postgresql_option: function (print) {
-        return print.spaced(["setKw", "name", "operator", "value"]);
-    },
-    alter_action_set_postgresql_option_from_current: function (print) {
-        return print.spaced(["setKw", "name", "fromCurrentKw"]);
-    },
-    alter_action_reset_postgresql_option: function (print) {
-        return print.spaced(["resetKw", "name"]);
-    },
-    alter_action_add_user: function (print) { return (0, print_utils_1.group)(print.spaced(["addUserKw", "users"])); },
-    alter_action_drop_user: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["dropUserKw", "users"]));
-    },
+    alter_action_alter_column: (print) => group([
+        print.spaced(["alterKw", "ifExistsKw", "column"]),
+        print.dynamicLine(),
+        print("action"),
+    ]),
+    alter_action_set_default: (print) => print.spaced(["setDefaultKw", "expr"]),
+    alter_action_drop_default: (print) => print.spaced("dropDefaultKw"),
+    alter_action_set_not_null: (print) => print.spaced("setNotNullKw"),
+    alter_action_drop_not_null: (print) => print.spaced("dropNotNullKw"),
+    alter_action_set_data_type: (print) => print.spaced(["setDataTypeKw", "dataType", "clauses"]),
+    alter_action_set_statistics: (print) => print.spaced(["setStatisticsKw", "value"]),
+    alter_action_set_compression: (print) => print.spaced(["setCompressionKw", "method"]),
+    alter_action_set_storage: (print) => print.spaced(["setStorageKw", "typeKw"]),
+    alter_action_drop_expression: (print) => print.spaced(["dropExpressionKw", "ifExistsKw"]),
+    alter_action_drop_identity: (print) => print.spaced(["dropIdentityKw", "ifExistsKw"]),
+    alter_action_add_identity: (print) => print.spaced([
+        "addGeneratedKw",
+        "whenKw",
+        "asIdentityKw",
+        "sequenceOptions",
+    ]),
+    alter_action_alter_identity: (print) => group(join(line, print("actions"))),
+    alter_action_set_generated: (print) => print.spaced(["setGeneratedKw", "whenKw"]),
+    alter_action_restart: (print) => print.spaced(["restartKw", "withKw", "value"]),
+    alter_action_set_sequence_option: (print) => print.spaced(["setKw", "option"]),
+    alter_action_with_role_options: (print, node) => node.withKw
+        ? group([print("withKw"), indent([line, join(line, print("options"))])])
+        : // This works in tandem with the logic inside alter_role_stmt
+            group(join(line, print("options"))),
+    alter_action_set_postgresql_option: (print) => print.spaced(["setKw", "name", "operator", "value"]),
+    alter_action_set_postgresql_option_from_current: (print) => print.spaced(["setKw", "name", "fromCurrentKw"]),
+    alter_action_reset_postgresql_option: (print) => print.spaced(["resetKw", "name"]),
+    alter_action_add_user: (print) => group(print.spaced(["addUserKw", "users"])),
+    alter_action_drop_user: (print) => group(print.spaced(["dropUserKw", "users"])),
     // ENABLE/DISABLE ..
-    toggle_trigger: function (print) { return print.spaced(["triggerKw", "name"]); },
-    toggle_rule: function (print) { return print.spaced(["ruleKw", "name"]); },
-    toggle_row_level_security: function (print) { return print.spaced("rowLevelSecurityKw"); },
+    toggle_trigger: (print) => print.spaced(["triggerKw", "name"]),
+    toggle_rule: (print) => print.spaced(["ruleKw", "name"]),
+    toggle_row_level_security: (print) => print.spaced("rowLevelSecurityKw"),
     // SET DATA TYPE ...
-    set_data_type_collate_clause: function (print) {
-        return print.spaced(["collateKw", "collation"]);
-    },
-    set_data_type_using_clause: function (print) { return print.spaced(["usingKw", "expr"]); },
+    set_data_type_collate_clause: (print) => print.spaced(["collateKw", "collation"]),
+    set_data_type_using_clause: (print) => print.spaced(["usingKw", "expr"]),
 };

package/dist/syntax/alter_table.js

@@ -1,28 +1,19 @@
-"use strict";
-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 (0, print_utils_1.group)([
-            print.spaced(["alterTableKw", "ifExistsKw", "table"]),
-            print.dynamicLine(),
-            print("actions"),
-        ]);
-    },
-    alter_table_all_in_tablespace_stmt: function (print) {
-        return (0, print_utils_1.group)([
-            print.spaced([
-                "alterTableKw",
-                "allInTablespaceKw",
-                "tablespace",
-                "ownedBy",
-            ]),
-            print.dynamicLine(),
-            print("action"),
-        ]);
-    },
-    owned_by_clause: function (print) {
-        return (0, print_utils_1.group)([print.spaced("ownedByKw"), (0, print_utils_1.indent)([print_utils_1.line, print("owners")])]);
-    },
+import { group, indent, line } from "../print_utils";
+export const alterTableMap = {
+    alter_table_stmt: (print) => group([
+        print.spaced(["alterTableKw", "ifExistsKw", "table"]),
+        print.dynamicLine(),
+        print("actions"),
+    ]),
+    alter_table_all_in_tablespace_stmt: (print) => group([
+        print.spaced([
+            "alterTableKw",
+            "allInTablespaceKw",
+            "tablespace",
+            "ownedBy",
+        ]),
+        print.dynamicLine(),
+        print("action"),
+    ]),
+    owned_by_clause: (print) => group([print.spaced("ownedByKw"), indent([line, print("owners")])]),
 };

package/dist/syntax/analyze.js

@@ -1,9 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.analyzeMap = {
-    analyze_stmt: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["analyzeKw", "tableKw", "tables"]));
-    },
+import { group } from "../print_utils";
+export const analyzeMap = {
+    analyze_stmt: (print) => group(print.spaced(["analyzeKw", "tableKw", "tables"])),
 };

package/dist/syntax/base.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.baseMap = void 0;
-var node_utils_1 = require("../node_utils");
-exports.baseMap = {
+import { isDataType } from "../node_utils";
+export const baseMap = {
     /** cst-ignore: name */
-    keyword: function (print, node, path, options) {
-        var keywordCase = (0, node_utils_1.isDataType)(path.ancestors)
+    keyword: (print, node, path, options) => {
+        const keywordCase = isDataType(path.ancestors)
             ? options.sqlTypeCase
             : options.sqlKeywordCase;
         switch (keywordCase) {
@@ -17,6 +14,6 @@ exports.baseMap = {
                 return path.node.text.toLowerCase();
         }
     },
-    all_columns: function () { return "*"; },
-    empty: function () { return []; },
+    all_columns: () => "*",
+    empty: () => [],
 };