prettier-plugin-sql-cst 0.18.0 → 0.19.0

package/dist/{CstToDocMap.d.ts → src/CstToDocMap.d.ts}

@@ -1,11 +1,11 @@
 import { Node } from "sql-parser-cst";
 import { AstPath, Doc } from "prettier";
-import { PrintFn } from "./PrintFn";
+import { PrintableKey, PrintFn } from "./PrintFn";
 import { AllPrettierOptions } from "./options";
 export type NodeByType<TType, TNode> = Extract<TNode, {
     type: TType;
 }>;
-export type ToDocFn<TNode> = (print: PrintFn<TNode>, node: TNode, path: AstPath<TNode>, options: AllPrettierOptions<TNode>) => Doc;
+export type ToDocFn<TNode> = (print: PrintFn<TNode, PrintableKey<TNode>>, node: TNode, path: AstPath<TNode>, options: AllPrettierOptions<TNode>) => Doc;
 export type CstToDocMap<TNode extends Node> = {
     [TType in TNode["type"]]: ToDocFn<NodeByType<TType, TNode>>;
 };

package/dist/src/CstToDocMap.js

@@ -0,0 +1 @@
+export {};

package/dist/src/PrintFn.js

@@ -0,0 +1 @@
+export {};

package/dist/src/embed.js

@@ -0,0 +1,6 @@
+import { embedJs } from "./embedJs";
+import { embedJson } from "./embedJson";
+import { embedSql } from "./embedSql";
+export const embed = (...args) => {
+    return embedJson(...args) || embedJs(...args) || embedSql(...args);
+};

package/dist/src/embedJs.js

@@ -0,0 +1,43 @@
+import { isAsClause, isCreateFunctionStmt, isLanguageClause, isStringLiteral, } from "./node_utils";
+import { hardline, indent, stripTrailingHardline } from "./print_utils";
+export const embedJs = (path, options) => {
+    const node = path.node;
+    const parent = path.getParentNode(0);
+    const grandParent = path.getParentNode(1);
+    if (isStringLiteral(node) &&
+        isAsClause(parent) &&
+        isCreateFunctionStmt(grandParent) &&
+        grandParent.clauses.some(isJavaScriptLanguageClause)) {
+        return async (textToDoc) => {
+            const quotes = detectQuotes(node.value);
+            if (!quotes) {
+                // Give up for now. Don't format JavaScript inside the string.
+                // Perhaps tackle this corner-case in the future.
+                return undefined;
+            }
+            const js = await textToDoc(node.value, {
+                ...options,
+                parser: "babel",
+            });
+            return [
+                quotes[0],
+                indent([hardline, stripTrailingHardline(js)]),
+                hardline,
+                quotes[1],
+            ];
+        };
+    }
+    return null;
+};
+const isJavaScriptLanguageClause = (clause) => isLanguageClause(clause) && clause.name.name === "js";
+// Whether to quote the code with single- or double-quotes.
+// Returns undefined when neither can be used without escaping.
+const detectQuotes = (js) => {
+    if (!/'''/.test(js)) {
+        return ["r'''", "'''"];
+    }
+    if (!/"""/.test(js)) {
+        return ['r"""', '"""'];
+    }
+    return undefined;
+};

package/dist/src/embedJson.js

@@ -0,0 +1,34 @@
+import { isJsonLiteral, isJsonbLiteral, isStringLiteral } from "./node_utils";
+import { ifBreak, indent, softline, stripTrailingHardline, } from "./print_utils";
+export const embedJson = (path, options) => {
+    const node = path.node;
+    const parent = path.getParentNode();
+    if (isStringLiteral(node) &&
+        (isJsonLiteral(parent) || isJsonbLiteral(parent))) {
+        return async (textToDoc) => {
+            if (containsTripleQuote(node.value) ||
+                containsBackslash(node.value) ||
+                isRawString(node)) {
+                // Give up for now. Don't format JSON inside the string.
+                // Tackle these corner-case in the future.
+                return undefined;
+            }
+            const json = await textToDoc(node.value, {
+                ...options,
+                parser: "json",
+            });
+            const inlineQuote = containsSingleQuote(node.value) ? "'''" : "'";
+            return [
+                ifBreak("'''", inlineQuote),
+                indent([softline, stripTrailingHardline(json)]),
+                softline,
+                ifBreak("'''", inlineQuote),
+            ];
+        };
+    }
+    return null;
+};
+const containsSingleQuote = (json) => /'/.test(json);
+const containsTripleQuote = (json) => /'''/.test(json);
+const containsBackslash = (json) => /\\/.test(json);
+const isRawString = (node) => /^R/i.test(node.text);

package/dist/src/embedSql.js

@@ -0,0 +1,39 @@
+import { isAsClause, isCreateFunctionStmt, isCreateProcedureStmt, isLanguageClause, isStringLiteral, } from "./node_utils";
+import { hardline, indent, stripTrailingHardline } from "./print_utils";
+export const embedSql = (path, options) => {
+    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 undefined;
+            }
+            const sql = await textToDoc(node.value, options);
+            return [
+                quote,
+                indent([hardline, stripTrailingHardline(sql)]),
+                hardline,
+                quote,
+            ];
+        };
+    }
+    return null;
+};
+const isSqlLanguageClause = (clause) => isLanguageClause(clause) && clause.name.name.toLowerCase() === "sql";
+const detectQuote = (node) => {
+    const match = node.text.match(/^('|\$[^$]*\$)/);
+    const quote = match?.[1];
+    if (quote === "'") {
+        // Convert `'` quotes to `$$`.
+        // But bail out if the code already contains $$.
+        return node.value.includes("$$") ? undefined : "$$";
+    }
+    else {
+        return quote;
+    }
+};

package/dist/src/index.js

@@ -0,0 +1,64 @@
+import { parse } from "sql-parser-cst";
+import { printSql } from "./printSql";
+import { printComment } from "./printComment";
+import { embed } from "./embed";
+import { isNode } from "./utils";
+import { transformCst } from "./transform/transformCst";
+export { options } from "./options";
+export const languages = [
+    {
+        extensions: [".sql", ".sqlite"],
+        name: "SQLite SQL",
+        parsers: ["sqlite"],
+    },
+    {
+        extensions: [".bigquery"],
+        name: "BigQuery SQL",
+        parsers: ["bigquery"],
+    },
+    {
+        extensions: [],
+        name: "Experimental MySQL SQL",
+        parsers: ["mysql"],
+    },
+    {
+        extensions: [],
+        name: "Experimental MariaDB SQL",
+        parsers: ["mariadb"],
+    },
+    {
+        extensions: [],
+        name: "Experimental PostgreSQL SQL",
+        parsers: ["postgresql"],
+    },
+];
+const createParser = (dialect) => ({
+    parse: (text, options) => transformCst(parse(text, {
+        dialect,
+        includeRange: true,
+        includeComments: true,
+        filename: options.filepath,
+        paramTypes: options.sqlParamTypes,
+        acceptUnsupportedGrammar: options
+            .sqlAcceptUnsupportedGrammar,
+    }), text, options),
+    astFormat: "sql-cst",
+    locStart: (node) => node.range?.[0],
+    locEnd: (node) => node.range?.[1],
+});
+export const parsers = {
+    sqlite: createParser("sqlite"),
+    bigquery: createParser("bigquery"),
+    mysql: createParser("mysql"),
+    mariadb: createParser("mariadb"),
+    postgresql: createParser("postgresql"),
+};
+export const printers = {
+    "sql-cst": {
+        print: printSql,
+        embed: embed,
+        printComment: printComment,
+        canAttachComment: isNode,
+        isBlockComment: (node) => node.type === "block_comment",
+    },
+};

package/dist/{node_utils.d.ts → src/node_utils.d.ts}

@@ -28,6 +28,7 @@ export declare const isDynamicallyLoadedFunction: (node: any) => node is import(
 export declare const isBigqueryQuotedMemberExpr: (node: any) => node is import("sql-parser-cst").BigQueryQuotedMemberExpr;
 export declare const isCreateTriggerStmt: (node: any) => node is import("sql-parser-cst").CreateTriggerStmt;
 export declare const isExecuteClause: (node: any) => node is import("sql-parser-cst").ExecuteClause;
+export declare const isFunctionSignature: (node: any) => node is import("sql-parser-cst").FunctionSignature;
 export declare const isDataTypeName: (node: any) => node is import("sql-parser-cst").DataTypeName;
 export declare const isIntervalDataType: (node: any) => node is import("sql-parser-cst").IntervalDataType;
 export declare const isIntervalUnit: (node: any) => node is import("sql-parser-cst").IntervalUnit;

package/dist/src/node_utils.js

@@ -0,0 +1,44 @@
+import { isObject } from "./utils";
+const is = (type) => (node) => isObject(node) && node.type === type;
+export const isProgram = is("program");
+export const isValuesClause = is("values_clause");
+export const isFuncCall = is("func_call");
+export const isFuncArgs = is("func_args");
+export const isCreateTableStmt = is("create_table_stmt");
+export const isKeyword = is("keyword");
+export const isEmpty = is("empty");
+export const isJsonLiteral = is("json_literal");
+export const isJsonbLiteral = is("jsonb_literal");
+export const isStringLiteral = is("string_literal");
+export const isArraySubscript = is("array_subscript");
+export const isAsClause = is("as_clause");
+export const isParenExpr = is("paren_expr");
+export const isMemberExpr = is("member_expr");
+export const isSelectStmt = is("select_stmt");
+export const isCompoundSelectStmt = is("compound_select_stmt");
+export const isListExpr = is("list_expr");
+export const isCreateFunctionStmt = is("create_function_stmt");
+export const isAlterFunctionStmt = is("alter_function_stmt");
+export const isDropFunctionStmt = is("drop_function_stmt");
+export const isCreateProcedureStmt = is("create_procedure_stmt");
+export const isAlterProcedureStmt = is("alter_procedure_stmt");
+export const isDropProcedureStmt = is("drop_procedure_stmt");
+export const isAlterActionRename = is("alter_action_rename");
+export const isLanguageClause = is("language_clause");
+export const isDynamicallyLoadedFunction = is("dynamically_loaded_function");
+export const isBigqueryQuotedMemberExpr = is("bigquery_quoted_member_expr");
+export const isCreateTriggerStmt = is("create_trigger_stmt");
+export const isExecuteClause = is("execute_clause");
+export const isFunctionSignature = is("function_signature");
+export const isDataTypeName = is("data_type_name");
+export const isIntervalDataType = is("interval_data_type");
+export const isIntervalUnit = is("interval_unit");
+export const isIntervalUnitRange = is("interval_unit_range");
+export const isTimeDataType = is("time_data_type");
+export const isParametricDataType = is("parametric_data_type");
+export const isDataType = ([node, ...ancestors]) => isDataTypeName(node) ||
+    isIntervalDataType(node) ||
+    (isIntervalUnit(node) && isDataType(ancestors)) ||
+    (isIntervalUnitRange(node) && isDataType(ancestors)) ||
+    isTimeDataType(node) ||
+    isParametricDataType(node);

package/dist/{options.js → src/options.js}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.options = void 0;
-exports.options = {
+export const options = {
     sqlKeywordCase: {
         type: "choice",
         category: "SQL",

package/dist/{printComment.js → src/printComment.js}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printComment = void 0;
-var printComment = function (path) {
-    var node = path.node;
+export const printComment = (path) => {
+    const node = path.node;
     if (node.type === "line_comment") {
         if (/^--[^ \t]/.test(node.text)) {
             return node.text.replace(/^--/, "-- ");
@@ -13,4 +10,3 @@ var printComment = function (path) {
     }
     return node.text;
 };
-exports.printComment = printComment;

package/dist/src/printSql.js

@@ -0,0 +1,61 @@
+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));
+}
+let cachedPrintFn;
+let cachedPath;
+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
+    // the path stays the same.
+    if (cachedPath === path) {
+        return cachedPrintFn;
+    }
+    cachedPath = path;
+    cachedPrintFn = ((selector) => {
+        if (isArray(selector)) {
+            const node = path.node;
+            return selector.filter((sel) => isDefined(node[sel])).map(oldPrint);
+        }
+        else {
+            return oldPrint(selector);
+        }
+    });
+    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(([sel, doc]) => !isEmptyArray(doc))
+            // only join with spaces when input to print was Node[]
+            .map(([sel, doc]) => (isArray(node[sel]) ? join(" ", doc) : doc));
+        return docs.length > 0 ? [join(separator, docs)] : [];
+    };
+    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) {
+    const node = path.node;
+    if (isArray(node)) {
+        return path.map(print);
+    }
+    if (isString(node)) {
+        return node;
+    }
+    if (!node?.type) {
+        throw new Error(`No type field on node: ${JSON.stringify(node)}`);
+    }
+    const fn = transformMap[node.type];
+    if (!fn) {
+        throw new Error(`Unexpected node type: ${node.type}`);
+    }
+    return fn(print, node, path, options);
+}

package/dist/src/print_utils.js

@@ -0,0 +1,49 @@
+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 */
+export const join = (sep, docs) => isArray(docs) ? origJoin(sep, docs) : docs;
+/** True when the Node contains a newline in original source code */
+export const containsNewline = (node, opts) => {
+    if (!node.range) {
+        throw new Error("containsNewline() expected a Node with range info");
+    }
+    return util.hasNewlineInRange(opts.originalText, node.range[0], node.range[1]);
+};
+export const hasEmptyLineBetweenNodes = (node1, node2, opts) => {
+    if (!node1.range || !node2.range) {
+        throw new Error("emptyLineBetweenNodes() expects Nodes with range info");
+    }
+    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
+    const comments = [...(node1.trailing ?? []), ...(node2.leading ?? [])];
+    return (indexes.filter((index) => !isIndexInsideOrBetweenComments(index, comments))
+        .length > 0);
+};
+function emptyLineIndexes(text) {
+    const indexes = [];
+    const re = /\n[ \t]*\r?\n/g;
+    let match;
+    while ((match = re.exec(text))) {
+        indexes.push(match.index);
+    }
+    return indexes;
+}
+function isIndexInsideOrBetweenComments(index, comments) {
+    if (comments.length === 0) {
+        return false;
+    }
+    // Assume all nodes have range info
+    const start = comments[0].range[0];
+    const end = comments[comments.length - 1].range[1];
+    return start <= index && index <= end;
+}

package/dist/src/syntax/alias.js

@@ -0,0 +1,3 @@
+export const aliasMap = {
+    alias: (print) => print.spaced(["expr", "asKw", "alias", "columnAliases"]),
+};

package/dist/src/syntax/alter_action.js

@@ -0,0 +1,120 @@
+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: (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: (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: (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: (print) => print.spaced(["collateKw", "collation"]),
+    set_data_type_using_clause: (print) => print.spaced(["usingKw", "expr"]),
+};

package/dist/src/syntax/alter_table.js

@@ -0,0 +1,19 @@
+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/src/syntax/analyze.js

@@ -0,0 +1,4 @@
+import { group } from "../print_utils";
+export const analyzeMap = {
+    analyze_stmt: (print) => group(print.spaced(["analyzeKw", "tableKw", "tables"])),
+};

package/dist/{syntax → src/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: () => [],
 };

package/dist/src/syntax/cast.js

@@ -0,0 +1,4 @@
+import { group } from "../print_utils";
+export const castMap = {
+    cast_definition: (print) => group(print.spaced(["from", "asKw", "to"])),
+};

package/dist/src/syntax/comment.js

@@ -0,0 +1,54 @@
+import { group, indent, line } from "../print_utils";
+export const commentMap = {
+    comment_stmt: (print) => group([
+        print.spaced(["commentKw", "onKw", "target", "isKw"]),
+        indent([line, print("message")]),
+    ]),
+    comment_target_aggregate: (print) => group([print.spaced(["aggregateKw", "name"]), print(["params"])]),
+    comment_target_function: (print) => group([print.spaced(["functionKw", "name"]), print(["params"])]),
+    comment_target_procedure: (print) => group([print.spaced(["procedureKw", "name"]), print(["params"])]),
+    comment_target_routine: (print) => group([print.spaced(["routineKw", "name"]), print(["params"])]),
+    comment_target_access_method: (print) => group(print.spaced(["accessMethodKw", "name"])),
+    comment_target_cast: (print) => group(print.spaced(["castKw", "args"])),
+    comment_target_collation: (print) => group(print.spaced(["collationKw", "name"])),
+    comment_target_column: (print) => group(print.spaced(["columnKw", "name"])),
+    comment_target_table_constraint: (print) => group(print.spaced(["constraintKw", "name", "onKw", "tableName"])),
+    comment_target_domain_constraint: (print) => group(print.spaced(["constraintKw", "name", "onKw", "domainKw", "domainName"])),
+    comment_target_conversion: (print) => group(print.spaced(["conversionKw", "name"])),
+    comment_target_database: (print) => group(print.spaced(["databaseKw", "name"])),
+    comment_target_domain: (print) => group(print.spaced(["domainKw", "name"])),
+    comment_target_extension: (print) => group(print.spaced(["extensionKw", "name"])),
+    comment_target_event_trigger: (print) => group(print.spaced(["eventTriggerKw", "name"])),
+    comment_target_foreign_data_wrapper: (print) => group(print.spaced(["foreignDataWrapperKw", "name"])),
+    comment_target_foreign_table: (print) => group(print.spaced(["foreignTableKw", "name"])),
+    comment_target_index: (print) => group(print.spaced(["indexKw", "name"])),
+    comment_target_language: (print) => group(print.spaced(["languageKw", "name"])),
+    comment_target_large_object: (print) => group(print.spaced(["largeObjectKw", "oid"])),
+    comment_target_materialized_view: (print) => group(print.spaced(["materializedViewKw", "name"])),
+    comment_target_operator_class: (print) => group(print.spaced(["operatorClassKw", "name", "usingKw", "methodName"])),
+    comment_target_operator_family: (print) => group(print.spaced(["operatorFamilyKw", "name", "usingKw", "methodName"])),
+    comment_target_policy: (print) => group(print.spaced(["policyKw", "name", "onKw", "tableName"])),
+    comment_target_publication: (print) => group(print.spaced(["publicationKw", "name"])),
+    comment_target_role: (print) => group(print.spaced(["roleKw", "name"])),
+    comment_target_rule: (print) => group(print.spaced(["ruleKw", "name", "onKw", "tableName"])),
+    comment_target_schema: (print) => group(print.spaced(["schemaKw", "name"])),
+    comment_target_sequence: (print) => group(print.spaced(["sequenceKw", "name"])),
+    comment_target_server: (print) => group(print.spaced(["serverKw", "name"])),
+    comment_target_statistics: (print) => group(print.spaced(["statisticsKw", "name"])),
+    comment_target_subscription: (print) => group(print.spaced(["subscriptionKw", "name"])),
+    comment_target_table: (print) => group(print.spaced(["tableKw", "name"])),
+    comment_target_tablespace: (print) => group(print.spaced(["tablespaceKw", "name"])),
+    comment_target_text_search_configuration: (print) => group(print.spaced(["textSearchConfigurationKw", "name"])),
+    comment_target_text_search_dictionary: (print) => group(print.spaced(["textSearchDictionaryKw", "name"])),
+    comment_target_text_search_parser: (print) => group(print.spaced(["textSearchParserKw", "name"])),
+    comment_target_text_search_template: (print) => group(print.spaced(["textSearchTemplateKw", "name"])),
+    comment_target_transform: (print) => group(print.spaced([
+        "transformForKw",
+        "typeName",
+        "languageKw",
+        "languageName",
+    ])),
+    comment_target_trigger: (print) => group(print.spaced(["triggerKw", "name", "onKw", "tableName"])),
+    comment_target_type: (print) => group(print.spaced(["typeKw", "name"])),
+    comment_target_view: (print) => group(print.spaced(["viewKw", "name"])),
+};