prettier-plugin-sql-cst 0.1.0

package/README.md

@@ -0,0 +1,45 @@
+# Prettier plugin SQL-CST
+
+A [Prettier][] plugin for SQL that uses [sql-parser-cst][] and the
+actual [Prettier formatting algorithm][wadler-prettier].
+
+Like Prettier for JavaScript,
+this plugin formats SQL expressions differently depending on their length.
+A short SQL query will be formatted on a single line:
+
+```sql
+SELECT a, b, c FROM tbl WHERE x > 10
+```
+
+A longer query, will get each clause printed on a separate line:
+
+```sql
+SELECT id, client.name, client.priority
+FROM client
+WHERE client.id IN (12, 18, 121)
+```
+
+An even longer one gets the contents of each clause indented:
+
+```sql
+SELECT
+  client.id,
+  client.name AS client_name,
+  organization.name AS org_name,
+  count(order.id) AS nr_of_orders
+FROM
+  client
+  LEFT JOIN organization ON client.organization_id = organization.id
+  LEFT JOIN order ON order.client_id = client.id
+WHERE
+  client.status = 'active'
+  AND client.id IN (28, 214, 457)
+  AND order.status IN ('active', 'pending', 'processing')
+GROUP BY client.id
+ORDER BY client.name
+LIMIT 100
+```
+
+[prettier]: https://prettier.io/
+[sql-parser-cst]: https://github.com/nene/sql-parser-cst
+[wadler-prettier]: http://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf

package/dist/CstToDocMap.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/PrintFn.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/comments.js

@@ -0,0 +1,43 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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.moveCommentsToRoot = void 0;
+var visitAllNodes_1 = require("./visitAllNodes");
+/**
+ * Gathers comments from .leading and .trailing fields of all nodes
+ * into a single .comments field in root Program node.
+ *
+ * Deletes the .leading and .trailing fields of all nodes.
+ */
+var moveCommentsToRoot = function (cst) {
+    return __assign(__assign({}, cst), { comments: extractComments(cst) });
+};
+exports.moveCommentsToRoot = moveCommentsToRoot;
+var extractComments = function (cst) {
+    var comments = [];
+    (0, visitAllNodes_1.visitAllNodes)(cst, function (node) {
+        comments.push.apply(comments, __spreadArray(__spreadArray([], (node.leading || []), false), (node.trailing || []), false));
+        delete node.leading;
+        delete node.trailing;
+    });
+    return comments;
+};

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printers = exports.parsers = exports.languages = exports.options = void 0;
+var sql_parser_cst_1 = require("sql-parser-cst");
+var printSql_1 = require("./printSql");
+var utils_1 = require("./utils");
+var comments_1 = require("./comments");
+var options_1 = require("./options");
+Object.defineProperty(exports, "options", { enumerable: true, get: function () { return options_1.options; } });
+exports.languages = [
+    {
+        extensions: [".sql"],
+        name: "SQL",
+        parsers: ["sql-parser-cst"],
+    },
+];
+exports.parsers = {
+    "sql-parser-cst": {
+        parse: function (text, parsers, options) {
+            return (0, comments_1.moveCommentsToRoot)((0, sql_parser_cst_1.parse)(text, {
+                dialect: "sqlite",
+                includeRange: true,
+                includeComments: true,
+                filename: options.filepath,
+            }));
+        },
+        astFormat: "sql-cst",
+        locStart: function (node) { var _a; return (_a = node.range) === null || _a === void 0 ? void 0 : _a[0]; },
+        locEnd: function (node) { var _a; return (_a = node.range) === null || _a === void 0 ? void 0 : _a[1]; },
+    },
+};
+exports.printers = {
+    "sql-cst": {
+        print: printSql_1.printSql,
+        printComment: function (path) {
+            return path.getValue().text;
+        },
+        canAttachComment: utils_1.isNode,
+        isBlockComment: function (node) { return node.type === "block_comment"; },
+    },
+};

package/dist/node_utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKeyword = exports.isCreateTableStmt = exports.isFuncCall = exports.isValuesClause = void 0;
+var utils_1 = require("./utils");
+var is = function (type) {
+    return function (node) {
+        return (0, utils_1.isObject)(node) && node.type === type;
+    };
+};
+exports.isValuesClause = is("values_clause");
+exports.isFuncCall = is("func_call");
+exports.isCreateTableStmt = is("create_table_stmt");
+exports.isKeyword = is("keyword");

package/dist/options.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.options = void 0;
+exports.options = {
+    sqlKeywordCase: {
+        type: "choice",
+        category: "SQL",
+        since: "0.1.0",
+        default: "preserve",
+        description: "Enforces upper/lower case for SQL keywords",
+        choices: [
+            {
+                value: "preserve",
+                description: "preserves the existing case",
+            },
+            { value: "upper", description: "forces all keywords to uppercase" },
+            { value: "lower", description: "forces all keywords to lowercase" },
+        ],
+    },
+};

package/dist/printSql.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printSql = void 0;
+var utils_1 = require("./utils");
+var syntax_1 = require("./syntax");
+var print_utils_1 = require("./print_utils");
+function printSql(path, options, oldPrint) {
+    return printNode(path, options, createPrintFn(path, oldPrint));
+}
+exports.printSql = printSql;
+var cachedPrintFn;
+var cachedPath;
+function createPrintFn(path, oldPrint) {
+    // 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 = (function (selector) {
+        if ((0, utils_1.isArray)(selector)) {
+            var node_1 = path.getValue();
+            return selector.filter(function (sel) { return (0, utils_1.isDefined)(node_1[sel]); }).map(oldPrint);
+        }
+        else {
+            return oldPrint(selector);
+        }
+    });
+    cachedPrintFn.spaced = function (selector) {
+        var node = path.getValue();
+        var docs = (0, utils_1.arrayWrap)(selector)
+            .filter(function (sel) { return (0, utils_1.isDefined)(node[sel]); })
+            .map(function (sel) { return [sel, oldPrint(sel)]; })
+            // skip empty arrays
+            .filter(function (_a) {
+            var sel = _a[0], doc = _a[1];
+            return !(0, utils_1.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)(" ", docs)] : [];
+    };
+    return cachedPrintFn;
+}
+function printNode(path, options, print) {
+    var node = path.getValue();
+    if ((0, utils_1.isArray)(node)) {
+        return path.map(print);
+    }
+    if ((0, utils_1.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)));
+    }
+    var fn = syntax_1.transformMap[node.type];
+    if (!fn) {
+        throw new Error("Unexpected node type: ".concat(node.type));
+    }
+    return fn(print, node, path, options);
+}

package/dist/print_utils.js

@@ -0,0 +1,21 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsNewline = exports.join = 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;
+var origJoin = prettier_1.doc.builders.join;
+/** 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;
+/** True when the Node contains a newline in original source code */
+var containsNewline = function (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]);
+};
+exports.containsNewline = containsNewline;

package/dist/syntax/alias.js

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

package/dist/syntax/base.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseMap = void 0;
+exports.baseMap = {
+    keyword: function (print, node, path, options) {
+        switch (options.sqlKeywordCase) {
+            case "preserve":
+                return path.getValue().text;
+            case "upper":
+                return path.getValue().text.toUpperCase();
+            case "lower":
+                return path.getValue().text.toLowerCase();
+        }
+    },
+    all_columns: function () { return "*"; },
+    empty: function () { return []; },
+};

package/dist/syntax/constraint.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constraintMap = void 0;
+var print_utils_1 = require("../print_utils");
+exports.constraintMap = {
+    constraint: function (print, node) {
+        if (node.name) {
+            return (0, print_utils_1.group)([
+                print("name"),
+                (0, print_utils_1.indent)([print_utils_1.line, printUnnamedConstraint(print, node)]),
+            ]);
+        }
+        else {
+            return printUnnamedConstraint(print, node);
+        }
+    },
+    constraint_name: function (print) { return print.spaced(["constraintKw", "name"]); },
+    constraint_deferrable: function (print) {
+        return print.spaced(["deferrableKw", "initiallyKw"]);
+    },
+    constraint_not_null: function (print) {
+        return (0, print_utils_1.group)(print.spaced(["notNullKw", "onConflict"]));
+    },
+    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", "orderKw", "columns", "onConflict"]));
+    },
+    constraint_unique: function (print) {
+        return (0, print_utils_1.group)(print.spaced(["uniqueKw", "columns", "onConflict"]));
+    },
+    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"]));
+    },
+    references_specification: function (print, node) {
+        var baseDoc = print.spaced(["referencesKw", "table", "columns"]);
+        if (node.options.length > 0) {
+            return (0, print_utils_1.group)([
+                baseDoc,
+                (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, print("options"))]),
+            ]);
+        }
+        else {
+            return baseDoc;
+        }
+    },
+    referential_action: function (print) { return print.spaced(["onKw", "eventKw", "actionKw"]); },
+    referential_match: function (print) { return print.spaced(["matchKw", "typeKw"]); },
+    constraint_generated: function (print) {
+        return print.spaced(["generatedKw", "asKw", "expr", "storageKw"]);
+    },
+    constraint_auto_increment: function (print) { return print("autoIncrementKw"); },
+    on_conflict_clause: function (print) { return print.spaced(["onConflictKw", "resolutionKw"]); },
+};
+var printUnnamedConstraint = function (print, node) {
+    if (node.deferrable) {
+        return (0, print_utils_1.group)([
+            print("constraint"),
+            (0, print_utils_1.indent)([print_utils_1.hardline, print("deferrable")]),
+        ]);
+    }
+    else {
+        return print("constraint");
+    }
+};

package/dist/syntax/create_table.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTableMap = void 0;
+var print_utils_1 = require("../print_utils");
+exports.createTableMap = {
+    create_table_stmt: function (print, node) { return [
+        print.spaced([
+            "createKw",
+            "temporaryKw",
+            "tableKw",
+            "ifNotExistsKw",
+            "name",
+            "columns",
+            "clauses",
+        ]),
+        node.options ? [" ", (0, print_utils_1.group)(print("options"))] : [],
+    ]; },
+    column_definition: function (print) {
+        return print.spaced(["name", "dataType", "constraints"]);
+    },
+    table_option: function (print) { return print.spaced(["name"]); },
+};

package/dist/syntax/data_type.js

@@ -0,0 +1,15 @@
+"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.dataTypeMap = void 0;
+exports.dataTypeMap = {
+    data_type: function (print) { return __spreadArray([print.spaced("nameKw")], print(["params"]), true); },
+};

package/dist/syntax/delete.js

@@ -0,0 +1,8 @@
+"use strict";
+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_clause: function (print) { return print.spaced(["deleteKw", "fromKw", "table"]); },
+};

package/dist/syntax/expr.js

@@ -0,0 +1,72 @@
+"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.exprMap = void 0;
+var print_utils_1 = require("../print_utils");
+var node_utils_1 = require("../node_utils");
+exports.exprMap = {
+    list_expr: function (print, node, path) {
+        var parent = path.getParentNode();
+        return (0, print_utils_1.join)([",", (0, node_utils_1.isValuesClause)(parent) ? print_utils_1.hardline : print_utils_1.line], print("items").map(function (it) { return (0, print_utils_1.group)(it); }));
+    },
+    paren_expr: function (print, node, path) {
+        var parent = path.getParentNode();
+        var lineStyle = (0, node_utils_1.isCreateTableStmt)(parent) ? print_utils_1.hardline : print_utils_1.softline;
+        return (0, print_utils_1.group)(["(", (0, print_utils_1.indent)([lineStyle, print("expr")]), lineStyle, ")"]);
+    },
+    binary_expr: function (print, node) {
+        if ((0, node_utils_1.isKeyword)(node.operator) && isBooleanOp(node.operator)) {
+            return (0, print_utils_1.join)(print_utils_1.line, [print("left"), print.spaced(["operator", "right"])]);
+        }
+        return print.spaced(["left", "operator", "right"]);
+    },
+    prefix_op_expr: function (print) { return print.spaced(["operator", "expr"]); },
+    postfix_op_expr: function (print) { return print.spaced(["expr", "operator"]); },
+    between_expr: function (print) {
+        return print.spaced(["left", "betweenKw", "begin", "andKw", "end"]);
+    },
+    case_expr: function (print) { return [
+        print.spaced(["caseKw", "expr"]),
+        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, print("clauses"))]),
+        print_utils_1.hardline,
+        print("endKw"),
+    ]; },
+    case_when: function (print) {
+        return print.spaced(["whenKw", "condition", "thenKw", "result"]);
+    },
+    case_else: function (print) { return print.spaced(["elseKw", "result"]); },
+    member_expr: function (print) { return [print("object"), ".", print("property")]; },
+    func_call: function (print) {
+        var fnCall = print(["name", "args"]);
+        var extras = print(["filter", "over"]);
+        if (extras.length > 1) {
+            return (0, print_utils_1.group)([fnCall, (0, print_utils_1.indent)([print_utils_1.line, (0, print_utils_1.join)(print_utils_1.line, extras)])]);
+        }
+        else {
+            return (0, print_utils_1.group)((0, print_utils_1.join)(" ", __spreadArray([fnCall], extras, true)));
+        }
+    },
+    func_args: function (print) { return print.spaced(["distinctKw", "args"]); },
+    filter_arg: function (print) { return print.spaced(["filterKw", "where"]); },
+    over_arg: function (print) { return print.spaced(["overKw", "window"]); },
+    cast_expr: function (print) { return print(["castKw", "args"]); },
+    cast_arg: function (print) { return print.spaced(["expr", "asKw", "dataType"]); },
+    raise_expr: function (print) { return print(["raiseKw", "args"]); },
+    number_literal: function (print) { return print("text"); },
+    boolean_literal: function (print) { return print("valueKw"); },
+    string_literal: function (print) { return print("text"); },
+    null_literal: function (print) { return print("nullKw"); },
+    identifier: function (print) { return print("text"); },
+};
+var isBooleanOp = function (_a) {
+    var name = _a.name;
+    return name === "AND" || name === "OR";
+};

package/dist/syntax/frame.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frameMap = void 0;
+var print_utils_1 = require("../print_utils");
+exports.frameMap = {
+    frame_clause: function (print, node) { return [
+        print.spaced(["unitKw", "extent"]),
+        node.exclusion ? [print_utils_1.hardline, print("exclusion")] : [],
+    ]; },
+    frame_bound_current_row: function (print) { return print.spaced("currentRowKw"); },
+    frame_bound_preceding: function (print) { return print.spaced(["expr", "precedingKw"]); },
+    frame_bound_following: function (print) { return print.spaced(["expr", "followingKw"]); },
+    frame_unbounded: function (print) { return print.spaced("unboundedKw"); },
+    frame_between: function (print) {
+        return print.spaced(["betweenKw", "begin", "andKw", "end"]);
+    },
+    frame_exclusion: function (print) { return print.spaced(["excludeKw", "kindKw"]); },
+};

package/dist/syntax/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformMap = void 0;
+var alias_1 = require("./alias");
+var base_1 = require("./base");
+var constraint_1 = require("./constraint");
+var create_table_1 = require("./create_table");
+var data_type_1 = require("./data_type");
+var delete_1 = require("./delete");
+var expr_1 = require("./expr");
+var frame_1 = require("./frame");
+var insert_1 = require("./insert");
+var proc_clause_1 = require("./proc_clause");
+var program_1 = require("./program");
+var select_1 = require("./select");
+var update_1 = require("./update");
+exports.transformMap = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, alias_1.aliasMap), base_1.baseMap), constraint_1.constraintMap), create_table_1.createTableMap), data_type_1.dataTypeMap), delete_1.deleteMap), expr_1.exprMap), frame_1.frameMap), insert_1.insertMap), proc_clause_1.procClauseMap), program_1.programMap), select_1.selectMap), update_1.updateMap);

package/dist/syntax/insert.js

@@ -0,0 +1,26 @@
+"use strict";
+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_clause: function (print, node) {
+        return (0, print_utils_1.group)([
+            print.spaced(["insertKw", "orAction", "intoKw", "table"]),
+            node.columns ? (0, print_utils_1.indent)([print_utils_1.hardline, 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")])]);
+    },
+    or_alternate_action: function (print) { return print.spaced(["orKw", "actionKw"]); },
+    default_values: function (print) { return print.spaced("defaultValuesKw"); },
+    upsert_clause: function (print) {
+        return print.spaced(["onConflictKw", "columns", "where", "doKw", "action"]);
+    },
+    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"]))]),
+    ]; },
+};

package/dist/syntax/proc_clause.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.procClauseMap = void 0;
+var print_utils_1 = require("../print_utils");
+exports.procClauseMap = {
+    as_clause: function (print) { return [print("asKw"), (0, print_utils_1.indent)([print_utils_1.hardline, print("expr")])]; },
+};

package/dist/syntax/program.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.programMap = void 0;
+var print_utils_1 = require("../print_utils");
+exports.programMap = {
+    program: function (print, node, path) { return path.map(printLineWith(print), "statements"); },
+};
+var printLineWith = function (print) {
+    return function (childPath, i, all) {
+        var node = childPath.getValue();
+        if (i === 0) {
+            return print(childPath);
+        }
+        else if (i < all.length - 1 || node.type !== "empty") {
+            return [";", print_utils_1.hardline, print(childPath)];
+        }
+        else {
+            return [";", print(childPath)];
+        }
+    };
+};

package/dist/syntax/select.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectMap = void 0;
+var utils_1 = require("../utils");
+var print_utils_1 = require("../print_utils");
+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")));
+    },
+    with_clause: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["withKw", "recursiveKw"]),
+            (0, print_utils_1.indent)([print_utils_1.line, print("tables")]),
+        ]);
+    },
+    common_table_expression: function (print) { return [
+        print(["table", "columns"]),
+        " ",
+        print.spaced(["asKw", "materializedKw", "expr"]),
+    ]; },
+    select_clause: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced(["selectKw", "distinctKw"]),
+            (0, print_utils_1.indent)([print_utils_1.line, print("columns")]),
+        ]);
+    },
+    from_clause: function (print) {
+        return (0, print_utils_1.group)([print("fromKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
+    },
+    join_expr: function (print, node) {
+        if (node.operator === ",") {
+            return (0, print_utils_1.join)([",", print_utils_1.hardline], print(["left", "right"]));
+        }
+        else {
+            return [
+                print("left"),
+                print_utils_1.hardline,
+                (0, print_utils_1.group)((0, print_utils_1.join)(" ", [
+                    print.spaced("operator"),
+                    [
+                        print("right"),
+                        node.specification
+                            ? (0, print_utils_1.indent)([print_utils_1.line, print(["specification"])])
+                            : [],
+                    ],
+                ])),
+            ];
+        }
+    },
+    join_on_specification: function (print) { return (0, print_utils_1.group)(print.spaced(["onKw", "expr"])); },
+    join_using_specification: function (print) { return (0, print_utils_1.group)(print.spaced(["usingKw", "expr"])); },
+    indexed_table: function (print) { return print.spaced(["table", "indexedByKw", "index"]); },
+    not_indexed_table: function (print) { return print.spaced(["table", "notIndexedKw"]); },
+    where_clause: function (print) {
+        return (0, print_utils_1.group)([print("whereKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
+    },
+    order_by_clause: function (print) {
+        return (0, print_utils_1.group)([print.spaced("orderByKw"), (0, print_utils_1.indent)([print_utils_1.line, print("specifications")])]);
+    },
+    group_by_clause: function (print) {
+        return (0, print_utils_1.group)([print.spaced("groupByKw"), (0, print_utils_1.indent)([print_utils_1.line, print("columns")])]);
+    },
+    partition_by_clause: function (print) {
+        return (0, print_utils_1.group)([
+            print.spaced("partitionByKw"),
+            (0, print_utils_1.indent)([print_utils_1.line, print("specifications")]),
+        ]);
+    },
+    having_clause: function (print) {
+        return (0, print_utils_1.group)([print("havingKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
+    },
+    returning_clause: function (print) {
+        return (0, print_utils_1.group)([print("returningKw"), (0, print_utils_1.indent)([print_utils_1.line, print("columns")])]);
+    },
+    limit_clause: function (print, node) {
+        return (0, print_utils_1.group)([print("limitKw"), (0, print_utils_1.indent)([print_utils_1.line, printLimitValues(print, node)])]);
+    },
+    sort_specification: function (print) {
+        return print.spaced(["expr", "orderKw", "nullHandlingKw"]);
+    },
+    window_clause: function (print, node) {
+        var lineType = node.namedWindows.items.length > 1 ? print_utils_1.hardline : print_utils_1.line;
+        return (0, print_utils_1.group)([
+            print("windowKw"),
+            (0, print_utils_1.indent)([lineType, print("namedWindows")]),
+        ]);
+    },
+    named_window: function (print) { return print.spaced(["name", "asKw", "window"]); },
+    window_definition: function (print, node) {
+        var itemCount = [
+            node.baseWindowName,
+            node.partitionBy,
+            node.orderBy,
+            node.frame,
+        ].filter(utils_1.isDefined).length;
+        var lineType = itemCount > 1 ? print_utils_1.hardline : print_utils_1.line;
+        return (0, print_utils_1.group)((0, print_utils_1.join)(lineType, print(["baseWindowName", "partitionBy", "orderBy", "frame"])));
+    },
+};
+var printLimitValues = function (print, node) {
+    if (node.offsetKw) {
+        return print.spaced(["count", "offsetKw", "offset"]);
+    }
+    else if (node.offset) {
+        return (0, print_utils_1.join)([",", " "], print(["offset", "count"]));
+    }
+    else {
+        return print("count");
+    }
+};

package/dist/syntax/update.js

@@ -0,0 +1,21 @@
+"use strict";
+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_clause: function (print) {
+        return print.spaced(["updateKw", "options", "orAction", "tables"]);
+    },
+    set_clause: function (print, node) {
+        if (node.assignments.items.length > 1) {
+            return [print("setKw"), (0, print_utils_1.indent)([print_utils_1.hardline, print("assignments")])];
+        }
+        else {
+            return print.spaced(["setKw", "assignments"]);
+        }
+    },
+    column_assignment: function (print) {
+        return (0, print_utils_1.join)([" ", "=", " "], print(["column", "expr"]));
+    },
+};

package/dist/utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayWrap = exports.isNode = exports.isEmptyArray = exports.isArray = exports.isObject = exports.isString = exports.isDefined = void 0;
+var isDefined = function (value) {
+    return value !== undefined;
+};
+exports.isDefined = isDefined;
+var isString = function (value) {
+    return typeof value === "string";
+};
+exports.isString = isString;
+var isObject = function (x) {
+    return typeof x === "object" && x !== null && !(x instanceof Array);
+};
+exports.isObject = isObject;
+var isArray = function (x) { return Array.isArray(x); };
+exports.isArray = isArray;
+var isEmptyArray = function (x) { return (0, exports.isArray)(x) && x.length === 0; };
+exports.isEmptyArray = isEmptyArray;
+var isNode = function (value) {
+    return (0, exports.isObject)(value) && (0, exports.isString)(value.type) && !isCommentType(value.type);
+};
+exports.isNode = isNode;
+var isCommentType = function (type) {
+    return type === "block_comment" || type === "line_comment";
+};
+var arrayWrap = function (x) { return ((0, exports.isArray)(x) ? x : [x]); };
+exports.arrayWrap = arrayWrap;

package/dist/visitAllNodes.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitAllNodes = void 0;
+var utils_1 = require("./utils");
+/* Executes a function with all nodes in syntax tree */
+var visitAllNodes = function (node, visit) {
+    visit(node);
+    // Visit all children
+    for (var _i = 0, _a = Object.values(node); _i < _a.length; _i++) {
+        var child = _a[_i];
+        if ((0, utils_1.isNode)(child)) {
+            (0, exports.visitAllNodes)(child, visit);
+        }
+        else if ((0, utils_1.isArray)(child)) {
+            child
+                .filter(utils_1.isNode)
+                .forEach(function (childNode) { return (0, exports.visitAllNodes)(childNode, visit); });
+        }
+    }
+};
+exports.visitAllNodes = visitAllNodes;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "prettier-plugin-sql-cst",
+  "version": "0.1.0",
+  "description": "Prettier plugin for SQL",
+  "author": "Rene Saarsoo <nene@triin.net>",
+  "license": "GPL-3.0-or-later",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nene/prettier-plugin-sql-cst"
+  },
+  "homepage": "https://github.com/nene/prettier-plugin-sql-cst",
+  "bugs": {
+    "url": "https://github.com/nene/prettier-plugin-sql-cst/issues"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "prepublishOnly": "yarn test && yarn build",
+    "clean": "rm -rf dist",
+    "build": "yarn clean && tsc",
+    "test": "jest"
+  },
+  "keywords": [
+    "prettier",
+    "sql",
+    "plugin"
+  ],
+  "dependencies": {
+    "prettier": "^2.8.2",
+    "sql-parser-cst": "^0.11.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.2.5",
+    "dedent-js": "^1.0.1",
+    "jest": "^29.3.1",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.9.4"
+  }
+}