sqlparser-rs 0.60.3 → 0.60.4

package/dist/index.mjs

@@ -1,7 +1,3 @@
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-
 //#region src/dialects.ts
 /**
 * Generic SQL dialect - accepts most SQL syntax
@@ -153,20 +149,7 @@ const DIALECT_MAP = {
 	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);
-* }
-* ```
-*/
+/** Create a dialect instance from a string name (case-insensitive) */
 function dialectFromString(name) {
 	const normalized = name.toLowerCase();
 	const DialectClass = DIALECT_MAP[{
@@ -217,64 +200,96 @@ var WasmInitError = class WasmInitError extends Error {
 };
 
 //#endregion
-//#region src/parser.ts
+//#region src/wasm.ts
 let wasmModule = null;
+let initPromise = null;
+let initStarted = false;
+const isBrowser = typeof window !== "undefined" && typeof process === "undefined";
+function startInit() {
+	if (initStarted) return;
+	initStarted = true;
+	initPromise = initWasm().catch(() => {});
+}
+startInit();
+/** Get initialized WASM module or throw */
 function getWasmModule() {
 	if (wasmModule) return wasmModule;
+	throw new WasmInitError("WASM module not yet initialized. Use the async import or wait for module to load: import(\"sqlparser-rs\").then(({ parse }) => parse(sql))");
+}
+/**
+* Wait for WASM module to be ready
+*/
+async function ready() {
+	startInit();
+	await initPromise;
+}
+/**
+* Initialize the WASM module explicitly.
+* Usually not needed - the module auto-initializes on first use.
+*/
+async function initWasm() {
+	if (wasmModule) return;
+	if (isBrowser) {
+		try {
+			const wasmJsUrl = new URL("../wasm/sqlparser_rs_wasm_web.js", import.meta.url);
+			const wasmBinaryUrl = new URL("../wasm/sqlparser_rs_wasm_web_bg.wasm", import.meta.url);
+			const wasm = await import(
+				/* @vite-ignore */
+				wasmJsUrl.href
+);
+			if (typeof wasm.default === "function") await wasm.default({ module_or_path: wasmBinaryUrl });
+			wasmModule = wasm;
+		} catch (error) {
+			throw new WasmInitError(`Failed to load WASM module in browser: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		return;
+	}
 	try {
-		const wasmPath = join(dirname(fileURLToPath(import.meta.url)), "../wasm/sqlparser_rs_wasm.js");
-		wasmModule = createRequire(import.meta.url)(wasmPath);
-		return wasmModule;
+		wasmModule = await import(
+			/* @vite-ignore */
+			new URL("../wasm/sqlparser_rs_wasm.js", import.meta.url).href
+);
 	} catch (error) {
 		throw new WasmInitError(`Failed to load WASM module: ${error instanceof Error ? error.message : String(error)}`);
 	}
 }
+
+//#endregion
+//#region src/parser.ts
+function resolveDialect(dialect = "generic") {
+	if (typeof dialect === "string") {
+		const resolved = dialectFromString(dialect);
+		if (!resolved) throw new Error(`Unknown dialect: ${dialect}`);
+		return resolved;
+	}
+	return dialect;
+}
 /**
-* SQL Parser
-*
-* Parses SQL statements into an Abstract Syntax Tree (AST).
+* SQL Parser - parses SQL statements into AST
 *
 * @example
 * ```typescript
 * import { Parser, PostgreSqlDialect } from 'sqlparser-rs';
 *
-* // Simple parsing
-* const statements = Parser.parse('SELECT * FROM users', new PostgreSqlDialect());
+* const statements = Parser.parse('SELECT * FROM users', 'postgresql');
 *
-* // With builder pattern
+* // With options
 * const parser = new Parser(new PostgreSqlDialect())
-*   .withRecursionLimit(50)
 *   .withOptions({ trailingCommas: true });
-*
-* const ast = parser.parse('SELECT * FROM users');
+* const ast = parser.parse('SELECT a, b, 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
-	*/
+	/** Set recursion limit for parsing nested expressions */
 	withRecursionLimit(limit) {
 		this.options.recursionLimit = limit;
 		return this;
 	}
-	/**
-	* Set parser options
-	*
-	* @param options - Parser options
-	* @returns This parser instance for chaining
-	*/
+	/** Set parser options */
 	withOptions(options) {
 		this.options = {
 			...this.options,
@@ -282,103 +297,83 @@ var Parser = class Parser {
 		};
 		return this;
 	}
-	/**
-	* Parse SQL statements
-	*
-	* @param sql - SQL string to parse
-	* @returns Array of parsed statements
-	*/
+	/** Parse SQL 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);
+			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 into AST */
+	static parse(sql, dialect = "generic") {
+		return new Parser(resolveDialect(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()) {
+	/** Parse SQL and return AST as JSON string */
+	static parseToJson(sql, dialect = "generic") {
 		const wasm = getWasmModule();
 		try {
-			return wasm.parse_sql_to_json_string(dialect.name, sql);
+			return wasm.parse_sql_to_json_string(resolveDialect(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()) {
+	/** Parse SQL and return formatted string representation */
+	static parseToString(sql, dialect = "generic") {
 		const wasm = getWasmModule();
 		try {
-			return wasm.parse_sql_to_string(dialect.name, sql);
+			return wasm.parse_sql_to_string(resolveDialect(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()) {
+	/** Format SQL by parsing and regenerating it */
+	static format(sql, dialect = "generic") {
 		const wasm = getWasmModule();
 		try {
-			return wasm.format_sql(dialect.name, sql);
+			return wasm.format_sql(resolveDialect(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
+	* Validate SQL syntax
+	* @throws ParserError if SQL is invalid
 	*/
-	static validate(sql, dialect = new GenericDialect()) {
+	static validate(sql, dialect = "generic") {
 		const wasm = getWasmModule();
 		try {
-			return wasm.validate_sql(dialect.name, sql);
+			return wasm.validate_sql(resolveDialect(dialect).name, sql);
 		} catch (error) {
 			throw ParserError.fromWasmError(error);
 		}
 	}
-	/**
-	* Get the list of supported dialect names
-	*/
+	/** Get list of supported dialect names */
 	static getSupportedDialects() {
 		return getWasmModule().get_supported_dialects();
 	}
 };
+/**
+* Parse SQL into AST
+*/
+function parse(sql, dialect = "generic") {
+	return Parser.parse(sql, dialect);
+}
+/**
+* Validate SQL syntax
+* @throws ParserError if SQL is invalid
+*/
+function validate(sql, dialect = "generic") {
+	return Parser.validate(sql, dialect);
+}
+/**
+* Format SQL by parsing and regenerating it
+*/
+function format(sql, dialect = "generic") {
+	return Parser.format(sql, dialect);
+}
 
 //#endregion
-export { AnsiDialect, BigQueryDialect, ClickHouseDialect, DatabricksDialect, DuckDbDialect, GenericDialect, HiveDialect, MsSqlDialect, MySqlDialect, OracleDialect, Parser, ParserError, PostgreSqlDialect, RedshiftDialect, SQLiteDialect, SUPPORTED_DIALECTS, SnowflakeDialect, WasmInitError, dialectFromString };
+export { AnsiDialect, BigQueryDialect, ClickHouseDialect, DatabricksDialect, DuckDbDialect, GenericDialect, HiveDialect, MsSqlDialect, MySqlDialect, OracleDialect, Parser, ParserError, PostgreSqlDialect, RedshiftDialect, SQLiteDialect, SUPPORTED_DIALECTS, SnowflakeDialect, WasmInitError, dialectFromString, format, initWasm, parse, ready, validate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlparser-rs",
-  "version": "0.60.3",
+  "version": "0.60.4",
   "type": "module",
   "description": "A SQL parser for JavaScript and TypeScript, powered by datafusion-sqlparser-rs via WASM",
   "main": "dist/index.cjs",
@@ -44,7 +44,7 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/guan404ming/sqlparser-rs"
+    "url": "git+https://github.com/guan404ming/sqlparser-rs.git"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",

package/wasm/README.md

@@ -2,8 +2,6 @@
 
 [![npm version](https://img.shields.io/npm/v/sqlparser-rs.svg)](https://www.npmjs.com/package/sqlparser-rs)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
-[![Node.js](https://img.shields.io/badge/Node.js-16+-green.svg)](https://nodejs.org/)
 [![WebAssembly](https://img.shields.io/badge/WebAssembly-powered-blueviolet.svg)](https://webassembly.org/)
 [![sqlparser](https://img.shields.io/badge/sqlparser--rs-v0.60.0-orange.svg)](https://github.com/apache/datafusion-sqlparser-rs)
 
@@ -11,11 +9,11 @@ A SQL parser for JavaScript and TypeScript, powered by [datafusion-sqlparser-rs]
 
 ## Features
 
-- Parse SQL into a detailed Abstract Syntax Tree (AST)
-- Support for 13+ SQL dialects (PostgreSQL, MySQL, SQLite, BigQuery, etc.)
-- Full TypeScript type definitions
-- Fast and accurate parsing using the battle-tested Rust implementation
-- Zero native dependencies
+- Parse SQL into a detailed AST with full TypeScript types
+- Support 14 SQL dialects (PostgreSQL, MySQL, SQLite, BigQuery, and more)
+- Run in Node.js and browsers
+- Stay small (~600KB gzipped) and fast (Rust + WebAssembly)
+- Ship zero native dependencies
 
 ## Installation
 
@@ -23,187 +21,59 @@ A SQL parser for JavaScript and TypeScript, powered by [datafusion-sqlparser-rs]
 npm install sqlparser-rs
 ```
 
-## Quick Start
+## Usage
 
 ```typescript
-import { Parser, GenericDialect, PostgreSqlDialect } from 'sqlparser-rs';
+import { parse, format, validate } from 'sqlparser-rs';
 
-// Simple parsing
-const statements = Parser.parse('SELECT * FROM users', new GenericDialect());
-console.log(statements);
+// Parse SQL into AST
+const ast = parse('SELECT * FROM users');
 
 // With specific dialect
-const pgStatements = Parser.parse(
-  'SELECT * FROM users WHERE id = $1',
-  new PostgreSqlDialect()
-);
+const ast = parse('SELECT * FROM users WHERE id = $1', 'postgresql');
 
 // Format SQL
-const formatted = Parser.format('select   *   from   users', new GenericDialect());
-console.log(formatted); // "SELECT * FROM users"
+const sql = format('select   *   from   users');
+// "SELECT * FROM users"
 
-// Validate SQL
-try {
-  Parser.validate('SELEC * FROM users', new GenericDialect());
-} catch (error) {
-  console.log('Invalid SQL:', error.message);
-}
+// Validate SQL (throws on invalid)
+validate('SELECT * FROM users'); // ok
 ```
 
-## API
-
-### Parser
-
-The main class for parsing SQL.
-
-#### Static Methods
+### Working with AST
 
 ```typescript
-// Parse SQL into statements
-const statements = Parser.parse(sql: string, dialect: Dialect): Statement[];
-
-// Parse and return JSON string
-const json = Parser.parseToJson(sql: string, dialect: Dialect): string;
-
-// Parse and return formatted SQL string
-const formatted = Parser.parseToString(sql: string, dialect: Dialect): string;
-
-// Format SQL (round-trip through parser)
-const formatted = Parser.format(sql: string, dialect: Dialect): string;
-
-// Validate SQL syntax
-const isValid = Parser.validate(sql: string, dialect: Dialect): boolean;
-
-// Get list of supported dialects
-const dialects = Parser.getSupportedDialects(): string[];
-```
-
-#### Instance Methods (Builder Pattern)
-
-```typescript
-import { Parser, PostgreSqlDialect } from 'sqlparser-rs';
-
-const parser = new Parser(new PostgreSqlDialect())
-  .withRecursionLimit(50)      // Set max recursion depth
-  .withOptions({               // Set parser options
-    trailingCommas: true
-  });
-
-const statements = parser.parse('SELECT * FROM users');
-```
-
-### Dialects
-
-All dialects from the upstream Rust crate are supported:
-
-```typescript
-import {
-  GenericDialect,      // Permissive, accepts most SQL syntax
-  AnsiDialect,         // ANSI SQL standard
-  MySqlDialect,        // MySQL
-  PostgreSqlDialect,   // PostgreSQL
-  SQLiteDialect,       // SQLite
-  SnowflakeDialect,    // Snowflake
-  RedshiftDialect,     // Amazon Redshift
-  MsSqlDialect,        // Microsoft SQL Server
-  ClickHouseDialect,   // ClickHouse
-  BigQueryDialect,     // Google BigQuery
-  DuckDbDialect,       // DuckDB
-  DatabricksDialect,   // Databricks
-  HiveDialect,         // Apache Hive
-} from 'sqlparser-rs';
-
-// Create dialect from string
-import { dialectFromString } from 'sqlparser-rs';
-const dialect = dialectFromString('postgresql'); // Returns PostgreSqlDialect instance
+// Parse and inspect
+const ast = parse('SELECT id, name FROM users WHERE active = true');
+console.log(JSON.stringify(ast, null, 2));
+
+// Multiple statements
+const statements = parse(`
+  SELECT * FROM users;
+  SELECT * FROM orders;
+`);
+console.log(statements.length); // 2
+
+// Modify AST and convert back to SQL
+const ast = parse('SELECT * FROM users')[0];
+// ... modify ast ...
+const sql = format(JSON.stringify([ast]));
 ```
 
 ### Error Handling
 
 ```typescript
-import { Parser, GenericDialect, ParserError } from 'sqlparser-rs';
-
 try {
-  Parser.parse('SELEC * FROM users', new GenericDialect());
-} catch (error) {
-  if (error instanceof ParserError) {
-    console.log('Parse error:', error.message);
-    if (error.location) {
-      console.log(`At line ${error.location.line}, column ${error.location.column}`);
-    }
-  }
-}
-```
-
-### AST Types
-
-Full TypeScript types are provided for the AST:
-
-```typescript
-import type { Statement, Query, Expr, Ident, ObjectName } from 'sqlparser-rs';
-
-const statements: Statement[] = Parser.parse('SELECT 1', new GenericDialect());
-
-// Statement is a discriminated union type
-for (const stmt of statements) {
-  if ('Query' in stmt) {
-    const query: Query = stmt.Query;
-    console.log('Found SELECT query');
-  } else if ('Insert' in stmt) {
-    console.log('Found INSERT statement');
-  }
+  parse('SELEC * FORM users');
+} catch (e) {
+  console.error(e.message); // Parse error details
 }
 ```
 
-## Development
-
-### Prerequisites
+## Supported Dialects
 
-- Rust toolchain (1.70+)
-- wasm-pack (`cargo install wasm-pack`)
-- Node.js (16+)
-
-### Build
-
-```bash
-# Build everything
-./scripts/build.sh
-
-# Or step by step:
-# 1. Build WASM
-wasm-pack build --target nodejs --out-dir ts/wasm
-
-# 2. Build TypeScript
-cd ts
-npm install
-npm run build
-```
-
-### Tests
-
-```bash
-cd ts
-npm test
-```
-
-## Versioning
-
-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.3` = upstream `0.60.0` + binding fix)
-
-| This package | sqlparser-rs |
-|--------------|--------------|
-| 0.60.x       | 0.60.0       |
-
-This approach is similar to [esbuild-wasm](https://github.com/evanw/esbuild) and [duckdb-wasm](https://github.com/duckdb/duckdb-wasm).
+`generic`, `ansi`, `mysql`, `postgresql`, `sqlite`, `snowflake`, `redshift`, `mssql`, `clickhouse`, `bigquery`, `duckdb`, `databricks`, `hive`, `oracle`
 
 ## License
 
 Apache-2.0
-
-## Related Projects
-
-- [datafusion-sqlparser-rs](https://github.com/apache/datafusion-sqlparser-rs) - The Rust SQL parser this package wraps
-- [Apache DataFusion](https://github.com/apache/datafusion) - Query execution framework using sqlparser-rs

package/wasm/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sqlparser-rs-wasm",
   "description": "WebAssembly bindings for sqlparser-rs SQL parser",
-  "version": "0.60.3",
+  "version": "0.60.4",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",