@guanmingchiu/sqlparser-ts 0.60.0-rc3

package/README.md

@@ -0,0 +1,89 @@
+# sqlparser-ts
+
+[![npm version](https://img.shields.io/npm/v/@guanmingchiu/sqlparser-ts.svg)](https://www.npmjs.com/package/@guanmingchiu/sqlparser-ts)
+[![npm downloads](https://img.shields.io/npm/dm/@guanmingchiu/sqlparser-ts.svg)](https://www.npmjs.com/package/@guanmingchiu/sqlparser-ts)
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+[![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)
+
+SQL parser for JavaScript and TypeScript, powered by [datafusion-sqlparser-rs](https://github.com/apache/datafusion-sqlparser-rs) via WebAssembly.
+
+## Features
+
+- 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
+
+```bash
+npm install @guanmingchiu/sqlparser-ts
+```
+
+## Usage
+
+```typescript
+import { parse, format, validate } from '@guanmingchiu/sqlparser-ts';
+
+// Parse SQL into AST
+const ast = parse('SELECT * FROM users');
+
+// With specific dialect
+const ast = parse('SELECT * FROM users WHERE id = $1', 'postgresql');
+
+// Format SQL
+const sql = format('select   *   from   users');
+// "SELECT * FROM users"
+
+// Validate SQL (throws on invalid)
+validate('SELECT * FROM users'); // ok
+```
+
+### Working with AST
+
+```typescript
+// 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
+try {
+  parse('SELEC * FORM users');
+} catch (e) {
+  console.error(e.message); // Parse error details
+}
+```
+
+## Supported Dialects
+
+`generic`, `ansi`, `mysql`, `postgresql`, `sqlite`, `snowflake`, `redshift`, `mssql`, `clickhouse`, `bigquery`, `duckdb`, `databricks`, `hive`, `oracle`
+
+## Versioning
+
+Follows [Semantic Versioning](https://semver.org/) with upstream tracking:
+
+- MAJOR.MINOR: Tracks upstream [datafusion-sqlparser-rs](https://github.com/apache/datafusion-sqlparser-rs)
+- PATCH: sqlparser-ts specific releases
+
+Example: `0.60.4` = upstream 0.60 + 4 sqlparser-ts releases
+
+## License
+
+Apache-2.0

package/dist/index.cjs

@@ -0,0 +1,403 @@
+
+//#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 (case-insensitive) */
+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/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(\"@guanmingchiu/sqlparser-ts\").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", 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({ 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 {
+		wasmModule = await import(
+			/* @vite-ignore */
+			new URL("../wasm/sqlparser_rs_wasm.js", require("url").pathToFileURL(__filename).href).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 AST
+*
+* @example
+* ```typescript
+* import { Parser, PostgreSqlDialect } from '@guanmingchiu/sqlparser-ts';
+*
+* const statements = Parser.parse('SELECT * FROM users', 'postgresql');
+*
+* // With options
+* const parser = new Parser(new PostgreSqlDialect())
+*   .withOptions({ trailingCommas: true });
+* const ast = parser.parse('SELECT a, b, FROM users');
+* ```
+*/
+var Parser = class Parser {
+	constructor(dialect = new GenericDialect()) {
+		this.dialect = dialect;
+		this.options = {};
+	}
+	/** Set recursion limit for parsing nested expressions */
+	withRecursionLimit(limit) {
+		this.options.recursionLimit = limit;
+		return this;
+	}
+	/** Set parser options */
+	withOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		return this;
+	}
+	/** 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);
+			return wasm.parse_sql(this.dialect.name, sql);
+		} catch (error) {
+			throw ParserError.fromWasmError(error);
+		}
+	}
+	/** Parse SQL into AST */
+	static parse(sql, dialect = "generic") {
+		return new Parser(resolveDialect(dialect)).parse(sql);
+	}
+	/** Parse SQL and return AST as JSON string */
+	static parseToJson(sql, dialect = "generic") {
+		const wasm = getWasmModule();
+		try {
+			return wasm.parse_sql_to_json_string(resolveDialect(dialect).name, sql);
+		} catch (error) {
+			throw ParserError.fromWasmError(error);
+		}
+	}
+	/** Parse SQL and return formatted string representation */
+	static parseToString(sql, dialect = "generic") {
+		const wasm = getWasmModule();
+		try {
+			return wasm.parse_sql_to_string(resolveDialect(dialect).name, sql);
+		} catch (error) {
+			throw ParserError.fromWasmError(error);
+		}
+	}
+	/** Format SQL by parsing and regenerating it */
+	static format(sql, dialect = "generic") {
+		const wasm = getWasmModule();
+		try {
+			return wasm.format_sql(resolveDialect(dialect).name, sql);
+		} catch (error) {
+			throw ParserError.fromWasmError(error);
+		}
+	}
+	/**
+	* Validate SQL syntax
+	* @throws ParserError if SQL is invalid
+	*/
+	static validate(sql, dialect = "generic") {
+		const wasm = getWasmModule();
+		try {
+			return wasm.validate_sql(resolveDialect(dialect).name, sql);
+		} catch (error) {
+			throw ParserError.fromWasmError(error);
+		}
+	}
+	/** 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
+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.format = format;
+exports.initWasm = initWasm;
+exports.parse = parse;
+exports.ready = ready;
+exports.validate = validate;