prettier-plugin-sql-cst 0.19.1 → 0.19.3

package/dist/syntax/merge.js

@@ -1,30 +0,0 @@
-import { group, hardline, indent, join, line } from "../print_utils";
-export const mergeMap = {
-    merge_stmt: (print) => group(join(hardline, print("clauses"))),
-    merge_clause: (print) => join(line, [
-        print.spaced(["mergeKw", "intoKw", "target"]),
-        print.spaced(["usingKw", "source"]),
-        group([print("onKw"), indent([line, print("condition")])]),
-    ]),
-    merge_when_clause: (print, node) => [
-        group([
-            print.spaced(["whenKw", "matchedKw", "byKw"]),
-            node.condition ? indent([line, print("condition")]) : [],
-            [line, print("thenKw")],
-        ]),
-        indent([hardline, group(print("action"))]),
-    ],
-    merge_when_condition: (print) => print.spaced(["andKw", "expr"]),
-    merge_action_delete: (print) => print("deleteKw"),
-    merge_action_insert: (print, node) => [
-        group([
-            print("insertKw"),
-            node.columns ? indent([hardline, print("columns")]) : [],
-        ]),
-        line,
-        join(hardline, print("clauses")),
-    ],
-    merge_action_insert_row_clause: (print) => print("rowKw"),
-    merge_action_update: (print) => print.spaced(["updateKw", "set"]),
-    merge_action_do_nothing: (print) => print.spaced(["doNothingKw"]),
-};

package/dist/syntax/other_clauses.d.ts

@@ -1,3 +0,0 @@
-import { AllOtherClauses } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const otherClausesMap: CstToDocMap<AllOtherClauses>;

package/dist/syntax/other_clauses.js

@@ -1,9 +0,0 @@
-import { line, indent, group } from "../print_utils";
-export const otherClausesMap = {
-    // CLUSTER BY clause
-    cluster_by_clause: (print) => group([print.spaced("clusterByKw"), indent([line, print("columns")])]),
-    // RETURNING clause
-    returning_clause: (print) => group([print("returningKw"), indent([line, print("columns")])]),
-    // WHERE CURRENT OF clause
-    where_current_of_clause: (print) => print.spaced(["whereCurrentOfKw", "cursor"]),
-};

package/dist/syntax/parameter.d.ts

@@ -1,3 +0,0 @@
-import { AllParameterNodes } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const parameterMap: CstToDocMap<AllParameterNodes>;

package/dist/syntax/parameter.js

@@ -1,18 +0,0 @@
-import { printLiteral } from "./expr";
-import { group } from "../print_utils";
-export const parameterMap = {
-    // SET
-    set_parameter_stmt: (print) => group(print.spaced(["setKw", "modifierKw", "name", "operator", "value"])),
-    set_time_zone_parameter_stmt: (print) => group(print.spaced(["setKw", "modifierKw", "timeZoneKw", "value"])),
-    set_parameter_clause: (print) => print.spaced(["setKw", "name", "operator", "value"]),
-    local_parameter_value: (print) => print("localKw"),
-    set_parameter_from_current_clause: (print) => print.spaced(["setKw", "name", "fromCurrentKw"]),
-    // RESET
-    reset_parameter_stmt: (print) => group(print.spaced(["resetKw", "name"])),
-    reset_parameter_clause: (print) => print.spaced(["resetKw", "name"]),
-    all_parameters: (print) => print("allKw"),
-    // SHOW
-    show_parameter_stmt: (print) => group(print.spaced(["showKw", "name"])),
-    /** cst-ignore: value */
-    boolean_on_off_literal: (print, node, path, options) => printLiteral(node.valueKw, options),
-};

package/dist/syntax/policy.d.ts

@@ -1,3 +0,0 @@
-import { AllPolicyNodes } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const policyMap: CstToDocMap<AllPolicyNodes>;

package/dist/syntax/policy.js

@@ -1,27 +0,0 @@
-import { group, join } from "../print_utils";
-export const policyMap = {
-    create_policy_stmt: (print, node) => group([
-        print.spaced(["createPolicyKw", "name", "onKw", "table"]),
-        node.clauses.length > 0 ? print.dynamicLine() : [],
-        join(print.dynamicLine(), print("clauses")),
-    ]),
-    policy_permissive_clause: (print) => group(print.spaced(["asKw", "permissiveKw"])),
-    policy_restrictive_clause: (print) => group(print.spaced(["asKw", "restrictiveKw"])),
-    policy_command_clause: (print) => group(print.spaced(["forKw", "commandKw"])),
-    policy_roles_clause: (print) => group(print.spaced(["toKw", "roles"])),
-    policy_using_clause: (print) => group(print.spaced(["usingKw", "expr"])),
-    policy_check_clause: (print) => group(print.spaced(["withKw", "checkKw", "expr"])),
-    alter_policy_stmt: (print) => group([
-        print.spaced(["alterPolicyKw", "name", "onKw", "table"]),
-        print.dynamicLine(),
-        join(print.dynamicLine(), print("actions")),
-    ]),
-    drop_policy_stmt: (print) => group(print.spaced([
-        "dropPolicyKw",
-        "ifExistsKw",
-        "name",
-        "onKw",
-        "table",
-        "behaviorKw",
-    ])),
-};

package/dist/syntax/prepared_statements.d.ts

@@ -1,3 +0,0 @@
-import { AllPreparedStatementNodes } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const preparedStatementsMap: CstToDocMap<AllPreparedStatementNodes>;

package/dist/syntax/prepared_statements.js

@@ -1,31 +0,0 @@
-import { group, hardline, indent, join, line } from "../print_utils";
-export const preparedStatementsMap = {
-    // EXECUTE
-    execute_stmt: (print, node) => {
-        if (node.args?.type === "execute_using_clause") {
-            return group(print.spaced(["executeKw", "name", "args"]));
-        }
-        else {
-            return group([print.spaced(["executeKw", "name"]), print("args")]);
-        }
-    },
-    execute_immediate_stmt: (print) => group(join(hardline, [
-        group([
-            print.spaced(["executeKw", "immediateKw"]),
-            indent([line, print("expr")]),
-        ]),
-        ...print(["into", "using"]).map((clause) => group(clause)),
-    ])),
-    execute_into_clause: (print) => print.spaced(["intoKw", "variables"]),
-    execute_using_clause: (print) => group([print("usingKw"), indent([line, print("values")])]),
-    // PREPARE
-    prepare_stmt: (print) => group(join(" ", [
-        print("prepareKw"),
-        print(["name", "params"]),
-        print("source"),
-    ])),
-    prepare_from_clause: (print) => group([print("fromKw"), indent([line, print("expr")])]),
-    // DEALLOCATE
-    deallocate_stmt: (print) => group(print.spaced(["deallocateKw", "name"])),
-    deallocate_all: (print) => print("allKw"),
-};

package/dist/syntax/proc_clause.d.ts

@@ -1,3 +0,0 @@
-import { AllProcClauseNodes } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const procClauseMap: CstToDocMap<AllProcClauseNodes>;

package/dist/syntax/proc_clause.js

@@ -1,14 +0,0 @@
-import { isDynamicallyLoadedFunction, isStringLiteral } from "../node_utils";
-import { hardline, indent } from "../print_utils";
-export const procClauseMap = {
-    returns_clause: (print) => print.spaced(["returnsKw", "dataType"]),
-    determinism_clause: (print) => print.spaced("deterministicKw"),
-    language_clause: (print) => print.spaced(["languageKw", "name"]),
-    as_clause: (print, node) => {
-        if (isStringLiteral(node.expr) || isDynamicallyLoadedFunction(node.expr)) {
-            return print.spaced(["asKw", "expr"]);
-        }
-        return [print("asKw"), indent([hardline, print("expr")])];
-    },
-    with_connection_clause: (print) => print.spaced(["withConnectionKw", "connection"]),
-};

package/dist/syntax/procedural_language.d.ts

@@ -1,3 +0,0 @@
-import { AllProceduralNodes } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const proceduralLanguageMap: CstToDocMap<AllProceduralNodes>;

package/dist/syntax/procedural_language.js

@@ -1,104 +0,0 @@
-import { group, hardline, indent, join, line, stripTrailingHardline, } from "../print_utils";
-export const proceduralLanguageMap = {
-    // BEGIN .. END
-    block_stmt: (print, node) => group([
-        print.spaced(["beginKw", "atomicKw"]),
-        indent([hardline, stripTrailingHardline(print("program"))]),
-        node.exception ? [hardline, print("exception")] : [],
-        hardline,
-        print("endKw"),
-    ]),
-    exception_clause: (print) => group([
-        print.spaced(["exceptionKw", "whenKw", "condition", "thenKw"]),
-        indent([hardline, stripTrailingHardline(print("program"))]),
-    ]),
-    error_category: (print) => print("errorKw"),
-    // DECLARE
-    declare_stmt: (print) => group(join(" ", [
-        print("declareKw"),
-        group(print("names")),
-        ...print.spaced(["dataType", "default"]),
-    ])),
-    declare_default: (print) => print.spaced(["defaultKw", "expr"]),
-    // SET
-    set_stmt: (print) => group(print.spaced(["setKw", "assignments"])),
-    // IF
-    if_stmt: (print) => group(join(hardline, [...print("clauses"), print.spaced("endIfKw")])),
-    if_clause: (print) => [
-        group([
-            print("ifKw"),
-            indent([line, print("condition")]),
-            line,
-            print("thenKw"),
-        ]),
-        indent([hardline, stripTrailingHardline(print("consequent"))]),
-    ],
-    elseif_clause: (print) => [
-        group([
-            print("elseifKw"),
-            indent([line, print("condition")]),
-            line,
-            print("thenKw"),
-        ]),
-        indent([hardline, stripTrailingHardline(print("consequent"))]),
-    ],
-    else_clause: (print) => [
-        print("elseKw"),
-        indent([hardline, stripTrailingHardline(print("consequent"))]),
-    ],
-    // CASE
-    case_stmt: (print) => group([
-        print.spaced(["caseKw", "expr"]),
-        indent([hardline, join(hardline, print("clauses"))]),
-        hardline,
-        print.spaced("endCaseKw"),
-    ]),
-    // LOOP
-    loop_stmt: (print) => group([
-        print("loopKw"),
-        indent([hardline, stripTrailingHardline(print("body"))]),
-        hardline,
-        print.spaced("endLoopKw"),
-    ]),
-    // REPEAT
-    repeat_stmt: (print) => group([
-        print("repeatKw"),
-        indent([hardline, stripTrailingHardline(print("body"))]),
-        hardline,
-        print.spaced(["untilKw", "condition", "endRepeatKw"]),
-    ]),
-    // WHILE
-    while_stmt: (print) => group([
-        print.spaced(["whileKw", "condition", "doKw"]),
-        indent([hardline, stripTrailingHardline(print("body"))]),
-        hardline,
-        print.spaced("endWhileKw"),
-    ]),
-    // FOR .. IN
-    for_stmt: (print) => group([
-        print.spaced(["forKw", "left", "inKw", "right", "doKw"]),
-        indent([hardline, stripTrailingHardline(print("body"))]),
-        hardline,
-        print.spaced("endForKw"),
-    ]),
-    // BREAK/CONTINUE
-    break_stmt: (print) => group(print.spaced(["breakKw", "label"])),
-    continue_stmt: (print) => group(print.spaced(["continueKw", "label"])),
-    labeled_stmt: (print, node) => group([
-        print("beginLabel"),
-        ": ",
-        print("statement"),
-        node.endLabel ? [" ", print(["endLabel"])] : [],
-    ]),
-    // CALL
-    call_stmt: (print) => group(print.spaced(["callKw", "func"])),
-    // RETURN
-    return_stmt: (print) => group(print.spaced(["returnKw", "expr"])),
-    // RAISE
-    raise_stmt: (print) => group(print.spaced(["raiseKw", "message"])),
-    raise_message: (print) => [
-        print.spaced("usingMessageKw"),
-        " = ",
-        print("string"),
-    ],
-};

package/dist/syntax/procedure.d.ts

@@ -1,3 +0,0 @@
-import { AllProcedureNodes } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const procedureMap: CstToDocMap<AllProcedureNodes>;

package/dist/syntax/procedure.js

@@ -1,38 +0,0 @@
-import { group, hardline, join } from "../print_utils";
-import { hasOnlyAsClause } from "./function";
-export const procedureMap = {
-    create_procedure_stmt: (print, node) => group([
-        print.spaced([
-            "createKw",
-            "orReplaceKw",
-            "procedureKw",
-            "ifNotExistsKw",
-            "name",
-        ]),
-        print("params"),
-        hasOnlyAsClause(node)
-            ? [" ", group(print("clauses"))]
-            : [
-                hardline,
-                join(hardline, print("clauses").map((clause) => group(clause))),
-            ],
-    ]),
-    drop_procedure_stmt: (print) => group([
-        print.spaced([
-            "dropKw",
-            "procedureKw",
-            "ifExistsKw",
-            "signatures",
-            "behaviorKw",
-        ]),
-    ]),
-    // almost exact copy of alter_function_stmt
-    alter_procedure_stmt: (print, node) => group([
-        print.spaced(["alterKw", "procedureKw"]),
-        " ",
-        print(["signature"]),
-        print.dynamicLine(),
-        join(print.dynamicLine(), print("actions")),
-        node.behaviorKw ? [print.dynamicLine(), print("behaviorKw")] : [],
-    ]),
-};

package/dist/syntax/program.d.ts

@@ -1,3 +0,0 @@
-import { Program } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const programMap: CstToDocMap<Program>;

package/dist/syntax/program.js

@@ -1,39 +0,0 @@
-import { hardline, hasEmptyLineBetweenNodes } from "../print_utils";
-export const programMap = {
-    program: (print, node, path, options) => print("statements").map((doc, i) => i === node.statements.length - 1
-        ? printFinalStatement(doc, i, node.statements, options)
-        : printStatement(doc, i, node.statements, options)),
-};
-const printStatement = (doc, i, statements, options) => {
-    const prevNode = statements[i - 1];
-    const node = statements[i];
-    if (i === 0) {
-        return doc;
-    }
-    else if (node.type !== "empty") {
-        if (hasEmptyLineBetweenNodes(prevNode, node, options)) {
-            return [";", hardline, hardline, doc];
-        }
-        else {
-            return [";", hardline, doc];
-        }
-    }
-    else {
-        return [";", hardline, doc];
-    }
-};
-const printFinalStatement = (doc, i, statements, options) => {
-    const stmtDoc = printStatement(doc, i, statements, options);
-    if (statements[i].type === "empty") {
-        // When the final statement is an empty statement,
-        // this means we have inserted a semicolon and newline before it.
-        // So nothing else is needed.
-        return stmtDoc;
-    }
-    else {
-        // If the last statement is not empty,
-        // this means sqlFinalSemicolon option is false,
-        // so we need to add an empty line after it.
-        return [stmtDoc, hardline];
-    }
-};

package/dist/syntax/publication.d.ts

@@ -1,3 +0,0 @@
-import { AllPublicationNodes } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const publicationMap: CstToDocMap<AllPublicationNodes>;

package/dist/syntax/publication.js

@@ -1,27 +0,0 @@
-import { group, indent, line } from "../print_utils";
-export const publicationMap = {
-    create_publication_stmt: (print, node) => group([
-        print.spaced(["createPublicationKw", "name"]),
-        print("clauses").map((printedClause, i) => {
-            if (node.clauses[i].type === "for_publication_objects_clause") {
-                return [" ", printedClause];
-            }
-            else {
-                return [line, printedClause];
-            }
-        }),
-    ]),
-    for_publication_objects_clause: (print) => group([print("forKw"), indent([line, print("publicationObjects")])]),
-    all_publication_object: (print) => group(print.spaced(["allKw", "typesKw"])),
-    publication_object_table: (print) => group(print.spaced(["tableKw", "table", "columns", "where"])),
-    publication_object_tables_in_schema: (print) => group(print.spaced(["tablesInSchemaKw", "schema"])),
-    alter_publication_stmt: (print) => group([
-        print.spaced(["alterPublicationKw", "name"]),
-        print.dynamicLine(),
-        print("action"),
-    ]),
-    alter_action_add_publication_objects: (print) => group([print("addKw"), indent([line, print("publicationObjects")])]),
-    alter_action_set_publication_objects: (print) => group([print("setKw"), indent([line, print("publicationObjects")])]),
-    alter_action_drop_publication_objects: (print) => group([print("dropKw"), indent([line, print("publicationObjects")])]),
-    drop_publication_stmt: (print) => group(print.spaced(["dropPublicationKw", "ifExistsKw", "names", "behaviorKw"])),
-};

package/dist/syntax/rename_table.d.ts

@@ -1,3 +0,0 @@
-import { AllRenameTableNodes } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const renameTableMap: CstToDocMap<AllRenameTableNodes>;

package/dist/syntax/rename_table.js

@@ -1,8 +0,0 @@
-import { group, indent, line } from "../print_utils";
-export const renameTableMap = {
-    rename_table_stmt: (print) => group([
-        print.spaced(["renameKw", "tableKw"]),
-        indent([line, print("actions")]),
-    ]),
-    rename_action: (print) => print.spaced(["from", "toKw", "to"]),
-};

package/dist/syntax/role.d.ts

@@ -1,3 +0,0 @@
-import { AllRoleNodes } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const roleMap: CstToDocMap<AllRoleNodes>;

package/dist/syntax/role.js

@@ -1,31 +0,0 @@
-import { group, indent, join, line } from "../print_utils";
-export const roleMap = {
-    create_role_stmt: (print, node) => group([
-        print.spaced(["createRoleKw", "name", "withKw"]),
-        ...(node.options?.length
-            ? [indent([line, join(print.dynamicLine(), print("options"))])]
-            : []),
-    ]),
-    alter_role_stmt: (print, node) => group([
-        join(print.dynamicLine(), [
-            group([print.spaced("alterRoleKw"), indent([line, print("name")])]),
-            ...(node.database ? print(["database"]) : []),
-        ]),
-        node.action.type === "alter_action_with_role_options" &&
-            !node.action.withKw
-            ? indent([print.dynamicLine(), print("action")])
-            : [print.dynamicLine(), print("action")],
-    ]),
-    drop_role_stmt: (print) => group(print.spaced(["dropRoleKw", "ifExistsKw", "names"])),
-    set_role_stmt: (print) => group(print.spaced(["setKw", "scopeKw", "roleKw", "name"])),
-    reset_role_stmt: (print) => group(print.spaced("resetRoleKw")),
-    role_option_keyword: (print) => print("kw"),
-    role_option_connection_limit: (print) => group(print.spaced(["connectionLimitKw", "limit"])),
-    role_option_password: (print) => group(print.spaced(["encryptedKw", "passwordKw", "password"])),
-    role_option_valid_until: (print) => group(print.spaced(["validUntilKw", "timestamp"])),
-    role_option_in_role: (print) => group(print.spaced(["inRoleKw", "names"])),
-    role_option_role: (print) => group(print.spaced(["roleKw", "names"])),
-    role_option_admin: (print) => group(print.spaced(["adminKw", "names"])),
-    role_option_sysid: (print) => group(print.spaced(["sysIdKw", "sysId"])),
-    in_database_clause: (print) => group(print.spaced(["inDatabaseKw", "name"])),
-};

package/dist/syntax/schema.d.ts

@@ -1,3 +0,0 @@
-import { AllSchemaStatements } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const schemaMap: CstToDocMap<AllSchemaStatements>;

package/dist/syntax/schema.js

@@ -1,18 +0,0 @@
-import { group, hardline, indent, join } from "../print_utils";
-export const schemaMap = {
-    create_schema_stmt: (print, node) => group([
-        group(join(print.dynamicLine(), [
-            print.spaced(["createSchemaKw", "ifNotExistsKw", "name"]),
-            ...print("clauses"),
-        ])),
-        node.statements.length > 0
-            ? indent([hardline, join(hardline, print("statements"))])
-            : [],
-    ]),
-    create_schema_authorization_clause: (print) => print.spaced(["authorizationKw", "role"]),
-    drop_schema_stmt: (print) => group(print.spaced(["dropSchemaKw", "ifExistsKw", "schemas", "behaviorKw"])),
-    alter_schema_stmt: (print) => group(join(print.dynamicLine(), [
-        print.spaced(["alterSchemaKw", "ifExistsKw", "name"]),
-        ...print("actions"),
-    ])),
-};

package/dist/syntax/select.d.ts

@@ -1,3 +0,0 @@
-import { AllSelectNodes } from "sql-parser-cst";
-import { CstToDocMap } from "../CstToDocMap";
-export declare const selectMap: CstToDocMap<AllSelectNodes>;