prettier-plugin-sql-cst 0.18.0 → 0.19.0

package/dist/src/syntax/select.js

@@ -0,0 +1,226 @@
+import { isDefined } from "../utils";
+import { join, line, hardline, indent, group, containsNewline, breakParent, } from "../print_utils";
+export const selectMap = {
+    compound_select_stmt: (print) => group(join(hardline, [print("left"), print.spaced("operator"), print("right")])),
+    select_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
+    // WITH clause
+    with_clause: (print) => group([
+        print.spaced(["withKw", "recursiveKw"]),
+        indent([line, print("tables")]),
+    ]),
+    common_table_expr: (print, node) => [
+        print(["table", "columns"]),
+        " ",
+        print.spaced(["asKw", "materializedKw", "expr"]),
+        group([
+            node.search || node.cycle
+                ? indent([line, print.separated(line, ["search", "cycle"])])
+                : [],
+        ]),
+    ],
+    cte_search_clause: (print) => group(join(line, [
+        [print.spaced("searchKw"), group(indent([line, print("columns")]))],
+        print.spaced(["setKw", "resultColumn"]),
+    ])),
+    cte_cycle_clause: (print, node) => group(join(line, [
+        [print("cycleKw"), group(indent([line, print("columns")]))],
+        print.spaced(["setKw", "resultColumn"]),
+        node.values ? print("values") : undefined,
+        print.spaced(["usingKw", "pathColumn"]),
+    ].filter(isDefined))),
+    cte_cycle_clause_values: (print) => join(line, [
+        print.spaced(["toKw", "markValue"]),
+        print.spaced(["defaultKw", "defaultValue"]),
+    ]),
+    // SELECT clause
+    select_clause: (print, node, path, opts) => group([
+        print.spaced(["selectKw", "modifiers"]),
+        node.columns ? indent([line, print("columns")]) : [],
+        containsNewline(node, opts) ? breakParent : [],
+    ]),
+    select_all: (print) => print.spaced(["allKw"]),
+    select_distinct: (print) => print.spaced(["distinctKw"]),
+    select_distinct_on: (print) => group([print.spaced(["distinctOnKw", "columns"])]),
+    select_as_struct: (print) => print.spaced(["asStructKw"]),
+    select_as_value: (print) => print.spaced(["asValueKw"]),
+    except_columns: (print) => print.spaced(["expr", "exceptKw", "columns"]),
+    replace_columns: (print) => print.spaced(["expr", "replaceKw", "columns"]),
+    // FROM clause
+    from_clause: (print) => group([print("fromKw"), indent([line, print("expr")])]),
+    join_expr: (print, node) => {
+        if (node.operator === ",") {
+            return join([",", hardline], print(["left", "right"]));
+        }
+        else {
+            return [
+                print("left"),
+                hardline,
+                group(join(" ", [
+                    print.spaced("operator"),
+                    [
+                        print("right"),
+                        node.specification
+                            ? indent([line, print(["specification"])])
+                            : [],
+                    ],
+                ])),
+            ];
+        }
+    },
+    join_on_specification: (print) => group(print.spaced(["onKw", "expr"])),
+    join_using_specification: (print) => group(print.spaced(["usingKw", "expr"])),
+    table_with_inheritance: (print) => [print("table"), " ", "*"],
+    table_without_inheritance: (print) => print.spaced(["onlyKw", "table"]),
+    indexed_table: (print) => print.spaced(["table", "indexedByKw", "index"]),
+    not_indexed_table: (print) => print.spaced(["table", "notIndexedKw"]),
+    unnest_expr: (print) => print(["unnestKw", "expr"]),
+    unnest_with_offset_expr: (print) => print.spaced(["unnest", "withOffsetKw"]),
+    pivot_expr: (print) => [print("left"), hardline, print(["pivotKw", "args"])],
+    pivot_for_in: (print) => group(join(line, [
+        group(print("aggregations")),
+        print.spaced(["forKw", "inputColumn"]),
+        print.spaced(["inKw", "pivotColumns"]),
+    ])),
+    unpivot_expr: (print, node) => [
+        print("left"),
+        hardline,
+        (node.nullHandlingKw ? print.spaced : print)([
+            "unpivotKw",
+            "nullHandlingKw",
+            "args",
+        ]),
+    ],
+    unpivot_for_in: (print) => group(join(line, [
+        print("valuesColumn"),
+        print.spaced(["forKw", "nameColumn"]),
+        print.spaced(["inKw", "unpivotColumns"]),
+    ])),
+    tablesample_expr: (print) => group([
+        print("left"),
+        line,
+        print.spaced(["tablesampleKw", "method", "args", "repeatable"]),
+    ]),
+    tablesample_method: (print) => print.spaced(["methodKw"]),
+    tablesample_percent: (print) => print.spaced(["percent", "percentKw"]),
+    tablesample_repeatable: (print) => print.spaced(["repeatableKw", "seed"]),
+    for_system_time_as_of_expr: (print) => group([print("left"), line, print.spaced(["forSystemTimeAsOfKw", "expr"])]),
+    partitioned_table: (print) => print.spaced(["table", "partitionKw", "partitions"]),
+    dual_table: (print) => print("dualKw"),
+    lateral_derived_table: (print) => print.spaced(["lateralKw", "expr"]),
+    rows_from_expr: (print) => print.spaced(["rowsFromKw", "expr"]),
+    with_ordinality_expr: (print) => print.spaced(["expr", "withOrdinalityKw"]),
+    func_call_with_column_definitions: (print) => print.spaced(["funcCall", "asKw", "columns"]),
+    // WHERE clause
+    where_clause: (print) => group([print("whereKw"), indent([line, print("expr")])]),
+    // ORDER BY clause
+    order_by_clause: (print, node) => group([
+        print.spaced("orderByKw"),
+        indent([line, print.separated(line, ["specifications", "withRollupKw"])]),
+    ]),
+    sort_specification: (print) => print.spaced(["expr", "direction", "nullHandlingKw"]),
+    sort_direction_asc: (print) => print("ascKw"),
+    sort_direction_desc: (print) => print("descKw"),
+    sort_direction_using_operator: (print) => print.spaced(["usingKw", "operator"]),
+    // GROUP BY clause
+    group_by_clause: (print, node) => group([
+        print.spaced(["groupByKw", "distinctKw"]),
+        indent([line, print.separated(line, ["columns", "withRollupKw"])]),
+    ]),
+    group_by_rollup: (print) => print(["rollupKw", "columns"]),
+    group_by_cube: (print) => print(["cubeKw", "columns"]),
+    group_by_grouping_sets: (print) => print.spaced(["groupingSetsKw", "columns"]),
+    group_by_all: (print) => print(["allKw"]),
+    // PARTITION BY clause
+    partition_by_clause: (print) => group([
+        print.spaced("partitionByKw"),
+        indent([line, print("specifications")]),
+    ]),
+    // HAVING clause
+    having_clause: (print) => group([print("havingKw"), indent([line, print("expr")])]),
+    // QUALIFY clause
+    qualify_clause: (print) => group([print("qualifyKw"), indent([line, print("expr")])]),
+    // LIMIT clause
+    /** cst-ignore: count, offsetKw, offset */
+    limit_clause: (print, node) => group([
+        print("limitKw"),
+        indent([
+            line,
+            printLimitValues(print, node),
+            node.rowsExamined ? [line, print("rowsExamined")] : [],
+        ]),
+    ]),
+    limit_all: (print) => print("allKw"),
+    limit_rows_examined: (print) => print.spaced(["rowsExaminedKw", "count"]),
+    // OFFSET clause
+    offset_clause: (print) => group([
+        print("offsetKw"),
+        indent([line, print.spaced(["offset", "rowsKw"])]),
+    ]),
+    // FETCH clause
+    fetch_clause: (print) => print.spaced(["fetchKw", "count", "rowsKw", "withTiesKw"]),
+    // WINDOW clause
+    window_clause: (print, node) => {
+        const lineType = node.namedWindows.items.length > 1 ? hardline : line;
+        return group([
+            print("windowKw"),
+            indent([lineType, print("namedWindows")]),
+        ]);
+    },
+    named_window: (print) => print.spaced(["name", "asKw", "window"]),
+    window_definition: (print, node) => {
+        const itemCount = [
+            node.baseWindowName,
+            node.partitionBy,
+            node.orderBy,
+            node.frame,
+        ].filter(isDefined).length;
+        const lineType = itemCount > 1 ? hardline : line;
+        return group(join(lineType, print(["baseWindowName", "partitionBy", "orderBy", "frame"])));
+    },
+    // INTO clause
+    into_table_clause: (print) => print.spaced(["intoKw", "kind", "tableKw", "name"]),
+    into_variables_clause: (print) => group([print("intoKw"), indent([line, print("variables")])]),
+    into_dumpfile_clause: (print) => print.spaced(["intoDumpfileKw", "filename"]),
+    into_outfile_clause: (print, node) => {
+        const hasOptions = node.charset || node.fields || node.lines;
+        return group([
+            print.spaced(["intoOutfileKw", "filename"]),
+            hasOptions
+                ? indent([
+                    hardline,
+                    join(hardline, print(["charset", "fields", "lines"])),
+                ])
+                : [],
+        ]);
+    },
+    outfile_fields: (print) => print.spaced(["fieldsKw", "options"]),
+    outfile_lines: (print) => print.spaced(["linesKw", "options"]),
+    outfile_option_character_set: (print) => print.spaced(["characterSetKw", "value"]),
+    outfile_option_starting_by: (print) => print.spaced(["startingByKw", "value"]),
+    outfile_option_terminated_by: (print) => print.spaced(["terminatedByKw", "value"]),
+    outfile_option_enclosed_by: (print) => print.spaced(["optionallyKw", "enclosedByKw", "value"]),
+    outfile_option_escaped_by: (print) => print.spaced(["escapedByKw", "value"]),
+    // FOR clause (locking)
+    for_clause: (print, node) => group([
+        print.spaced(["forKw", "lockStrengthKw", "tables"]),
+        node.waitingKw ? indent([line, print.spaced("waitingKw")]) : [],
+    ]),
+    for_clause_tables: (print) => [
+        print("ofKw"),
+        indent([line, print("tables")]),
+    ],
+    lock_in_share_mode_clause: (print) => print.spaced("lockInShareModeKw"),
+    // TABLE clause
+    table_clause: (print) => print.spaced(["tableKw", "table"]),
+};
+const printLimitValues = (print, node) => {
+    if (node.offsetKw) {
+        return print.spaced(["count", "offsetKw", "offset"]);
+    }
+    else if (node.offset) {
+        return join([",", " "], print(["offset", "count"]));
+    }
+    else {
+        return print("count");
+    }
+};

package/dist/src/syntax/sequence.js

@@ -0,0 +1,36 @@
+import { group, indent, join, line } from "../print_utils";
+export const sequenceMap = {
+    create_sequence_stmt: (print, node) => group([
+        print.spaced(["createKw", "kind", "sequenceKw", "ifNotExistsKw", "name"]),
+        node.options.length > 0
+            ? indent([print.dynamicLine(), join(line, print("options"))])
+            : [],
+    ]),
+    alter_sequence_stmt: (print) => group([
+        print.spaced(["alterKw", "sequenceKw", "ifExistsKw", "sequence"]),
+        indent([print.dynamicLine(), join(line, print("actions"))]),
+    ]),
+    drop_sequence_stmt: (print) => group(print.spaced([
+        "dropKw",
+        "sequenceKw",
+        "ifExistsKw",
+        "sequences",
+        "behaviorKw",
+    ])),
+    sequence_option_sequence_name: (print) => print.spaced(["sequenceNameKw", "name"]),
+    sequence_option_logged: (print) => print.spaced("loggedKw"),
+    sequence_option_unlogged: (print) => print.spaced("unloggedKw"),
+    sequence_option_as_type: (print) => print.spaced(["asKw", "dataType"]),
+    sequence_option_increment: (print) => print.spaced(["incrementKw", "byKw", "value"]),
+    sequence_option_minvalue: (print) => print.spaced(["minvalueKw", "value"]),
+    sequence_option_maxvalue: (print) => print.spaced(["maxvalueKw", "value"]),
+    sequence_option_no_minvalue: (print) => print.spaced("noMinvalueKw"),
+    sequence_option_no_maxvalue: (print) => print.spaced("noMaxvalueKw"),
+    sequence_option_start: (print) => print.spaced(["startKw", "withKw", "value"]),
+    sequence_option_restart: (print) => print.spaced(["restartKw", "withKw", "value"]),
+    sequence_option_cache: (print) => print.spaced(["cacheKw", "value"]),
+    sequence_option_cycle: (print) => print.spaced("cycleKw"),
+    sequence_option_no_cycle: (print) => print.spaced("noCycleKw"),
+    sequence_option_owned_by: (print) => print.spaced(["ownedByKw", "owner"]),
+    sequence_option_list: (print) => join(line, print("options")),
+};

package/dist/src/syntax/subscription.js

@@ -0,0 +1,10 @@
+import { group, line, join } from "../print_utils";
+export const subscriptionMap = {
+    create_subscription_stmt: (print, node) => group(join(line, [
+        print.spaced(["createSubscriptionKw", "name"]),
+        print.spaced(["connectionKw", "connectionInfo"]),
+        print.spaced(["publicationKw", "publications"]),
+        ...(node.with ? [print.spaced(["with"])] : []),
+    ])),
+    drop_subscription_stmt: (print) => group(print.spaced(["dropSubscriptionKw", "ifExistsKw", "name", "behaviorKw"])),
+};

package/dist/src/syntax/transaction.js

@@ -0,0 +1,19 @@
+import { group, indent, line } from "../print_utils";
+export const transactionMap = {
+    start_transaction_stmt: (print, node) => group([
+        print.spaced(["startKw", "behaviorKw", "transactionKw"]),
+        node.modes ? indent([line, print("modes")]) : [],
+    ]),
+    commit_transaction_stmt: (print) => group(print.spaced(["commitKw", "transactionKw", "chain"])),
+    rollback_transaction_stmt: (print) => group(print.spaced(["rollbackKw", "transactionKw", "savepoint", "chain"])),
+    rollback_to_savepoint: (print) => print.spaced(["toKw", "savepointKw", "savepoint"]),
+    savepoint_stmt: (print) => group(print.spaced(["savepointKw", "savepoint"])),
+    release_savepoint_stmt: (print) => group(print.spaced(["releaseKw", "savepointKw", "savepoint"])),
+    transaction_chain_clause: (print) => print.spaced("andChainKw"),
+    transaction_no_chain_clause: (print) => print.spaced("andNoChainKw"),
+    transaction_mode_isolation_level: (print) => print.spaced(["isolationLevelKw", "levelKw"]),
+    transaction_mode_deferrable: (print) => print.spaced("deferrableKw"),
+    transaction_mode_not_deferrable: (print) => print.spaced("notDeferrableKw"),
+    transaction_mode_read_only: (print) => print.spaced("readOnlyKw"),
+    transaction_mode_read_write: (print) => print.spaced("readWriteKw"),
+};

package/dist/src/syntax/transformMap.js

@@ -0,0 +1,100 @@
+import { aliasMap } from "./alias";
+import { alterActionMap } from "./alter_action";
+import { alterTableMap } from "./alter_table";
+import { analyzeMap } from "./analyze";
+import { baseMap } from "./base";
+import { castMap } from "./cast";
+import { commentMap } from "./comment";
+import { constraintMap } from "./constraint";
+import { createTableMap } from "./create_table";
+import { dataTypeMap } from "./data_type";
+import { dclMap } from "./dcl";
+import { deleteMap } from "./delete";
+import { doMap } from "./do";
+import { domainMap } from "./domain";
+import { dropTableMap } from "./drop_table";
+import { explainMap } from "./explain";
+import { exprMap } from "./expr";
+import { extensionMap } from "./extension";
+import { frameMap } from "./frame";
+import { functionMap } from "./function";
+import { indexMap } from "./index";
+import { insertMap } from "./insert";
+import { mergeMap } from "./merge";
+import { otherClausesMap } from "./other_clauses";
+import { renameTableMap } from "./rename_table";
+import { roleMap } from "./role";
+import { parameterMap } from "./parameter";
+import { policyMap } from "./policy";
+import { preparedStatementsMap } from "./prepared_statements";
+import { proceduralLanguageMap } from "./procedural_language";
+import { procedureMap } from "./procedure";
+import { procClauseMap } from "./proc_clause";
+import { programMap } from "./program";
+import { publicationMap } from "./publication";
+import { schemaMap } from "./schema";
+import { selectMap } from "./select";
+import { sequenceMap } from "./sequence";
+import { subscriptionMap } from "./subscription";
+import { transactionMap } from "./transaction";
+import { triggerMap } from "./trigger";
+import { truncateMap } from "./truncate";
+import { typeMap } from "./type";
+import { unsupportedGrammarMap } from "./unsupported_grammar";
+import { updateMap } from "./update";
+import { viewMap } from "./view";
+import { bigqueryMap } from "./dialects/bigquery";
+import { mysqlMap } from "./dialects/mysql";
+import { sqliteMap } from "./dialects/sqlite";
+import { postgresqlMap } from "./dialects/postgresql";
+export const transformMap = {
+    ...aliasMap,
+    ...alterActionMap,
+    ...alterTableMap,
+    ...analyzeMap,
+    ...baseMap,
+    ...castMap,
+    ...commentMap,
+    ...constraintMap,
+    ...createTableMap,
+    ...dataTypeMap,
+    ...dclMap,
+    ...deleteMap,
+    ...doMap,
+    ...domainMap,
+    ...dropTableMap,
+    ...explainMap,
+    ...exprMap,
+    ...extensionMap,
+    ...frameMap,
+    ...functionMap,
+    ...indexMap,
+    ...insertMap,
+    ...mergeMap,
+    ...otherClausesMap,
+    ...parameterMap,
+    ...policyMap,
+    ...preparedStatementsMap,
+    ...procClauseMap,
+    ...proceduralLanguageMap,
+    ...procedureMap,
+    ...programMap,
+    ...publicationMap,
+    ...renameTableMap,
+    ...roleMap,
+    ...schemaMap,
+    ...selectMap,
+    ...sequenceMap,
+    ...subscriptionMap,
+    ...transactionMap,
+    ...triggerMap,
+    ...truncateMap,
+    ...typeMap,
+    ...unsupportedGrammarMap,
+    ...updateMap,
+    ...viewMap,
+    ...bigqueryMap,
+    ...mysqlMap,
+    ...postgresqlMap,
+    ...sqliteMap,
+};

package/dist/src/syntax/trigger.js

@@ -0,0 +1,52 @@
+import { group, hardline, indent, join, line } from "../print_utils";
+export const triggerMap = {
+    create_trigger_stmt: (print, node) => group(join(hardline, [
+        print.spaced([
+            "createKw",
+            "orReplaceKw",
+            "kind",
+            "triggerKw",
+            "ifNotExistsKw",
+            "name",
+        ]),
+        group([
+            node.timeKw ? [print.spaced("timeKw"), " "] : [],
+            print("event"),
+            line,
+            print("target"),
+        ]),
+        ...print("clauses"),
+        print("body"),
+    ])),
+    trigger_event: (print, node) => group([
+        print.spaced(["eventKw", "ofKw"]),
+        node.columns ? indent([line, print("columns")]) : [],
+    ]),
+    trigger_target: (print) => print.spaced(["onKw", "table"]),
+    when_clause: (print) => group([print("whenKw"), indent([line, print("expr")])]),
+    for_each_clause: (print) => print.spaced(["forEachKw", "itemKw"]),
+    execute_clause: (print) => [
+        print.spaced(["executeKw", "functionKw", "name"]),
+        print("args"),
+    ],
+    from_referenced_table_clause: (print) => print.spaced(["fromKw", "table"]),
+    trigger_timing_clause: (print) => print.spaced(["timingKw"]),
+    trigger_referencing_clause: (print) => group([
+        print.spaced(["referencingKw"]),
+        indent([line, print("transitions")]),
+    ]),
+    trigger_transition: (print) => [
+        print.spaced(["oldOrNewKw", "rowOrTableKw", "asKw", "name"]),
+    ],
+    alter_trigger_stmt: (print) => group(join(print.dynamicLine(), [
+        print.spaced(["alterTriggerKw", "trigger", "target"]),
+        print("action"),
+    ])),
+    drop_trigger_stmt: (print) => group(print.spaced([
+        "dropTriggerKw",
+        "ifExistsKw",
+        "trigger",
+        "target",
+        "behaviorKw",
+    ])),
+};

package/dist/src/syntax/truncate.js

@@ -0,0 +1,10 @@
+import { group, indent, line } from "../print_utils";
+export const truncateMap = {
+    truncate_stmt: (print) => group([
+        print.spaced(["truncateKw", "tableKw"]),
+        indent([
+            line,
+            print.separated(line, ["tables", "restartOrContinueKw", "behaviorKw"]),
+        ]),
+    ]),
+};

package/dist/src/syntax/type.js

@@ -0,0 +1,12 @@
+import { group } from "../print_utils";
+export const typeMap = {
+    create_type_stmt: (print) => group([print.spaced(["createTypeKw", "name", "definition"])]),
+    composite_type_definition: (print) => group(print.spaced(["asKw", "columns"])),
+    enum_type_definition: (print) => group(print.spaced(["asEnumKw", "values"])),
+    alter_type_stmt: (print, node) => group([
+        print.spaced(["alterTypeKw", "name"]),
+        print.dynamicLine(),
+        print("actions"),
+    ]),
+    drop_type_stmt: (print) => group(print.spaced(["dropTypeKw", "ifExistsKw", "types", "behaviorKw"])),
+};

package/dist/src/syntax/unsupported_grammar.js

@@ -0,0 +1,4 @@
+import { group } from "../print_utils";
+export const unsupportedGrammarMap = {
+    unsupported_grammar_stmt: (print) => group(print("text")),
+};

package/dist/src/syntax/update.js

@@ -0,0 +1,14 @@
+import { join, hardline, indent, group } from "../print_utils";
+export const updateMap = {
+    update_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
+    update_clause: (print) => print.spaced(["updateKw", "modifiers", "orAction", "tables"]),
+    set_clause: (print, node) => {
+        if (node.assignments.items.length > 1) {
+            return [print("setKw"), indent([hardline, print("assignments")])];
+        }
+        else {
+            return print.spaced(["setKw", "assignments"]);
+        }
+    },
+    column_assignment: (print) => join([" ", "=", " "], print(["column", "expr"])),
+};

package/dist/src/syntax/view.js

@@ -0,0 +1,48 @@
+import { group, hardline, join, line } from "../print_utils";
+export const viewMap = {
+    create_view_stmt: (print, node) => {
+        const hasOnlyAsClause = node.clauses.length === 1;
+        const hasManyClauses = node.clauses.length > 1;
+        return group([
+            print.spaced([
+                "createKw",
+                "orReplaceKw",
+                "kinds",
+                "viewKw",
+                "ifNotExistsKw",
+                "name",
+                "columns",
+            ]),
+            hasOnlyAsClause ? [" ", print("clauses")] : [],
+            hasManyClauses ? [hardline, join(hardline, print("clauses"))] : [],
+        ]);
+    },
+    with_check_option_clause: (print) => print.spaced(["withKw", "levelKw", "checkOptionKw"]),
+    as_replica_of_clause: (print) => print.spaced(["asReplicaOfKw", "view"]),
+    drop_view_stmt: (print) => group(print.spaced([
+        "dropKw",
+        "kind",
+        "viewKw",
+        "ifExistsKw",
+        "views",
+        "behaviorKw",
+    ])),
+    alter_view_stmt: (print) => group([
+        print.spaced([
+            "alterKw",
+            "kind",
+            "viewKw",
+            "ifExistsKw",
+            "name",
+            "columns",
+        ]),
+        hardline,
+        print("actions"),
+    ]),
+    refresh_materialized_view_stmt: (print, node) => group([
+        print.spaced(["refreshMaterializedViewKw", "concurrentlyKw", "name"]),
+        node.clauses.length > 0
+            ? [print.dynamicLine(), join(line, print("clauses"))]
+            : [],
+    ]),
+};

package/dist/src/transform/addFinalSemicolon.js

@@ -0,0 +1,9 @@
+import { isEmpty } from "../node_utils";
+import { last } from "../utils";
+export const addFinalSemicolon = (program, originalText) => {
+    if (!isEmpty(last(program.statements))) {
+        const end = originalText.length;
+        program.statements.push({ type: "empty", range: [end, end] });
+    }
+    return program;
+};

package/dist/src/transform/aliasAs.js

@@ -0,0 +1,10 @@
+import { cstVisitor } from "sql-parser-cst";
+// Adds AS keyword to aliases if none exists
+export const processAliasAs = (cst) => {
+    cstVisitor({
+        alias: (node) => {
+            node.asKw = node.asKw || { type: "keyword", name: "AS", text: "AS" };
+        },
+    })(cst);
+    return cst;
+};

package/dist/{transform → src/transform}/canonicKeywords.js

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