sqlparser-rs 0.60.1 → 0.60.3-rc1

package/README.md

@@ -14,7 +14,6 @@ A SQL parser for JavaScript and TypeScript, powered by [datafusion-sqlparser-rs]
 - Parse SQL into a detailed Abstract Syntax Tree (AST)
 - Support for 13+ SQL dialects (PostgreSQL, MySQL, SQLite, BigQuery, etc.)
 - Full TypeScript type definitions
-- Works in Node.js and browsers
 - Fast and accurate parsing using the battle-tested Rust implementation
 - Zero native dependencies
 
@@ -30,22 +29,22 @@ npm install sqlparser-rs
 import { Parser, GenericDialect, PostgreSqlDialect } from 'sqlparser-rs';
 
 // Simple parsing
-const statements = await Parser.parse('SELECT * FROM users', new GenericDialect());
+const statements = Parser.parse('SELECT * FROM users', new GenericDialect());
 console.log(statements);
 
 // With specific dialect
-const pgStatements = await Parser.parse(
+const pgStatements = Parser.parse(
   'SELECT * FROM users WHERE id = $1',
   new PostgreSqlDialect()
 );
 
 // Format SQL
-const formatted = await Parser.format('select   *   from   users', new GenericDialect());
+const formatted = Parser.format('select   *   from   users', new GenericDialect());
 console.log(formatted); // "SELECT * FROM users"
 
 // Validate SQL
 try {
-  await Parser.validate('SELEC * FROM users', new GenericDialect());
+  Parser.validate('SELEC * FROM users', new GenericDialect());
 } catch (error) {
   console.log('Invalid SQL:', error.message);
 }
@@ -61,22 +60,22 @@ The main class for parsing SQL.
 
 ```typescript
 // Parse SQL into statements
-const statements = await Parser.parse(sql: string, dialect: Dialect): Promise<Statement[]>;
+const statements = Parser.parse(sql: string, dialect: Dialect): Statement[];
 
 // Parse and return JSON string
-const json = await Parser.parseToJson(sql: string, dialect: Dialect): Promise<string>;
+const json = Parser.parseToJson(sql: string, dialect: Dialect): string;
 
 // Parse and return formatted SQL string
-const formatted = await Parser.parseToString(sql: string, dialect: Dialect): Promise<string>;
+const formatted = Parser.parseToString(sql: string, dialect: Dialect): string;
 
 // Format SQL (round-trip through parser)
-const formatted = await Parser.format(sql: string, dialect: Dialect): Promise<string>;
+const formatted = Parser.format(sql: string, dialect: Dialect): string;
 
 // Validate SQL syntax
-const isValid = await Parser.validate(sql: string, dialect: Dialect): Promise<boolean>;
+const isValid = Parser.validate(sql: string, dialect: Dialect): boolean;
 
 // Get list of supported dialects
-const dialects = await Parser.getSupportedDialects(): Promise<string[]>;
+const dialects = Parser.getSupportedDialects(): string[];
 ```
 
 #### Instance Methods (Builder Pattern)
@@ -90,13 +89,7 @@ const parser = new Parser(new PostgreSqlDialect())
     trailingCommas: true
   });
 
-// Parse asynchronously
-const statements = await parser.parseAsync('SELECT * FROM users');
-
-// Parse synchronously (requires initWasm() first)
-import { initWasm } from 'sqlparser-rs';
-await initWasm();
-const statements = parser.parseSync('SELECT * FROM users');
+const statements = parser.parse('SELECT * FROM users');
 ```
 
 ### Dialects
@@ -131,7 +124,7 @@ const dialect = dialectFromString('postgresql'); // Returns PostgreSqlDialect in
 import { Parser, GenericDialect, ParserError } from 'sqlparser-rs';
 
 try {
-  await Parser.parse('SELEC * FROM users', new GenericDialect());
+  Parser.parse('SELEC * FROM users', new GenericDialect());
 } catch (error) {
   if (error instanceof ParserError) {
     console.log('Parse error:', error.message);
@@ -149,7 +142,7 @@ Full TypeScript types are provided for the AST:
 ```typescript
 import type { Statement, Query, Expr, Ident, ObjectName } from 'sqlparser-rs';
 
-const statements: Statement[] = await Parser.parse('SELECT 1', new GenericDialect());
+const statements: Statement[] = Parser.parse('SELECT 1', new GenericDialect());
 
 // Statement is a discriminated union type
 for (const stmt of statements) {
@@ -198,7 +191,7 @@ npm test
 This package follows the upstream [sqlparser-rs](https://github.com/apache/datafusion-sqlparser-rs) version:
 
 - **Major.Minor** matches the upstream Rust crate version
-- **Patch** is for TypeScript binding fixes (e.g., `0.60.1` = upstream `0.60.0` + binding fix)
+- **Patch** is for TypeScript binding fixes (e.g., `0.60.3-rc1` = upstream `0.60.0` + binding fix)
 
 | This package | sqlparser-rs |
 |--------------|--------------|

package/dist/index.cjs

@@ -0,0 +1,441 @@
+
+//#region src/dialects.ts
+/**
+* Generic SQL dialect - accepts most SQL syntax
+*/
+var GenericDialect = class {
+	constructor() {
+		this.name = "generic";
+	}
+};
+/**
+* ANSI SQL standard dialect
+*/
+var AnsiDialect = class {
+	constructor() {
+		this.name = "ansi";
+	}
+};
+/**
+* MySQL dialect
+*/
+var MySqlDialect = class {
+	constructor() {
+		this.name = "mysql";
+	}
+};
+/**
+* PostgreSQL dialect
+*/
+var PostgreSqlDialect = class {
+	constructor() {
+		this.name = "postgresql";
+	}
+};
+/**
+* SQLite dialect
+*/
+var SQLiteDialect = class {
+	constructor() {
+		this.name = "sqlite";
+	}
+};
+/**
+* Snowflake dialect
+*/
+var SnowflakeDialect = class {
+	constructor() {
+		this.name = "snowflake";
+	}
+};
+/**
+* Amazon Redshift dialect
+*/
+var RedshiftDialect = class {
+	constructor() {
+		this.name = "redshift";
+	}
+};
+/**
+* Microsoft SQL Server dialect
+*/
+var MsSqlDialect = class {
+	constructor() {
+		this.name = "mssql";
+	}
+};
+/**
+* ClickHouse dialect
+*/
+var ClickHouseDialect = class {
+	constructor() {
+		this.name = "clickhouse";
+	}
+};
+/**
+* Google BigQuery dialect
+*/
+var BigQueryDialect = class {
+	constructor() {
+		this.name = "bigquery";
+	}
+};
+/**
+* DuckDB dialect
+*/
+var DuckDbDialect = class {
+	constructor() {
+		this.name = "duckdb";
+	}
+};
+/**
+* Databricks dialect
+*/
+var DatabricksDialect = class {
+	constructor() {
+		this.name = "databricks";
+	}
+};
+/**
+* Apache Hive dialect
+*/
+var HiveDialect = class {
+	constructor() {
+		this.name = "hive";
+	}
+};
+/**
+* Oracle dialect
+*/
+var OracleDialect = class {
+	constructor() {
+		this.name = "oracle";
+	}
+};
+/**
+* All supported dialect names
+*/
+const SUPPORTED_DIALECTS = [
+	"generic",
+	"ansi",
+	"mysql",
+	"postgresql",
+	"sqlite",
+	"snowflake",
+	"redshift",
+	"mssql",
+	"clickhouse",
+	"bigquery",
+	"duckdb",
+	"databricks",
+	"hive",
+	"oracle"
+];
+/**
+* Map of dialect names to dialect classes
+*/
+const DIALECT_MAP = {
+	generic: GenericDialect,
+	ansi: AnsiDialect,
+	mysql: MySqlDialect,
+	postgresql: PostgreSqlDialect,
+	sqlite: SQLiteDialect,
+	snowflake: SnowflakeDialect,
+	redshift: RedshiftDialect,
+	mssql: MsSqlDialect,
+	clickhouse: ClickHouseDialect,
+	bigquery: BigQueryDialect,
+	duckdb: DuckDbDialect,
+	databricks: DatabricksDialect,
+	hive: HiveDialect,
+	oracle: OracleDialect
+};
+/**
+* Create a dialect instance from a string name
+*
+* @param name - The name of the dialect (case-insensitive)
+* @returns A dialect instance, or undefined if the dialect is not recognized
+*
+* @example
+* ```typescript
+* const dialect = dialectFromString('postgresql');
+* if (dialect) {
+*   const ast = Parser.parse('SELECT 1', dialect);
+* }
+* ```
+*/
+function dialectFromString(name) {
+	const normalized = name.toLowerCase();
+	const DialectClass = DIALECT_MAP[{
+		postgres: "postgresql",
+		pg: "postgresql",
+		sqlserver: "mssql",
+		duck: "duckdb"
+	}[normalized] ?? normalized];
+	return DialectClass ? new DialectClass() : void 0;
+}
+
+//#endregion
+//#region src/types/errors.ts
+/**
+* Error thrown when SQL parsing fails
+*/
+var ParserError = class ParserError extends Error {
+	constructor(message, location) {
+		super(message);
+		this.name = "ParserError";
+		this.location = location;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, ParserError);
+	}
+	/**
+	* Create a ParserError from a WASM error object
+	*/
+	static fromWasmError(error) {
+		if (typeof error === "string") return new ParserError(error);
+		if (error && typeof error === "object") {
+			const err = error;
+			return new ParserError(typeof err.message === "string" ? err.message : String(error), typeof err.line === "number" && typeof err.column === "number" ? {
+				line: err.line,
+				column: err.column
+			} : void 0);
+		}
+		return new ParserError(String(error));
+	}
+};
+/**
+* Error thrown when WASM module fails to initialize
+*/
+var WasmInitError = class WasmInitError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "WasmInitError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, WasmInitError);
+	}
+};
+
+//#endregion
+//#region src/parser.ts
+let wasmModule = null;
+const isBrowser = typeof window !== "undefined" || typeof self !== "undefined";
+function getWasmModule() {
+	if (wasmModule) return wasmModule;
+	if (isBrowser) throw new WasmInitError("WASM module not initialized. Call initWasm() first in browser environments.");
+	try {
+		const nodeRequire = (0, eval)("require");
+		const nodeModule = nodeRequire("node:module");
+		const nodeUrl = nodeRequire("node:url");
+		const nodePath = nodeRequire("node:path");
+		const currentDir = nodePath.dirname(nodeUrl.fileURLToPath(require("url").pathToFileURL(__filename).href));
+		const wasmPath = nodePath.join(currentDir, "../wasm/sqlparser_rs_wasm.js");
+		wasmModule = nodeModule.createRequire(require("url").pathToFileURL(__filename).href)(wasmPath);
+		return wasmModule;
+	} catch (error) {
+		throw new WasmInitError(`Failed to load WASM module: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
+* Initialize the WASM module for browser environments.
+* This must be called before using the Parser in browsers.
+*
+* @example
+* ```typescript
+* import { initWasm, Parser, GenericDialect } from 'sqlparser-rs';
+*
+* // In browser, initialize first
+* await initWasm();
+*
+* // Then use the parser
+* const ast = Parser.parse('SELECT 1', new GenericDialect());
+* ```
+*/
+async function initWasm() {
+	if (wasmModule) return;
+	if (!isBrowser) {
+		getWasmModule();
+		return;
+	}
+	try {
+		const wasmJsUrl = new URL("../wasm/sqlparser_rs_wasm_web.js", require("url").pathToFileURL(__filename).href);
+		const wasmBinaryUrl = new URL("../wasm/sqlparser_rs_wasm_web_bg.wasm", require("url").pathToFileURL(__filename).href);
+		const wasm = await import(
+			/* @vite-ignore */
+			wasmJsUrl.href
+);
+		if (typeof wasm.default === "function") await wasm.default(wasmBinaryUrl);
+		wasmModule = wasm;
+	} catch (error) {
+		throw new WasmInitError(`Failed to load WASM module in browser: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
+* SQL Parser
+*
+* Parses SQL statements into an Abstract Syntax Tree (AST).
+*
+* @example
+* ```typescript
+* import { Parser, PostgreSqlDialect } from 'sqlparser-rs';
+*
+* // Simple parsing
+* const statements = Parser.parse('SELECT * FROM users', new PostgreSqlDialect());
+*
+* // With builder pattern
+* const parser = new Parser(new PostgreSqlDialect())
+*   .withRecursionLimit(50)
+*   .withOptions({ trailingCommas: true });
+*
+* const ast = parser.parse('SELECT * FROM users');
+* ```
+*/
+var Parser = class Parser {
+	/**
+	* Create a new parser instance
+	*
+	* @param dialect - The SQL dialect to use (defaults to GenericDialect)
+	*/
+	constructor(dialect = new GenericDialect()) {
+		this.dialect = dialect;
+		this.options = {};
+	}
+	/**
+	* Set the recursion limit for parsing nested expressions
+	*
+	* @param limit - Maximum recursion depth
+	* @returns This parser instance for chaining
+	*/
+	withRecursionLimit(limit) {
+		this.options.recursionLimit = limit;
+		return this;
+	}
+	/**
+	* Set parser options
+	*
+	* @param options - Parser options
+	* @returns This parser instance for chaining
+	*/
+	withOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		return this;
+	}
+	/**
+	* Parse SQL statements
+	*
+	* @param sql - SQL string to parse
+	* @returns Array of parsed statements
+	*/
+	parse(sql) {
+		const wasm = getWasmModule();
+		try {
+			if (Object.keys(this.options).length > 0) return wasm.parse_sql_with_options(this.dialect.name, sql, this.options);
+			else return wasm.parse_sql(this.dialect.name, sql);
+		} catch (error) {
+			throw ParserError.fromWasmError(error);
+		}
+	}
+	/**
+	* Parse SQL statements
+	*
+	* @param sql - SQL string to parse
+	* @param dialect - SQL dialect to use
+	* @returns Array of parsed statements
+	*
+	* @example
+	* ```typescript
+	* const statements = Parser.parse('SELECT 1', new GenericDialect());
+	* ```
+	*/
+	static parse(sql, dialect = new GenericDialect()) {
+		return new Parser(dialect).parse(sql);
+	}
+	/**
+	* Parse SQL and return the AST as a JSON string
+	*
+	* @param sql - SQL string to parse
+	* @param dialect - SQL dialect to use
+	* @returns JSON string representation of the AST
+	*/
+	static parseToJson(sql, dialect = new GenericDialect()) {
+		const wasm = getWasmModule();
+		try {
+			return wasm.parse_sql_to_json_string(dialect.name, sql);
+		} catch (error) {
+			throw ParserError.fromWasmError(error);
+		}
+	}
+	/**
+	* Parse SQL and return a formatted string representation
+	*
+	* @param sql - SQL string to parse
+	* @param dialect - SQL dialect to use
+	* @returns String representation of the parsed SQL
+	*/
+	static parseToString(sql, dialect = new GenericDialect()) {
+		const wasm = getWasmModule();
+		try {
+			return wasm.parse_sql_to_string(dialect.name, sql);
+		} catch (error) {
+			throw ParserError.fromWasmError(error);
+		}
+	}
+	/**
+	* Format SQL by parsing and regenerating it (round-trip)
+	*
+	* @param sql - SQL string to format
+	* @param dialect - SQL dialect to use
+	* @returns Formatted SQL string
+	*/
+	static format(sql, dialect = new GenericDialect()) {
+		const wasm = getWasmModule();
+		try {
+			return wasm.format_sql(dialect.name, sql);
+		} catch (error) {
+			throw ParserError.fromWasmError(error);
+		}
+	}
+	/**
+	* Validate SQL syntax without returning the full AST
+	*
+	* @param sql - SQL string to validate
+	* @param dialect - SQL dialect to use
+	* @returns true if valid, throws ParserError if invalid
+	*/
+	static validate(sql, dialect = new GenericDialect()) {
+		const wasm = getWasmModule();
+		try {
+			return wasm.validate_sql(dialect.name, sql);
+		} catch (error) {
+			throw ParserError.fromWasmError(error);
+		}
+	}
+	/**
+	* Get the list of supported dialect names
+	*/
+	static getSupportedDialects() {
+		return getWasmModule().get_supported_dialects();
+	}
+};
+
+//#endregion
+exports.AnsiDialect = AnsiDialect;
+exports.BigQueryDialect = BigQueryDialect;
+exports.ClickHouseDialect = ClickHouseDialect;
+exports.DatabricksDialect = DatabricksDialect;
+exports.DuckDbDialect = DuckDbDialect;
+exports.GenericDialect = GenericDialect;
+exports.HiveDialect = HiveDialect;
+exports.MsSqlDialect = MsSqlDialect;
+exports.MySqlDialect = MySqlDialect;
+exports.OracleDialect = OracleDialect;
+exports.Parser = Parser;
+exports.ParserError = ParserError;
+exports.PostgreSqlDialect = PostgreSqlDialect;
+exports.RedshiftDialect = RedshiftDialect;
+exports.SQLiteDialect = SQLiteDialect;
+exports.SUPPORTED_DIALECTS = SUPPORTED_DIALECTS;
+exports.SnowflakeDialect = SnowflakeDialect;
+exports.WasmInitError = WasmInitError;
+exports.dialectFromString = dialectFromString;
+exports.initWasm = initWasm;