@guojc1/sql-formatter-compact 1.0.0

package/dist/esm/lexer/token.js

@@ -0,0 +1,94 @@
+/** Token type enum for all possible Token categories */
+export var TokenType;
+(function (TokenType) {
+    TokenType["QUOTED_IDENTIFIER"] = "QUOTED_IDENTIFIER";
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    TokenType["STRING"] = "STRING";
+    TokenType["VARIABLE"] = "VARIABLE";
+    TokenType["RESERVED_DATA_TYPE"] = "RESERVED_DATA_TYPE";
+    TokenType["RESERVED_PARAMETERIZED_DATA_TYPE"] = "RESERVED_PARAMETERIZED_DATA_TYPE";
+    TokenType["RESERVED_KEYWORD"] = "RESERVED_KEYWORD";
+    TokenType["RESERVED_FUNCTION_NAME"] = "RESERVED_FUNCTION_NAME";
+    TokenType["RESERVED_KEYWORD_PHRASE"] = "RESERVED_KEYWORD_PHRASE";
+    TokenType["RESERVED_DATA_TYPE_PHRASE"] = "RESERVED_DATA_TYPE_PHRASE";
+    TokenType["RESERVED_SET_OPERATION"] = "RESERVED_SET_OPERATION";
+    TokenType["RESERVED_CLAUSE"] = "RESERVED_CLAUSE";
+    TokenType["RESERVED_SELECT"] = "RESERVED_SELECT";
+    TokenType["RESERVED_JOIN"] = "RESERVED_JOIN";
+    TokenType["ARRAY_IDENTIFIER"] = "ARRAY_IDENTIFIER";
+    TokenType["ARRAY_KEYWORD"] = "ARRAY_KEYWORD";
+    TokenType["CASE"] = "CASE";
+    TokenType["END"] = "END";
+    TokenType["WHEN"] = "WHEN";
+    TokenType["ELSE"] = "ELSE";
+    TokenType["THEN"] = "THEN";
+    TokenType["LIMIT"] = "LIMIT";
+    TokenType["BETWEEN"] = "BETWEEN";
+    TokenType["AND"] = "AND";
+    TokenType["OR"] = "OR";
+    TokenType["XOR"] = "XOR";
+    TokenType["OPERATOR"] = "OPERATOR";
+    TokenType["COMMA"] = "COMMA";
+    TokenType["ASTERISK"] = "ASTERISK";
+    TokenType["PROPERTY_ACCESS_OPERATOR"] = "PROPERTY_ACCESS_OPERATOR";
+    TokenType["OPEN_PAREN"] = "OPEN_PAREN";
+    TokenType["CLOSE_PAREN"] = "CLOSE_PAREN";
+    TokenType["LINE_COMMENT"] = "LINE_COMMENT";
+    TokenType["BLOCK_COMMENT"] = "BLOCK_COMMENT";
+    // Text between /* sql-formatter-disable */ and /* sql-formatter-enable */
+    TokenType["DISABLE_COMMENT"] = "DISABLE_COMMENT";
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["NAMED_PARAMETER"] = "NAMED_PARAMETER";
+    TokenType["QUOTED_PARAMETER"] = "QUOTED_PARAMETER";
+    TokenType["NUMBERED_PARAMETER"] = "NUMBERED_PARAMETER";
+    TokenType["POSITIONAL_PARAMETER"] = "POSITIONAL_PARAMETER";
+    TokenType["CUSTOM_PARAMETER"] = "CUSTOM_PARAMETER";
+    TokenType["DELIMITER"] = "DELIMITER";
+    TokenType["EOF"] = "EOF";
+})(TokenType = TokenType || (TokenType = {}));
+/** Creates EOF token positioned at given location */
+export const createEofToken = (index) => ({
+    type: TokenType.EOF,
+    raw: '«EOF»',
+    text: '«EOF»',
+    start: index,
+});
+/**
+ * For use as a "missing token"
+ * e.g. in lookAhead and lookBehind to avoid dealing with null values
+ */
+export const EOF_TOKEN = createEofToken(Infinity);
+/** Checks if two tokens are equivalent */
+export const testToken = (compareToken) => (token) => token.type === compareToken.type && token.text === compareToken.text;
+/** Util object that allows for easy checking of Reserved Keywords */
+export const isToken = {
+    ARRAY: testToken({ text: 'ARRAY', type: TokenType.RESERVED_DATA_TYPE }),
+    BY: testToken({ text: 'BY', type: TokenType.RESERVED_KEYWORD }),
+    SET: testToken({ text: 'SET', type: TokenType.RESERVED_CLAUSE }),
+    STRUCT: testToken({ text: 'STRUCT', type: TokenType.RESERVED_DATA_TYPE }),
+    WINDOW: testToken({ text: 'WINDOW', type: TokenType.RESERVED_CLAUSE }),
+    VALUES: testToken({ text: 'VALUES', type: TokenType.RESERVED_CLAUSE }),
+};
+/** Checks if token is any Reserved Keyword or Clause */
+export const isReserved = (type) => type === TokenType.RESERVED_DATA_TYPE ||
+    type === TokenType.RESERVED_KEYWORD ||
+    type === TokenType.RESERVED_FUNCTION_NAME ||
+    type === TokenType.RESERVED_KEYWORD_PHRASE ||
+    type === TokenType.RESERVED_DATA_TYPE_PHRASE ||
+    type === TokenType.RESERVED_CLAUSE ||
+    type === TokenType.RESERVED_SELECT ||
+    type === TokenType.RESERVED_SET_OPERATION ||
+    type === TokenType.RESERVED_JOIN ||
+    type === TokenType.ARRAY_KEYWORD ||
+    type === TokenType.CASE ||
+    type === TokenType.END ||
+    type === TokenType.WHEN ||
+    type === TokenType.ELSE ||
+    type === TokenType.THEN ||
+    type === TokenType.LIMIT ||
+    type === TokenType.BETWEEN ||
+    type === TokenType.AND ||
+    type === TokenType.OR ||
+    type === TokenType.XOR;
+export const isLogicalOperator = (type) => type === TokenType.AND || type === TokenType.OR || type === TokenType.XOR;
+//# sourceMappingURL=token.js.map

package/dist/esm/lexer/token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.js","sourceRoot":"","sources":["../../../src/lexer/token.ts"],"names":[],"mappings":"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"}

package/dist/esm/parser/LexerAdapter.d.ts

@@ -0,0 +1,17 @@
+import { Token } from '../lexer/token.js';
+type NearleyToken = Token & {
+    value: string;
+};
+export default class LexerAdapter {
+    private tokenize;
+    private index;
+    private tokens;
+    private input;
+    constructor(tokenize: (chunk: string) => Token[]);
+    reset(chunk: string, _info: any): void;
+    next(): NearleyToken | undefined;
+    save(): any;
+    formatError(token: NearleyToken): string;
+    has(name: string): boolean;
+}
+export {};

package/dist/esm/parser/LexerAdapter.js

@@ -0,0 +1,27 @@
+import { lineColFromIndex } from '../lexer/lineColFromIndex.js';
+import { TokenType } from '../lexer/token.js';
+export default class LexerAdapter {
+    constructor(tokenize) {
+        this.tokenize = tokenize;
+        this.index = 0;
+        this.tokens = [];
+        this.input = '';
+    }
+    reset(chunk, _info) {
+        this.input = chunk;
+        this.index = 0;
+        this.tokens = this.tokenize(chunk);
+    }
+    next() {
+        return this.tokens[this.index++];
+    }
+    save() { }
+    formatError(token) {
+        const { line, col } = lineColFromIndex(this.input, token.start);
+        return `Parse error at token: ${token.text} at line ${line} column ${col}`;
+    }
+    has(name) {
+        return name in TokenType;
+    }
+}
+//# sourceMappingURL=LexerAdapter.js.map

package/dist/esm/parser/LexerAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexerAdapter.js","sourceRoot":"","sources":["../../../src/parser/LexerAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAS,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAMrD,MAAM,CAAC,OAAO,OAAO,YAAY;IAK/B,YAAoB,QAAoC;QAApC,aAAQ,GAAR,QAAQ,CAA4B;QAJhD,UAAK,GAAG,CAAC,CAAC;QACV,WAAM,GAAY,EAAE,CAAC;QACrB,UAAK,GAAG,EAAE,CAAC;IAEwC,CAAC;IAE5D,KAAK,CAAC,KAAa,EAAE,KAAU;QAC7B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;QACf,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACrC,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAA6B,CAAC;IAC/D,CAAC;IAED,IAAI,KAAS,CAAC;IAEd,WAAW,CAAC,KAAmB;QAC7B,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;QAChE,OAAO,yBAAyB,KAAK,CAAC,IAAI,YAAY,IAAI,WAAW,GAAG,EAAE,CAAC;IAC7E,CAAC;IAED,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,IAAI,SAAS,CAAC;IAC3B,CAAC;CACF"}

package/dist/esm/parser/ast.d.ts

@@ -0,0 +1,158 @@
+import { TokenType } from '../lexer/token.js';
+export declare enum NodeType {
+    statement = "statement",
+    clause = "clause",
+    set_operation = "set_operation",
+    function_call = "function_call",
+    parameterized_data_type = "parameterized_data_type",
+    array_subscript = "array_subscript",
+    property_access = "property_access",
+    parenthesis = "parenthesis",
+    between_predicate = "between_predicate",
+    case_expression = "case_expression",
+    case_when = "case_when",
+    case_else = "case_else",
+    limit_clause = "limit_clause",
+    all_columns_asterisk = "all_columns_asterisk",
+    literal = "literal",
+    identifier = "identifier",
+    keyword = "keyword",
+    data_type = "data_type",
+    parameter = "parameter",
+    operator = "operator",
+    comma = "comma",
+    line_comment = "line_comment",
+    block_comment = "block_comment",
+    disable_comment = "disable_comment"
+}
+interface BaseNode {
+    leadingComments?: CommentNode[];
+    trailingComments?: CommentNode[];
+}
+export interface StatementNode extends BaseNode {
+    type: NodeType.statement;
+    children: AstNode[];
+    hasSemicolon: boolean;
+}
+export interface ClauseNode extends BaseNode {
+    type: NodeType.clause;
+    nameKw: KeywordNode;
+    children: AstNode[];
+}
+export interface SetOperationNode extends BaseNode {
+    type: NodeType.set_operation;
+    nameKw: KeywordNode;
+    children: AstNode[];
+}
+export interface FunctionCallNode extends BaseNode {
+    type: NodeType.function_call;
+    nameKw: KeywordNode;
+    parenthesis: ParenthesisNode;
+}
+export interface ParameterizedDataTypeNode extends BaseNode {
+    type: NodeType.parameterized_data_type;
+    dataType: DataTypeNode;
+    parenthesis: ParenthesisNode;
+}
+export interface ArraySubscriptNode extends BaseNode {
+    type: NodeType.array_subscript;
+    array: IdentifierNode | KeywordNode | DataTypeNode;
+    parenthesis: ParenthesisNode;
+}
+export interface ParenthesisNode extends BaseNode {
+    type: NodeType.parenthesis;
+    children: AstNode[];
+    openParen: string;
+    closeParen: string;
+}
+export interface BetweenPredicateNode extends BaseNode {
+    type: NodeType.between_predicate;
+    betweenKw: KeywordNode;
+    expr1: AstNode[];
+    andKw: KeywordNode;
+    expr2: AstNode[];
+}
+export interface CaseExpressionNode extends BaseNode {
+    type: NodeType.case_expression;
+    caseKw: KeywordNode;
+    endKw: KeywordNode;
+    expr: AstNode[];
+    clauses: (CaseWhenNode | CaseElseNode)[];
+}
+export interface CaseWhenNode extends BaseNode {
+    type: NodeType.case_when;
+    whenKw: KeywordNode;
+    thenKw: KeywordNode;
+    condition: AstNode[];
+    result: AstNode[];
+}
+export interface CaseElseNode extends BaseNode {
+    type: NodeType.case_else;
+    elseKw: KeywordNode;
+    result: AstNode[];
+}
+export interface LimitClauseNode extends BaseNode {
+    type: NodeType.limit_clause;
+    limitKw: KeywordNode;
+    count: AstNode[];
+    offset?: AstNode[];
+}
+export interface AllColumnsAsteriskNode extends BaseNode {
+    type: NodeType.all_columns_asterisk;
+}
+export interface LiteralNode extends BaseNode {
+    type: NodeType.literal;
+    text: string;
+}
+export interface PropertyAccessNode extends BaseNode {
+    type: NodeType.property_access;
+    object: AstNode;
+    operator: string;
+    property: IdentifierNode | ArraySubscriptNode | AllColumnsAsteriskNode;
+}
+export interface IdentifierNode extends BaseNode {
+    type: NodeType.identifier;
+    quoted: boolean;
+    text: string;
+}
+export interface DataTypeNode extends BaseNode {
+    type: NodeType.data_type;
+    text: string;
+    raw: string;
+}
+export interface KeywordNode extends BaseNode {
+    type: NodeType.keyword;
+    tokenType: TokenType;
+    text: string;
+    raw: string;
+}
+export interface ParameterNode extends BaseNode {
+    type: NodeType.parameter;
+    key?: string;
+    text: string;
+}
+export interface OperatorNode extends BaseNode {
+    type: NodeType.operator;
+    text: string;
+}
+export interface CommaNode extends BaseNode {
+    type: NodeType.comma;
+}
+export interface LineCommentNode extends BaseNode {
+    type: NodeType.line_comment;
+    text: string;
+    precedingWhitespace: string;
+}
+export interface BlockCommentNode extends BaseNode {
+    type: NodeType.block_comment;
+    text: string;
+    precedingWhitespace: string;
+}
+export interface DisableCommentNode extends BaseNode {
+    type: NodeType.disable_comment;
+    text: string;
+    precedingWhitespace: string;
+}
+export type CommentNode = LineCommentNode | BlockCommentNode | DisableCommentNode;
+export type AstNode = ClauseNode | SetOperationNode | FunctionCallNode | ParameterizedDataTypeNode | ArraySubscriptNode | PropertyAccessNode | ParenthesisNode | BetweenPredicateNode | CaseExpressionNode | CaseWhenNode | CaseElseNode | LimitClauseNode | AllColumnsAsteriskNode | LiteralNode | IdentifierNode | DataTypeNode | KeywordNode | ParameterNode | OperatorNode | CommaNode | LineCommentNode | BlockCommentNode | DisableCommentNode;
+export {};

package/dist/esm/parser/ast.js

@@ -0,0 +1,28 @@
+export var NodeType;
+(function (NodeType) {
+    NodeType["statement"] = "statement";
+    NodeType["clause"] = "clause";
+    NodeType["set_operation"] = "set_operation";
+    NodeType["function_call"] = "function_call";
+    NodeType["parameterized_data_type"] = "parameterized_data_type";
+    NodeType["array_subscript"] = "array_subscript";
+    NodeType["property_access"] = "property_access";
+    NodeType["parenthesis"] = "parenthesis";
+    NodeType["between_predicate"] = "between_predicate";
+    NodeType["case_expression"] = "case_expression";
+    NodeType["case_when"] = "case_when";
+    NodeType["case_else"] = "case_else";
+    NodeType["limit_clause"] = "limit_clause";
+    NodeType["all_columns_asterisk"] = "all_columns_asterisk";
+    NodeType["literal"] = "literal";
+    NodeType["identifier"] = "identifier";
+    NodeType["keyword"] = "keyword";
+    NodeType["data_type"] = "data_type";
+    NodeType["parameter"] = "parameter";
+    NodeType["operator"] = "operator";
+    NodeType["comma"] = "comma";
+    NodeType["line_comment"] = "line_comment";
+    NodeType["block_comment"] = "block_comment";
+    NodeType["disable_comment"] = "disable_comment";
+})(NodeType = NodeType || (NodeType = {}));
+//# sourceMappingURL=ast.js.map

package/dist/esm/parser/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../../../src/parser/ast.ts"],"names":[],"mappings":"AAEA,MAAM,CAAN,IAAY,QAyBX;AAzBD,WAAY,QAAQ;IAClB,mCAAuB,CAAA;IACvB,6BAAiB,CAAA;IACjB,2CAA+B,CAAA;IAC/B,2CAA+B,CAAA;IAC/B,+DAAmD,CAAA;IACnD,+CAAmC,CAAA;IACnC,+CAAmC,CAAA;IACnC,uCAA2B,CAAA;IAC3B,mDAAuC,CAAA;IACvC,+CAAmC,CAAA;IACnC,mCAAuB,CAAA;IACvB,mCAAuB,CAAA;IACvB,yCAA6B,CAAA;IAC7B,yDAA6C,CAAA;IAC7C,+BAAmB,CAAA;IACnB,qCAAyB,CAAA;IACzB,+BAAmB,CAAA;IACnB,mCAAuB,CAAA;IACvB,mCAAuB,CAAA;IACvB,iCAAqB,CAAA;IACrB,2BAAe,CAAA;IACf,yCAA6B,CAAA;IAC7B,2CAA+B,CAAA;IAC/B,+CAAmC,CAAA;AACrC,CAAC,EAzBW,QAAQ,GAAR,QAAQ,KAAR,QAAQ,QAyBnB"}

package/dist/esm/parser/createParser.d.ts

@@ -0,0 +1,10 @@
+import Tokenizer from '../lexer/Tokenizer.js';
+import { ParamTypes } from '../lexer/TokenizerOptions.js';
+import { StatementNode } from './ast.js';
+export interface Parser {
+    parse(sql: string, paramTypesOverrides: ParamTypes): StatementNode[];
+}
+/**
+ * Creates a parser object which wraps the setup of Nearley parser
+ */
+export declare function createParser(tokenizer: Tokenizer): Parser;

package/dist/esm/parser/createParser.js

@@ -0,0 +1,36 @@
+import nearley from 'nearley';
+import { disambiguateTokens } from '../lexer/disambiguateTokens.js';
+import grammar from './grammar.js';
+import LexerAdapter from './LexerAdapter.js';
+import { createEofToken } from '../lexer/token.js';
+const { Parser: NearleyParser, Grammar } = nearley;
+/**
+ * Creates a parser object which wraps the setup of Nearley parser
+ */
+export function createParser(tokenizer) {
+    let paramTypesOverrides = {};
+    const lexer = new LexerAdapter(chunk => [
+        ...disambiguateTokens(tokenizer.tokenize(chunk, paramTypesOverrides)),
+        createEofToken(chunk.length),
+    ]);
+    const parser = new NearleyParser(Grammar.fromCompiled(grammar), { lexer });
+    return {
+        parse: (sql, paramTypes) => {
+            // share paramTypesOverrides with Tokenizer
+            paramTypesOverrides = paramTypes;
+            const { results } = parser.feed(sql);
+            if (results.length === 1) {
+                return results[0];
+            }
+            else if (results.length === 0) {
+                // Ideally we would report a line number where the parser failed,
+                // but I haven't found a way to get this info from Nearley :(
+                throw new Error('Parse error: Invalid SQL');
+            }
+            else {
+                throw new Error(`Parse error: Ambiguous grammar\n${JSON.stringify(results, undefined, 2)}`);
+            }
+        },
+    };
+}
+//# sourceMappingURL=createParser.js.map

package/dist/esm/parser/createParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createParser.js","sourceRoot":"","sources":["../../../src/parser/createParser.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAG9B,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGpE,OAAO,OAAO,MAAM,cAAc,CAAC;AACnC,OAAO,YAAY,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;AAMnD;;GAEG;AACH,MAAM,UAAU,YAAY,CAAC,SAAoB;IAC/C,IAAI,mBAAmB,GAAe,EAAE,CAAC;IACzC,MAAM,KAAK,GAAG,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;QACtC,GAAG,kBAAkB,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC;QACrE,cAAc,CAAC,KAAK,CAAC,MAAM,CAAC;KAC7B,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,IAAI,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAE3E,OAAO;QACL,KAAK,EAAE,CAAC,GAAW,EAAE,UAAsB,EAAE,EAAE;YAC7C,2CAA2C;YAC3C,mBAAmB,GAAG,UAAU,CAAC;YAEjC,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAErC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;gBACxB,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;aACnB;iBAAM,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC/B,iEAAiE;gBACjE,6DAA6D;gBAC7D,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;aAC7C;iBAAM;gBACL,MAAM,IAAI,KAAK,CAAC,mCAAmC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;aAC7F;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/esm/parser/grammar.d.ts

@@ -0,0 +1,28 @@
+interface NearleyToken {
+    value: any;
+    [key: string]: any;
+}
+interface NearleyLexer {
+    reset: (chunk: string, info: any) => void;
+    next: () => NearleyToken | undefined;
+    save: () => any;
+    formatError: (token: never) => string;
+    has: (tokenType: string) => boolean;
+}
+interface NearleyRule {
+    name: string;
+    symbols: NearleySymbol[];
+    postprocess?: (d: any[], loc?: number, reject?: {}) => any;
+}
+type NearleySymbol = string | {
+    literal: any;
+} | {
+    test: (token: any) => boolean;
+};
+interface Grammar {
+    Lexer: NearleyLexer | undefined;
+    ParserRules: NearleyRule[];
+    ParserStart: string;
+}
+declare const grammar: Grammar;
+export default grammar;