refactor: standard naming (#278)

* refactor: rename flinksql to flink

* refactor: rename pgsql to postgresql

* refactor: rename trinosql to trino

* refactor: replace all default exports with named export

* refactor: rename basicParser to basicSQL

* refactor: rename basic-parser-types to types

* refactor: replace arrow func with plain func

src/parser/common/basicSQL.ts

@@ -10,20 +10,20 @@ import {
     PredictionMode,
 } from 'antlr4ng';
 import { CandidatesCollection, CodeCompletionCore } from 'antlr4-c3';
-import SQLParserBase from '../../lib/SQLParserBase';
+import { SQLParserBase } from '../../lib/SQLParserBase';
 import { findCaretTokenIndex } from './findCaretTokenIndex';
 import { ctxToText, tokenToWord, WordRange, TextSlice } from './textAndWord';
-import { CaretPosition, Suggestions, SyntaxSuggestion } from './basic-parser-types';
-import ParseErrorListener, { ParseError, ErrorListener } from './parseErrorListener';
+import { CaretPosition, Suggestions, SyntaxSuggestion } from './types';
+import { ParseError, ErrorListener, ParseErrorListener } from './parseErrorListener';
 import { ErrorStrategy } from './errorStrategy';
-import type SplitListener from './splitListener';
-import type EntityCollector from './entityCollector';
+import type { SplitListener } from './splitListener';
+import type { EntityCollector } from './entityCollector';
 import { EntityContext } from './entityCollector';
 
 /**
- * Custom Parser class, subclass needs extends it.
+ * Basic SQL class, every sql needs extends it.
  */
-export default abstract class BasicParser<
+export abstract class BasicSQL<
     L extends Lexer = Lexer,
     PRC extends ParserRuleContext = ParserRuleContext,
     P extends SQLParserBase<PRC> = SQLParserBase<PRC>,

src/parser/common/entityCollector.ts

@@ -1,8 +1,8 @@
 import { ParserRuleContext } from 'antlr4ng';
-import { EntityContextType } from './basic-parser-types';
+import { EntityContextType } from './types';
 import { WordPosition, TextPosition } from './textAndWord';
 import { ctxToText, ctxToWord } from './textAndWord';
-import SimpleStack from './simpleStack';
+import { SimpleStack } from './simpleStack';
 
 /**
  * TODO: more stmt type should be supported.
@@ -11,7 +11,7 @@ export enum StmtContextType {
     /** A self-contained and complete statement */
     COMMON_STMT = 'commonStmt',
     CREATE_CATALOG_STMT = 'createCatalogStmt',
-    CREATE_DATABASE_STMT = 'crateDatabaseStmt',
+    CREATE_DATABASE_STMT = 'createDatabaseStmt',
     CREATE_TABLE_STMT = 'createTableStmt',
     CREATE_VIEW_STMT = 'createViewStmt',
     SELECT_STMT = 'selectStmt',
@@ -90,7 +90,7 @@ export function toEntityContext(
  * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
  * @todo: [may be need] Combine the entities in each clause.
  */
-abstract class EntityCollector {
+export abstract class EntityCollector {
     constructor(input: string, caretTokenIndex?: number) {
         this._input = input;
         this._caretTokenIndex = caretTokenIndex ?? -1;
@@ -275,5 +275,3 @@ abstract class EntityCollector {
         return finalEntities;
     }
 }
-
-export default EntityCollector;

src/parser/common/findCaretTokenIndex.ts

@@ -1,5 +1,5 @@
 import { Token } from 'antlr4ng';
-import { CaretPosition } from './basic-parser-types';
+import { CaretPosition } from './types';
 
 /**
  * find token index via caret position (cursor position)

src/parser/common/parseErrorListener.ts

@@ -39,7 +39,7 @@ export interface SyntaxError<T> {
  */
 export type ErrorListener<T> = (parseError: ParseError, originalError: SyntaxError<T>) => void;
 
-export default class ParseErrorListener implements ANTLRErrorListener {
+export class ParseErrorListener implements ANTLRErrorListener {
     private _errorListener: ErrorListener<Token>;
 
     constructor(errorListener: ErrorListener<Token>) {

src/parser/common/simpleStack.ts

@@ -1,4 +1,4 @@
-class SimpleStack<T> {
+export class SimpleStack<T> {
     constructor() {
         this.stack = [];
     }
@@ -28,5 +28,3 @@ class SimpleStack<T> {
         return this.stack.length === 0;
     }
 }
-
-export default SimpleStack;

src/parser/common/splitListener.ts

@@ -1,4 +1,4 @@
-abstract class SplitListener<T> {
+export abstract class SplitListener<T> {
     protected _statementsContext: T[] = [];
 
     visitTerminal() {}
@@ -13,5 +13,3 @@ abstract class SplitListener<T> {
         return this._statementsContext;
     }
 }
-
-export default SplitListener;

src/parser/flink/flinkEntityCollector.ts

@@ -1,4 +1,4 @@
-import { EntityContextType } from '../../parser/common/basic-parser-types';
+import { EntityContextType } from '../common/types';
 import {
     CatalogPathContext,
     CatalogPathCreateContext,
@@ -18,14 +18,11 @@ import {
     TablePathCreateContext,
     ViewPathContext,
     ViewPathCreateContext,
-} from '../../lib/flinksql/FlinkSqlParser';
-import { FlinkSqlParserListener } from '../../lib/flinksql/FlinkSqlParserListener';
-import EntityCollector, { StmtContextType } from '../common/entityCollector';
+} from '../../lib/flink/FlinkSqlParser';
+import { FlinkSqlParserListener } from '../../lib/flink/FlinkSqlParserListener';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
 
-export default class FlinkEntityCollector
-    extends EntityCollector
-    implements FlinkSqlParserListener
-{
+export class FlinkEntityCollector extends EntityCollector implements FlinkSqlParserListener {
     /** ====== Entity Begin */
     exitCatalogPathCreate(ctx: CatalogPathCreateContext) {
         this.pushEntity(ctx, EntityContextType.CATALOG_CREATE);

src/parser/flink/flinkSplitListener.ts

@@ -0,0 +1,12 @@
+import { SingleStatementContext } from '../../lib/flink/FlinkSqlParser';
+import { FlinkSqlParserListener } from '../../lib/flink/FlinkSqlParserListener';
+import { SplitListener } from '../common/splitListener';
+
+export class FlinkSqlSplitListener
+    extends SplitListener<SingleStatementContext>
+    implements FlinkSqlParserListener
+{
+    exitSingleStatement(ctx: SingleStatementContext) {
+        this._statementsContext.push(ctx);
+    }
+}

src/parser/flink/index.ts

@@ -1,24 +1,22 @@
 import { Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
-import { FlinkSqlLexer } from '../../lib/flinksql/FlinkSqlLexer';
-import { FlinkSqlParser, ProgramContext } from '../../lib/flinksql/FlinkSqlParser';
-import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/basic-parser-types';
-import BasicParser from '../common/basicParser';
+import { FlinkSqlLexer } from '../../lib/flink/FlinkSqlLexer';
+import { FlinkSqlParser, ProgramContext } from '../../lib/flink/FlinkSqlParser';
+import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/types';
+import { BasicSQL } from '../common/basicSQL';
 import { StmtContextType } from '../common/entityCollector';
 import { FlinkSqlSplitListener } from './flinkSplitListener';
-import FlinkEntityCollector from './flinkEntityCollector';
+import { FlinkEntityCollector } from './flinkEntityCollector';
 
 export { FlinkSqlSplitListener, FlinkEntityCollector };
 
-export default class FlinkSQL extends BasicParser<FlinkSqlLexer, ProgramContext, FlinkSqlParser> {
+export class FlinkSQL extends BasicSQL<FlinkSqlLexer, ProgramContext, FlinkSqlParser> {
     protected createLexerFromCharStream(charStreams) {
-        const lexer = new FlinkSqlLexer(charStreams);
-        return lexer;
+        return new FlinkSqlLexer(charStreams);
     }
 
     protected createParserFromTokenStream(tokenStream) {
-        const parser = new FlinkSqlParser(tokenStream);
-        return parser;
+        return new FlinkSqlParser(tokenStream);
     }
 
     protected preferredRules = new Set([

src/parser/flinksql/flinkSplitListener.ts

@@ -1,12 +0,0 @@
-import { SingleStatementContext } from '../../lib/flinksql/FlinkSqlParser';
-import { FlinkSqlParserListener } from '../../lib/flinksql/FlinkSqlParserListener';
-import SplitListener from '../common/splitListener';
-
-export class FlinkSqlSplitListener
-    extends SplitListener<SingleStatementContext>
-    implements FlinkSqlParserListener
-{
-    exitSingleStatement = (ctx: SingleStatementContext) => {
-        this._statementsContext.push(ctx);
-    };
-}

src/parser/hive/hiveEntityCollector.ts

@@ -1,4 +1,4 @@
-import { EntityContextType } from '../..';
+import { EntityContextType } from '../common/types';
 import { HiveSqlParserListener } from '../../lib';
 import {
     ColumnNameCreateContext,
@@ -21,29 +21,29 @@ import {
     ViewNameContext,
     ViewNameCreateContext,
 } from '../../lib/hive/HiveSqlParser';
-import EntityCollector, { StmtContextType } from '../common/entityCollector';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
 
-export default class HiveEntityCollector extends EntityCollector implements HiveSqlParserListener {
+export class HiveEntityCollector extends EntityCollector implements HiveSqlParserListener {
     /** ====== Entity Begin */
-    exitTableNameCreate = (ctx: TableNameCreateContext) => {
+    exitTableNameCreate(ctx: TableNameCreateContext) {
         this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
-    };
+    }
 
-    exitTableName = (ctx: TableNameContext) => {
+    exitTableName(ctx: TableNameContext) {
         this.pushEntity(ctx, EntityContextType.TABLE);
-    };
+    }
 
-    exitColumnNameCreate = (ctx: ColumnNameCreateContext) => {
+    exitColumnNameCreate(ctx: ColumnNameCreateContext) {
         this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
-    };
+    }
 
-    exitViewNameCreate = (ctx: ViewNameCreateContext) => {
+    exitViewNameCreate(ctx: ViewNameCreateContext) {
         this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
-    };
+    }
 
-    exitViewName = (ctx: ViewNameContext) => {
+    exitViewName(ctx: ViewNameContext) {
         this.pushEntity(ctx, EntityContextType.VIEW);
-    };
+    }
 
     exitDbSchemaNameCreate(ctx: DbSchemaNameCreateContext) {
         this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
@@ -57,70 +57,70 @@ export default class HiveEntityCollector extends EntityCollector implements Hive
         this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
     }
 
-    /** ===== Statement begin */
-    enterStatement = (ctx: StatementContext) => {
+    /** ==== Statement begin */
+    enterStatement(ctx: StatementContext) {
         this.pushStmt(ctx, StmtContextType.COMMON_STMT);
-    };
+    }
 
-    exitStatement = () => {
+    exitStatement() {
         this.popStmt();
-    };
+    }
 
-    enterCreateTableStatement = (ctx: CreateTableStatementContext) => {
+    enterCreateTableStatement(ctx: CreateTableStatementContext) {
         this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
-    };
+    }
 
-    exitCreateTableStatement = () => {
+    exitCreateTableStatement() {
         this.popStmt();
-    };
+    }
 
-    enterSelectStatement = (ctx: SelectStatementContext) => {
+    enterSelectStatement(ctx: SelectStatementContext) {
         this.pushStmt(ctx, StmtContextType.SELECT_STMT);
-    };
+    }
 
-    exitSelectStatement = (ctx: SelectStatementContext) => {
+    exitSelectStatement(ctx: SelectStatementContext) {
         this.popStmt();
-    };
+    }
 
-    enterFromSelectStmt = (ctx: FromSelectStmtContext) => {
+    enterFromSelectStmt(ctx: FromSelectStmtContext) {
         this.pushStmt(ctx, StmtContextType.SELECT_STMT);
-    };
+    }
 
-    exitFromSelectStmt = (ctx: FromSelectStmtContext) => {
+    exitFromSelectStmt(ctx: FromSelectStmtContext) {
         this.popStmt();
-    };
+    }
 
-    enterCreateViewStatement = (ctx: CreateViewStatementContext) => {
+    enterCreateViewStatement(ctx: CreateViewStatementContext) {
         this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
-    };
+    }
 
-    exitCreateViewStatement = (ctx: CreateViewStatementContext) => {
+    exitCreateViewStatement(ctx: CreateViewStatementContext) {
         this.popStmt();
-    };
+    }
 
-    enterCreateMaterializedViewStatement = (ctx: CreateMaterializedViewStatementContext) => {
+    enterCreateMaterializedViewStatement(ctx: CreateMaterializedViewStatementContext) {
         this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
-    };
+    }
 
-    exitCreateMaterializedViewStatement = (ctx: CreateMaterializedViewStatementContext) => {
+    exitCreateMaterializedViewStatement(ctx: CreateMaterializedViewStatementContext) {
         this.popStmt();
-    };
+    }
 
-    enterInsertStmt = (ctx: InsertStmtContext) => {
+    enterInsertStmt(ctx: InsertStmtContext) {
         this.pushStmt(ctx, StmtContextType.INSERT_STMT);
-    };
+    }
 
-    exitInsertStmt = (ctx: InsertStmtContext) => {
+    exitInsertStmt(ctx: InsertStmtContext) {
         this.popStmt();
-    };
+    }
 
-    enterFromInsertStmt = (ctx: FromInsertStmtContext) => {
+    enterFromInsertStmt(ctx: FromInsertStmtContext) {
         this.pushStmt(ctx, StmtContextType.INSERT_STMT);
-    };
+    }
 
-    exitFromInsertStmt = (ctx: FromInsertStmtContext) => {
+    exitFromInsertStmt(ctx: FromInsertStmtContext) {
         this.popStmt();
-    };
+    }
 
     enterCreateDatabaseStatement(ctx: CreateDatabaseStatementContext) {
         this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT);

src/parser/hive/hiveSplitListener.ts

@@ -1,12 +1,12 @@
 import { StatementContext } from '../../lib/hive/HiveSqlParser';
 import { HiveSqlParserListener } from '../../lib/hive/HiveSqlParserListener';
-import SplitListener from '../common/splitListener';
+import { SplitListener } from '../common/splitListener';
 
 export class HiveSqlSplitListener
     extends SplitListener<StatementContext>
     implements HiveSqlParserListener
 {
-    exitStatement = (ctx: StatementContext) => {
+    exitStatement(ctx: StatementContext) {
         this._statementsContext.push(ctx);
-    };
+    }
 }

src/parser/hive/index.ts

@@ -2,19 +2,18 @@ import { Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
 import { HiveSqlLexer } from '../../lib/hive/HiveSqlLexer';
 import { HiveSqlParser, ProgramContext } from '../../lib/hive/HiveSqlParser';
-import BasicParser from '../common/basicParser';
+import { BasicSQL } from '../common/basicSQL';
 
-import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/basic-parser-types';
+import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/types';
 import { StmtContextType } from '../common/entityCollector';
 import { HiveSqlSplitListener } from './hiveSplitListener';
-import HiveEntityCollector from './hiveEntityCollector';
+import { HiveEntityCollector } from './hiveEntityCollector';
 
 export { HiveEntityCollector, HiveSqlSplitListener };
 
-export default class HiveSQL extends BasicParser<HiveSqlLexer, ProgramContext, HiveSqlParser> {
+export class HiveSQL extends BasicSQL<HiveSqlLexer, ProgramContext, HiveSqlParser> {
     protected createLexerFromCharStream(charStreams) {
-        const lexer = new HiveSqlLexer(charStreams);
-        return lexer;
+        return new HiveSqlLexer(charStreams);
     }
 
     protected createParserFromTokenStream(tokenStream) {

src/parser/impala/impalaEntityCollector.ts

@@ -20,13 +20,10 @@ import {
     ViewNameCreateContext,
     ViewNamePathContext,
 } from '../../lib/impala/ImpalaSqlParser';
-import { EntityContextType } from '../common/basic-parser-types';
-import EntityCollector, { StmtContextType } from '../common/entityCollector';
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
 
-export default class ImpalaEntityCollector
-    extends EntityCollector
-    implements ImpalaSqlParserListener
-{
+export class ImpalaEntityCollector extends EntityCollector implements ImpalaSqlParserListener {
     /** ===== Entity begin */
     exitTableNameCreate(ctx: TableNameCreateContext) {
         this.pushEntity(ctx, EntityContextType.TABLE_CREATE);

src/parser/impala/impalaSplitListener.ts

@@ -1,12 +1,12 @@
 import { SingleStatementContext } from '../../lib/impala/ImpalaSqlParser';
 import { ImpalaSqlParserListener } from '../../lib/impala/ImpalaSqlParserListener';
-import SplitListener from '../common/splitListener';
+import { SplitListener } from '../common/splitListener';
 
 export class ImpalaSqlSplitListener
     extends SplitListener<SingleStatementContext>
     implements ImpalaSqlParserListener
 {
-    exitSingleStatement = (ctx: SingleStatementContext) => {
+    exitSingleStatement(ctx: SingleStatementContext) {
         this._statementsContext.push(ctx);
-    };
+    }
 }

src/parser/impala/index.ts

@@ -2,22 +2,17 @@ import { Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
 import { ImpalaSqlLexer } from '../../lib/impala/ImpalaSqlLexer';
 import { ImpalaSqlParser, ProgramContext } from '../../lib/impala/ImpalaSqlParser';
-import BasicParser from '../common/basicParser';
-import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/basic-parser-types';
+import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/types';
 import { StmtContextType } from '../common/entityCollector';
 import { ImpalaSqlSplitListener } from './impalaSplitListener';
-import ImpalaEntityCollector from './impalaEntityCollector';
+import { ImpalaEntityCollector } from './impalaEntityCollector';
 
 export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 
-export default class ImpalaSQL extends BasicParser<
-    ImpalaSqlLexer,
-    ProgramContext,
-    ImpalaSqlParser
-> {
+export class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext, ImpalaSqlParser> {
     protected createLexerFromCharStream(charStreams) {
-        const lexer = new ImpalaSqlLexer(charStreams);
-        return lexer;
+        return new ImpalaSqlLexer(charStreams);
     }
 
     protected createParserFromTokenStream(tokenStream) {

src/parser/index.ts

@@ -1,8 +1,8 @@
-export { default as MySQL } from './mysql';
-export { default as PLSQL } from './plsql';
-export { default as HiveSQL } from './hive';
-export { default as FlinkSQL } from './flinksql';
-export { default as SparkSQL } from './spark';
-export { default as PostgresSQL } from './pgsql';
-export { default as TrinoSQL } from './trino';
-export { default as ImpalaSQL } from './impala';
+export { MySQL } from './mysql';
+export { PLSQL } from './plsql';
+export { HiveSQL } from './hive';
+export { FlinkSQL } from './flink';
+export { SparkSQL } from './spark';
+export { PostgreSQL } from './postgresql';
+export { TrinoSQL } from './trino';
+export { ImpalaSQL } from './impala';

src/parser/mysql/index.ts

@@ -2,18 +2,17 @@ import { Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
 import { MySqlLexer } from '../../lib/mysql/MySqlLexer';
 import { MySqlParser, ProgramContext } from '../../lib/mysql/MySqlParser';
-import BasicParser from '../common/basicParser';
-import { Suggestions, EntityContextType, SyntaxSuggestion } from '../common/basic-parser-types';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions, EntityContextType, SyntaxSuggestion } from '../common/types';
 import { StmtContextType } from '../common/entityCollector';
-import MysqlSplitListener from './mysqlSplitListener';
-import MySqlEntityCollector from './mysqlEntityCollector';
+import { MysqlSplitListener } from './mysqlSplitListener';
+import { MySqlEntityCollector } from './mysqlEntityCollector';
 
 export { MySqlEntityCollector, MysqlSplitListener };
 
-export default class MySQL extends BasicParser<MySqlLexer, ProgramContext, MySqlParser> {
+export class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlParser> {
     protected createLexerFromCharStream(charStreams): MySqlLexer {
-        const lexer = new MySqlLexer(charStreams);
-        return lexer;
+        return new MySqlLexer(charStreams);
     }
 
     protected createParserFromTokenStream(tokenStream): MySqlParser {

src/parser/mysql/mysqlEntityCollector.ts

@@ -19,10 +19,10 @@ import type {
     ViewNameCreateContext,
 } from '../../lib/mysql/MySqlParser';
 import type { MySqlParserListener } from '../../lib/mysql/MySqlParserListener';
-import { EntityContextType } from '../common/basic-parser-types';
-import EntityCollector, { StmtContextType } from '../common/entityCollector';
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
 
-export default class MySqlEntityCollector extends EntityCollector implements MySqlParserListener {
+export class MySqlEntityCollector extends EntityCollector implements MySqlParserListener {
     /** ====== Entity Begin */
     exitDatabaseName(ctx: DatabaseNameContext) {
         this.pushEntity(ctx, EntityContextType.DATABASE);

src/parser/mysql/mysqlSplitListener.ts

@@ -1,12 +1,12 @@
 import { SingleStatementContext } from '../../lib/mysql/MySqlParser';
 import { MySqlParserListener } from '../../lib/mysql/MySqlParserListener';
-import SplitListener from '../common/splitListener';
+import { SplitListener } from '../common/splitListener';
 
-export default class MysqlSplitListener
+export class MysqlSplitListener
     extends SplitListener<SingleStatementContext>
     implements MySqlParserListener
 {
-    exitSingleStatement = (ctx: SingleStatementContext) => {
+    exitSingleStatement(ctx: SingleStatementContext) {
         this._statementsContext.push(ctx);
-    };
+    }
 }

src/parser/pgsql/postgreSplitListener.ts

@@ -1,12 +0,0 @@
-import { SingleStmtContext } from '../../lib/pgsql/PostgreSQLParser';
-import { PostgreSQLParserListener } from '../../lib/pgsql/PostgreSQLParserListener';
-import SplitListener from '../common/splitListener';
-
-export default class PostgreSqlSplitListener
-    extends SplitListener<SingleStmtContext>
-    implements PostgreSQLParserListener
-{
-    exitSingleStmt = (ctx: SingleStmtContext) => {
-        this._statementsContext.push(ctx);
-    };
-}

src/parser/plsql.ts

@@ -2,13 +2,12 @@ import { Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
 import { PlSqlLexer } from '../lib/plsql/PlSqlLexer';
 import { PlSqlParser, ProgramContext } from '../lib/plsql/PlSqlParser';
-import BasicParser from './common/basicParser';
-import { Suggestions } from './common/basic-parser-types';
+import { BasicSQL } from './common/basicSQL';
+import { Suggestions } from './common/types';
 
-export default class PLSQL extends BasicParser<PlSqlLexer, ProgramContext, PlSqlParser> {
+export class PLSQL extends BasicSQL<PlSqlLexer, ProgramContext, PlSqlParser> {
     protected createLexerFromCharStream(charStreams) {
-        const lexer = new PlSqlLexer(charStreams);
-        return lexer;
+        return new PlSqlLexer(charStreams);
     }
 
     protected createParserFromTokenStream(tokenStream) {

src/parser/postgresql/index.ts

@@ -1,45 +1,40 @@
 import { CandidatesCollection } from 'antlr4-c3';
 import { Token } from 'antlr4ng';
 
-import { PostgreSQLLexer } from '../../lib/pgsql/PostgreSQLLexer';
-import { PostgreSQLParser, ProgramContext } from '../../lib/pgsql/PostgreSQLParser';
-import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/basic-parser-types';
-import BasicParser from '../common/basicParser';
+import { PostgreSqlLexer } from '../../lib/postgresql/PostgreSqlLexer';
+import { PostgreSqlParser, ProgramContext } from '../../lib/postgresql/PostgreSqlParser';
+import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/types';
+import { BasicSQL } from '../common/basicSQL';
 import { StmtContextType } from '../common/entityCollector';
-import PostgreSQLEntityCollector from './postgreEntityCollector';
-import PostgreSqlSplitListener from './postgreSplitListener';
+import { PostgreSqlEntityCollector } from './postgreEntityCollector';
+import { PostgreSqlSplitListener } from './postgreSplitListener';
 
-export { PostgreSQLEntityCollector, PostgreSqlSplitListener };
+export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 
-export default class PostgresSQL extends BasicParser<
-    PostgreSQLLexer,
-    ProgramContext,
-    PostgreSQLParser
-> {
+export class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext, PostgreSqlParser> {
     protected createLexerFromCharStream(charStreams) {
-        const lexer = new PostgreSQLLexer(charStreams);
-        return lexer;
+        return new PostgreSqlLexer(charStreams);
     }
 
     protected createParserFromTokenStream(tokenStream) {
-        return new PostgreSQLParser(tokenStream);
+        return new PostgreSqlParser(tokenStream);
     }
 
     protected preferredRules: Set<number> = new Set([
-        PostgreSQLParser.RULE_table_name_create, // table name
-        PostgreSQLParser.RULE_table_name, // table name that will be created
-        PostgreSQLParser.RULE_function_name, // function name
-        PostgreSQLParser.RULE_function_name_create, // function name that will be created
-        PostgreSQLParser.RULE_schema_name_create, // schema name that will be created
-        PostgreSQLParser.RULE_schema_name, // schema name
-        PostgreSQLParser.RULE_view_name_create, // view name that will be created
-        PostgreSQLParser.RULE_view_name, // view name
-        PostgreSQLParser.RULE_database_name_create, // database name that will be created
-        PostgreSQLParser.RULE_database_name, // database name
-        PostgreSQLParser.RULE_procedure_name_create, // procedure name that will be created
-        PostgreSQLParser.RULE_procedure_name, // procedure name
-        PostgreSQLParser.RULE_column_name_create, // column name that will be created
-        PostgreSQLParser.RULE_column_name, // column name
+        PostgreSqlParser.RULE_table_name_create, // table name
+        PostgreSqlParser.RULE_table_name, // table name that will be created
+        PostgreSqlParser.RULE_function_name, // function name
+        PostgreSqlParser.RULE_function_name_create, // function name that will be created
+        PostgreSqlParser.RULE_schema_name_create, // schema name that will be created
+        PostgreSqlParser.RULE_schema_name, // schema name
+        PostgreSqlParser.RULE_view_name_create, // view name that will be created
+        PostgreSqlParser.RULE_view_name, // view name
+        PostgreSqlParser.RULE_database_name_create, // database name that will be created
+        PostgreSqlParser.RULE_database_name, // database name
+        PostgreSqlParser.RULE_procedure_name_create, // procedure name that will be created
+        PostgreSqlParser.RULE_procedure_name, // procedure name
+        PostgreSqlParser.RULE_column_name_create, // column name that will be created
+        PostgreSqlParser.RULE_column_name, // column name
     ]);
 
     protected get splitListener() {
@@ -47,7 +42,7 @@ export default class PostgresSQL extends BasicParser<
     }
 
     protected createEntityCollector(input: string, caretTokenIndex?: number) {
-        return new PostgreSQLEntityCollector(input, caretTokenIndex);
+        return new PostgreSqlEntityCollector(input, caretTokenIndex);
     }
 
     protected processCandidates(
@@ -68,59 +63,59 @@ export default class PostgresSQL extends BasicParser<
 
             let syntaxContextType: EntityContextType | StmtContextType;
             switch (ruleType) {
-                case PostgreSQLParser.RULE_table_name_create: {
+                case PostgreSqlParser.RULE_table_name_create: {
                     syntaxContextType = EntityContextType.TABLE_CREATE;
                     break;
                 }
-                case PostgreSQLParser.RULE_table_name: {
+                case PostgreSqlParser.RULE_table_name: {
                     syntaxContextType = EntityContextType.TABLE;
                     break;
                 }
-                case PostgreSQLParser.RULE_function_name_create: {
+                case PostgreSqlParser.RULE_function_name_create: {
                     syntaxContextType = EntityContextType.FUNCTION_CREATE;
                     break;
                 }
-                case PostgreSQLParser.RULE_function_name: {
+                case PostgreSqlParser.RULE_function_name: {
                     syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
-                case PostgreSQLParser.RULE_schema_name_create: {
+                case PostgreSqlParser.RULE_schema_name_create: {
                     syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
-                case PostgreSQLParser.RULE_schema_name: {
+                case PostgreSqlParser.RULE_schema_name: {
                     syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
-                case PostgreSQLParser.RULE_view_name_create: {
+                case PostgreSqlParser.RULE_view_name_create: {
                     syntaxContextType = EntityContextType.VIEW_CREATE;
                     break;
                 }
-                case PostgreSQLParser.RULE_view_name: {
+                case PostgreSqlParser.RULE_view_name: {
                     syntaxContextType = EntityContextType.VIEW;
                     break;
                 }
-                case PostgreSQLParser.RULE_database_name_create: {
+                case PostgreSqlParser.RULE_database_name_create: {
                     syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
-                case PostgreSQLParser.RULE_database_name: {
+                case PostgreSqlParser.RULE_database_name: {
                     syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
-                case PostgreSQLParser.RULE_procedure_name_create: {
+                case PostgreSqlParser.RULE_procedure_name_create: {
                     syntaxContextType = EntityContextType.PROCEDURE_CREATE;
                     break;
                 }
-                case PostgreSQLParser.RULE_procedure_name: {
+                case PostgreSqlParser.RULE_procedure_name: {
                     syntaxContextType = EntityContextType.PROCEDURE;
                     break;
                 }
-                case PostgreSQLParser.RULE_column_name_create: {
+                case PostgreSqlParser.RULE_column_name_create: {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
-                case PostgreSQLParser.RULE_column_name: {
+                case PostgreSqlParser.RULE_column_name: {
                     syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }

src/parser/postgresql/postgreEntityCollector.ts

@@ -18,15 +18,12 @@ import type {
     TableNameCreateContext,
     ViewNameContext,
     ViewNameCreateContext,
-} from '../../lib/pgsql/PostgreSQLParser';
-import type { PostgreSQLParserListener } from '../../lib/pgsql/PostgreSQLParserListener';
-import { EntityContextType } from '../common/basic-parser-types';
-import EntityCollector, { StmtContextType } from '../common/entityCollector';
+} from '../../lib/postgresql/PostgreSqlParser';
+import type { PostgreSqlParserListener } from '../../lib/postgresql/PostgreSqlParserListener';
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
 
-export default class PostgreSQLEntityCollector
-    extends EntityCollector
-    implements PostgreSQLParserListener
-{
+export class PostgreSqlEntityCollector extends EntityCollector implements PostgreSqlParserListener {
     /** ====== Entity Begin */
     exitDatabaseName(ctx: DatabaseNameContext) {
         this.pushEntity(ctx, EntityContextType.DATABASE);

src/parser/postgresql/postgreSplitListener.ts

@@ -0,0 +1,12 @@
+import { SingleStmtContext } from '../../lib/postgresql/PostgreSqlParser';
+import { PostgreSqlParserListener } from '../../lib/postgresql/PostgreSqlParserListener';
+import { SplitListener } from '../common/splitListener';
+
+export class PostgreSqlSplitListener
+    extends SplitListener<SingleStmtContext>
+    implements PostgreSqlParserListener
+{
+    exitSingleStmt(ctx: SingleStmtContext) {
+        this._statementsContext.push(ctx);
+    }
+}

src/parser/spark/index.ts

@@ -2,23 +2,21 @@ import { Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
 import { SparkSqlLexer } from '../../lib/spark/SparkSqlLexer';
 import { SparkSqlParser, ProgramContext } from '../../lib/spark/SparkSqlParser';
-import BasicParser from '../common/basicParser';
-import { Suggestions, EntityContextType, SyntaxSuggestion } from '../common/basic-parser-types';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions, EntityContextType, SyntaxSuggestion } from '../common/types';
 import { StmtContextType } from '../common/entityCollector';
-import SparkSqlSplitListener from './sparkSplitListener';
-import SparkEntityCollector from './sparkEntityCollector';
+import { SparkSqlSplitListener } from './sparkSplitListener';
+import { SparkEntityCollector } from './sparkEntityCollector';
 
 export { SparkSqlSplitListener, SparkEntityCollector };
 
-export default class SparkSQL extends BasicParser<SparkSqlLexer, ProgramContext, SparkSqlParser> {
+export class SparkSQL extends BasicSQL<SparkSqlLexer, ProgramContext, SparkSqlParser> {
     protected createLexerFromCharStream(charStreams) {
-        const lexer = new SparkSqlLexer(charStreams);
-        return lexer;
+        return new SparkSqlLexer(charStreams);
     }
 
     protected createParserFromTokenStream(tokenStream) {
-        const parser = new SparkSqlParser(tokenStream);
-        return parser;
+        return new SparkSqlParser(tokenStream);
     }
 
     protected preferredRules: Set<number> = new Set([

src/parser/spark/sparkEntityCollector.ts

@@ -20,13 +20,10 @@ import type {
     CreateFunctionContext,
 } from '../../lib/spark/SparkSqlParser';
 import type { SparkSqlParserListener } from '../../lib/spark/SparkSqlParserListener';
-import { EntityContextType } from '../common/basic-parser-types';
-import EntityCollector, { StmtContextType } from '../common/entityCollector';
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
 
-export default class SparkEntityCollector
-    extends EntityCollector
-    implements SparkSqlParserListener
-{
+export class SparkEntityCollector extends EntityCollector implements SparkSqlParserListener {
     /** ====== Entity Begin */
     exitNamespaceName(ctx: NamespaceNameContext) {
         this.pushEntity(ctx, EntityContextType.DATABASE);

src/parser/spark/sparkSplitListener.ts

@@ -1,13 +1,13 @@
 import { SingleStatementContext } from '../../lib/spark/SparkSqlParser';
 
 import { SparkSqlParserListener } from '../../lib/spark/SparkSqlParserListener';
-import SplitListener from '../common/splitListener';
+import { SplitListener } from '../common/splitListener';
 
-export default class SparkSqlSplitListener
+export class SparkSqlSplitListener
     extends SplitListener<SingleStatementContext>
     implements SparkSqlParserListener
 {
-    exitSingleStatement = (ctx: SingleStatementContext) => {
+    exitSingleStatement(ctx: SingleStatementContext) {
         this._statementsContext.push(ctx);
-    };
+    }
 }

src/parser/trino/index.ts

@@ -1,24 +1,22 @@
 import { Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
-import { TrinoSqlLexer } from '../../lib/trinosql/TrinoSqlLexer';
-import { TrinoSqlParser, ProgramContext } from '../../lib/trinosql/TrinoSqlParser';
-import BasicParser from '../common/basicParser';
-import { Suggestions, EntityContextType, SyntaxSuggestion } from '../common/basic-parser-types';
+import { TrinoSqlLexer } from '../../lib/trino/TrinoSqlLexer';
+import { TrinoSqlParser, ProgramContext } from '../../lib/trino/TrinoSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions, EntityContextType, SyntaxSuggestion } from '../common/types';
 import { StmtContextType } from '../common/entityCollector';
-import TrinoSqlSplitListener from './trinoSplitListener';
-import TrinoEntityCollector from './trinoEntityCollector';
+import { TrinoSqlSplitListener } from './trinoSplitListener';
+import { TrinoEntityCollector } from './trinoEntityCollector';
 
 export { TrinoSqlSplitListener, TrinoEntityCollector };
 
-export default class TrinoSQL extends BasicParser<TrinoSqlLexer, ProgramContext, TrinoSqlParser> {
+export class TrinoSQL extends BasicSQL<TrinoSqlLexer, ProgramContext, TrinoSqlParser> {
     protected createLexerFromCharStream(charStreams) {
-        const lexer = new TrinoSqlLexer(charStreams);
-        return lexer;
+        return new TrinoSqlLexer(charStreams);
     }
 
     protected createParserFromTokenStream(tokenStream) {
-        const parser = new TrinoSqlParser(tokenStream);
-        return parser;
+        return new TrinoSqlParser(tokenStream);
     }
 
     protected get splitListener() {

src/parser/trino/trinoEntityCollector.ts

@@ -14,12 +14,12 @@ import type {
     TableNameCreateContext,
     ViewNameContext,
     ViewNameCreateContext,
-} from '../../lib/trinosql/TrinoSqlParser';
-import type { TrinoSqlListener } from '../../lib/trinosql/TrinoSqlListener';
-import { EntityContextType } from '../common/basic-parser-types';
-import EntityCollector, { StmtContextType } from '../common/entityCollector';
+} from '../../lib/trino/TrinoSqlParser';
+import type { TrinoSqlListener } from '../../lib/trino/TrinoSqlListener';
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
 
-export default class TrinoEntityCollector extends EntityCollector implements TrinoSqlListener {
+export class TrinoEntityCollector extends EntityCollector implements TrinoSqlListener {
     /** ====== Entity Begin */
     exitSchemaName(ctx: SchemaNameContext) {
         this.pushEntity(ctx, EntityContextType.DATABASE);

src/parser/trino/trinoSplitListener.ts

@@ -1,12 +1,12 @@
-import { SingleStatementContext } from '../../lib/trinosql/TrinoSqlParser';
-import { TrinoSqlListener } from '../../lib/trinosql/TrinoSqlListener';
-import SplitListener from '../common/splitListener';
+import { SingleStatementContext } from '../../lib/trino/TrinoSqlParser';
+import { TrinoSqlListener } from '../../lib/trino/TrinoSqlListener';
+import { SplitListener } from '../common/splitListener';
 
-export default class TrinoSqlSplitListener
+export class TrinoSqlSplitListener
     extends SplitListener<SingleStatementContext>
     implements TrinoSqlListener
 {
-    exitSingleStatement = (ctx: SingleStatementContext) => {
+    exitSingleStatement(ctx: SingleStatementContext) {
         this._statementsContext.push(ctx);
-    };
+    }
 }