rawsql-ts 0.1.1-beta.1 → 0.1.1-beta.3

package/dist/esm/types/parsers/IdentifierParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class IdentifierParser {
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/JoinClauseParser.d.ts

@@ -0,0 +1,14 @@
+import { JoinClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class JoinClauseParser {
+    static tryParse(lexemes: Lexeme[], index: number): {
+        value: JoinClause[];
+        newIndex: number;
+    } | null;
+    private static isJoinKeyword;
+    private static parseLateral;
+    private static isJoinCommand;
+    private static parseJoinClause;
+    private static tryParseJoinOn;
+    private static tryParseJoinUsing;
+}

package/dist/esm/types/parsers/KeywordParser.d.ts

@@ -0,0 +1,17 @@
+import { KeywordTrie } from "../models/KeywordTrie";
+export declare enum KeywordMatchResult {
+    NotAKeyword = 0,// "Not recognized as a keyword"
+    PartialOnly = 1,// "Partial match (this will not be the end)"
+    PartialOrFinal = 2,// "Partial or complete match (it can stop here)"
+    Final = 3
+}
+export declare class KeywordParser {
+    private trie;
+    constructor(trie: KeywordTrie);
+    private isEndOfInput;
+    private canParse;
+    parse(input: string, position: number): {
+        keyword: string;
+        newPosition: number;
+    } | null;
+}

package/dist/esm/types/parsers/LimitClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { LimitClause as LimitClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class LimitClauseParser {
+    static parse(query: string): LimitClause;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: LimitClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/LiteralParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class LiteralParser {
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/OrderByClauseParser.d.ts

@@ -0,0 +1,10 @@
+import { OrderByClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class OrderByClauseParser {
+    static parse(query: string): OrderByClause;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: OrderByClause;
+        newIndex: number;
+    };
+    private static parseItem;
+}

package/dist/esm/types/parsers/OverExpressionParser.d.ts

@@ -0,0 +1,9 @@
+import { Lexeme } from "../models/Lexeme";
+import { OverExpression } from "../models/ValueComponent";
+export declare class OverExpressionParser {
+    static parse(query: string): OverExpression;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: OverExpression;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/ParameterExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class ParameterExpressionParser {
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/ParenExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class ParenExpressionParser {
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/PartitionByParser.d.ts

@@ -0,0 +1,9 @@
+import { PartitionByClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class PartitionByParser {
+    static parse(query: string): PartitionByClause;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: PartitionByClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/SelectClauseParser.d.ts

@@ -0,0 +1,10 @@
+import { SelectClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class SelectClauseParser {
+    static parse(query: string): SelectClause;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: SelectClause;
+        newIndex: number;
+    };
+    private static parseItem;
+}

package/dist/esm/types/parsers/SelectQueryParser.d.ts

@@ -0,0 +1,13 @@
+import { Lexeme } from "../models/Lexeme";
+import { SelectQuery } from "../models/SelectQuery";
+export declare class SelectQueryParser {
+    static parse(query: string): SelectQuery;
+    private static unionCommandSet;
+    private static selectCommandSet;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: SelectQuery;
+        newIndex: number;
+    };
+    private static parseSimpleSelectQuery;
+    private static parseValuesQuery;
+}

package/dist/esm/types/parsers/SourceAliasExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { SourceAliasExpression } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class SourceAliasExpressionParser {
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: SourceAliasExpression;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/SourceExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { SourceExpression } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class SourceExpressionParser {
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: SourceExpression;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/SourceParser.d.ts

@@ -0,0 +1,13 @@
+import { SourceComponent } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class SourceParser {
+    static parse(query: string): SourceComponent;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: SourceComponent;
+        newIndex: number;
+    };
+    private static parseTableSource;
+    private static parseFunctionSource;
+    private static parseParenSource;
+    private static parseSubQuerySource;
+}

package/dist/esm/types/parsers/SqlTokenizer.d.ts

@@ -0,0 +1,64 @@
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Class responsible for tokenizing SQL input.
+ */
+export declare class SqlTokenizer {
+    /**
+     * The input SQL string to be tokenized.
+     */
+    private input;
+    /**
+     * Current position within the input string.
+     */
+    private position;
+    /**
+     * Manager responsible for handling token readers.
+     */
+    private readerManager;
+    /**
+     * Initializes a new instance of the SqlTokenizer.
+     */
+    constructor(input: string);
+    /**
+     * Checks if the end of input is reached.
+     *
+     * @param shift - The shift to consider beyond the current position.
+     * @returns True if the end of input is reached; otherwise, false.
+     */
+    private isEndOfInput;
+    /**
+     * Checks if more input can be read.
+     *
+     * @param shift - The shift to consider beyond the current position.
+     * @returns True if more input can be read; otherwise, false.
+     */
+    private canRead;
+    /**
+     * Reads the lexemes from the input string.
+     *
+     * @returns An array of lexemes extracted from the input string.
+     * @throws Error if an unexpected character is encountered.
+     */
+    readLexmes(): Lexeme[];
+    /**
+     * Adds pending comments to the last token.
+     */
+    private addPendingCommentsToLastToken;
+    /**
+     * Adds comments to the token.
+     */
+    private addCommentsToToken;
+    /**
+     * Skips whitespace characters and SQL comments in the input.
+     *
+     * @remarks This method updates the position pointer.
+     */
+    private readComment;
+    /**
+     * Gets debug information for error reporting.
+     *
+     * @param errPosition - The position where the error occurred.
+     * @returns A string containing the debug position information.
+     */
+    private getDebugPositionInfo;
+}

package/dist/esm/types/parsers/StringSpecifierExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class StringSpecifierExpressionParser {
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/UnaryExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class UnaryExpressionParser {
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/ValueParser.d.ts

@@ -0,0 +1,14 @@
+import { Lexeme, TokenType } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class ValueParser {
+    static parse(query: string): ValueComponent;
+    static parseFromLexeme(lexemes: Lexeme[], index: number, allowAndOperator?: boolean): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+    private static parseItem;
+    static parseArgument(openToken: TokenType, closeToken: TokenType, lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/ValuesQueryParser.d.ts

@@ -0,0 +1,10 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValuesQuery } from "../models/SelectQuery";
+export declare class ValuesQueryParser {
+    static parse(query: string): ValuesQuery;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: ValuesQuery;
+        newIndex: number;
+    };
+    private static parseTuple;
+}

package/dist/esm/types/parsers/WhereClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { WhereClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class WhereClauseParser {
+    static parse(query: string): WhereClause;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: WhereClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/WindowClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { WindowFrameClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class WindowClauseParser {
+    static parse(query: string): WindowFrameClause;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: WindowFrameClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/WindowExpressionParser.d.ts

@@ -0,0 +1,12 @@
+import { Lexeme } from "../models/Lexeme";
+import { WindowFrameExpression } from "../models/ValueComponent";
+export declare class WindowExpressionParser {
+    static parse(query: string): WindowFrameExpression;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: WindowFrameExpression;
+        newIndex: number;
+    };
+    private static isFrameTypeKeyword;
+    private static parseFrameSpec;
+    private static parseFrameBoundary;
+}

package/dist/esm/types/parsers/WithClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { WithClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class WithClauseParser {
+    static parse(query: string): WithClause;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: WithClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/tokenReaders/BaseTokenReader.d.ts

@@ -0,0 +1,43 @@
+import { Lexeme, TokenType } from '../models/Lexeme';
+/**
+ * Base class for token readers
+ */
+export declare abstract class BaseTokenReader {
+    protected input: string;
+    protected position: number;
+    constructor(input: string, position?: number);
+    /**
+     * Get the current position in the input
+     */
+    getPosition(): number;
+    /**
+     * Set the position in the input
+     */
+    setPosition(position: number): void;
+    /**
+     * Check if we've reached the end of input
+     */
+    protected isEndOfInput(shift?: number): boolean;
+    /**
+     * Check if we can read more characters
+     */
+    protected canRead(shift?: number): boolean;
+    /**
+     * Read an expected character
+     */
+    protected read(expectChar: string): string;
+    /**
+     * Create a lexeme with the specified type and value
+     */
+    protected createLexeme(type: TokenType, value: string, maybeType?: boolean | null, comments?: string[] | null): Lexeme;
+    /**
+     * Get debug info for error reporting
+     */
+    protected getDebugPositionInfo(errPosition: number): string;
+    /**
+     * Try to read a token from the current position
+     * @param previous The previous token, if available
+     * @returns The read token or null if no token could be read
+     */
+    abstract tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/esm/types/tokenReaders/CommandTokenReader.d.ts

@@ -0,0 +1,7 @@
+import { BaseTokenReader } from "./BaseTokenReader";
+import { Lexeme } from '../models/Lexeme';
+import { KeywordParser } from "../parsers/KeywordParser";
+export declare const joinkeywordParser: KeywordParser;
+export declare class CommandTokenReader extends BaseTokenReader {
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/esm/types/tokenReaders/FunctionTokenReader.d.ts

@@ -0,0 +1,11 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Reads SQL identifier tokens
+ */
+export declare class FunctionTokenReader extends BaseTokenReader {
+    /**
+     * Try to read an identifier token
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/esm/types/tokenReaders/IdentifierTokenReader.d.ts

@@ -0,0 +1,15 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Reads SQL identifier tokens
+ */
+export declare class IdentifierTokenReader extends BaseTokenReader {
+    /**
+     * Try to read an identifier token
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+    /**
+     * Read an escaped identifier (surrounded by delimiters)
+     */
+    private readEscapedIdentifier;
+}

package/dist/esm/types/tokenReaders/LiteralTokenReader.d.ts

@@ -0,0 +1,23 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+import { KeywordParser } from '../parsers/KeywordParser';
+export declare const literalKeywordParser: KeywordParser;
+export declare class LiteralTokenReader extends BaseTokenReader {
+    /**
+     * Try to read a literal token
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+    private tryReadKeyword;
+    /**
+     * Check if the current context allows for a signed number
+     */
+    private isValidNumericPrefix;
+    /**
+     * Read a numeric value
+     */
+    private readDigit;
+    /**
+     * Read a string literal
+     */
+    private readSingleQuotedString;
+}

package/dist/esm/types/tokenReaders/OperatorTokenReader.d.ts

@@ -0,0 +1,5 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+export declare class OperatorTokenReader extends BaseTokenReader {
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/esm/types/tokenReaders/ParameterTokenReader.d.ts

@@ -0,0 +1,11 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Reads SQL parameter tokens (@param, :param, $param, ?)
+ */
+export declare class ParameterTokenReader extends BaseTokenReader {
+    /**
+     * Try to read a parameter token
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/esm/types/tokenReaders/StringSpecifierTokenReader.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from '../models/Lexeme';
+import { BaseTokenReader } from './BaseTokenReader';
+export declare class StringSpecifierTokenReader extends BaseTokenReader {
+    /**
+     * Try to read an escaped literal like e'...', x'...', etc.
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/esm/types/tokenReaders/SymbolTokenReader.d.ts

@@ -0,0 +1,12 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Reads SQL symbol tokens (., ,, (, ))
+ */
+export declare class SpecialSymbolTokenReader extends BaseTokenReader {
+    private static readonly SPECIAL_SYMBOL_TOKENS;
+    /**
+     * Try to read a symbol token
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/esm/types/tokenReaders/TokenReaderManager.d.ts

@@ -0,0 +1,53 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Manages and coordinates multiple token readers
+ */
+export declare class TokenReaderManager {
+    private readers;
+    private input;
+    private position;
+    private tokenCache;
+    private cacheHits;
+    private cacheMisses;
+    constructor(input: string, position?: number);
+    /**
+     * Register a token reader
+     * @param reader The reader to register
+     * @returns This manager instance for chaining
+     */
+    register(reader: BaseTokenReader): TokenReaderManager;
+    /**
+     * Register multiple token readers
+     * @param readers The readers to register
+     * @returns This manager instance for chaining
+     */
+    registerAll(readers: BaseTokenReader[]): TokenReaderManager;
+    /**
+     * Update the position for all readers
+     */
+    private setPosition;
+    /**
+     * Try to read a token using all registered readers
+     * @param position The position to read from
+     * @param previous The previous token, if any
+     * @returns The lexeme if a reader could read it, null otherwise
+     */
+    tryRead(position: number, previous: Lexeme | null): Lexeme | null;
+    /**
+     * Get the maximum position among all readers
+     */
+    getMaxPosition(): number;
+    /**
+     * Get the input string
+     */
+    getInput(): string;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        hits: number;
+        misses: number;
+        ratio: number;
+    };
+}

package/dist/esm/types/tokenReaders/TypeTokenReader.d.ts

@@ -0,0 +1,11 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Reads SQL identifier tokens
+ */
+export declare class TypeTokenReader extends BaseTokenReader {
+    /**
+     * Try to read an identifier token
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/esm/types/transformers/CTEBuilder.d.ts

@@ -0,0 +1,52 @@
+import { CommonTable, WithClause } from "../models/Clause";
+/**
+ * CTENameConflictResolver is responsible for resolving name conflicts among Common Table Expressions (CTEs).
+ * It also sorts the tables in the proper order based on dependencies and recursiveness.
+ */
+export declare class CTEBuilder {
+    private sourceCollector;
+    private cteCollector;
+    private formatter;
+    constructor();
+    /**
+     * Resolves name conflicts among CommonTables.
+     * If there are duplicate CTE names, they must have identical definitions.
+     * Also sorts the tables so that:
+     * 1. Recursive CTEs come first (CTEs that reference themselves)
+     * 2. Then remaining tables are sorted so inner (deeper) CTEs come before outer CTEs
+     *
+     * @param commonTables The list of CommonTables to check for name conflicts
+     * @returns An object containing:
+     *          - needRecursive: boolean indicating if any recursive CTEs are present
+     *          - commonTables: A new list of CommonTables with resolved name conflicts and proper order
+     * @throws Error if there are duplicate CTE names with different definitions
+     */
+    build(commonTables: CommonTable[]): WithClause;
+    /**
+     * Resolves duplicate CTE names by checking if they have identical definitions.
+     * If definitions differ, throws an error.
+     *
+     * @param commonTables The list of CTEs to check for duplicates
+     * @returns A list of CTEs with duplicates removed
+     * @throws Error if there are duplicate CTE names with different definitions
+     */
+    private resolveDuplicateNames;
+    /**
+     * Builds a dependency graph of CTEs and identifies recursive CTEs.
+     *
+     * @param tables The list of CTEs to analyze
+     * @returns Object containing the table map, set of recursive CTEs, and dependency map
+     */
+    private buildDependencyGraph;
+    /**
+     * Sorts the CTEs using topological sort, with recursive CTEs coming first.
+     *
+     * @param tables The list of CTEs to sort
+     * @param tableMap Map of table names to their CommonTable objects
+     * @param recursiveCTEs Set of table names that are recursive (self-referential)
+     * @param dependencies Map of table dependencies
+     * @returns Sorted list of CTEs
+     * @throws Error if a circular reference is detected
+     */
+    private sortCommonTables;
+}