libpg-query

hyperweb.io

The Real PostgreSQL Parser for JavaScript

Bring the power of PostgreSQL's native parser to your JavaScript projects — no native builds, no platform headaches.

This is the official PostgreSQL parser, compiled to WebAssembly (WASM) for seamless, cross-platform compatibility. Use it in Node.js or the browser, on Linux, Windows, or anywhere JavaScript runs.

Built to power pgsql-parser, this library delivers full fidelity with the Postgres C codebase — no rewrites, no shortcuts.

Features

🔧 Powered by PostgreSQL – Uses the official Postgres C parser compiled to WebAssembly
🖥️ Cross-Platform – Runs smoothly on macOS, Linux, and Windows
🌐 Node.js & Browser Support – Consistent behavior in any JS environment
📦 No Native Builds Required – No compilation, no system-specific dependencies
🧠 Spec-Accurate Parsing – Produces faithful, standards-compliant ASTs
🚀 Production-Grade – Millions of downloads and trusted by countless projects and top teams

🚀 For Round-trip Codegen

🎯 Want to parse + deparse (full round trip)?
We highly recommend using pgsql-parser which leverages a pure TypeScript deparser that has been battle-tested against 23,000+ SQL statements and is built on top of libpg-query.

🔀 Multi-Version Support with @pgsql/parser

Need to support multiple PostgreSQL versions at runtime?
Use @pgsql/parser for dynamic version selection — parse SQL with PostgreSQL 15, 16, or 17 in a single package!
import { parse } from '@pgsql/parser';

// Parse with specific PostgreSQL version
const result15 = await parse('SELECT * FROM users', 15);
const result17 = await parse('SELECT * FROM users', 17);

Installation

npm install libpg-query

Example

import { parse } from 'libpg-query';

const result = await parse('SELECT * FROM users WHERE active = true');
// {"version":170004,"stmts":[{"stmt":{"SelectStmt":{"targetList":[{"ResTarget" ... "op":"SETOP_NONE"}}}]}

📦 Packages

This repository contains multiple packages to support different PostgreSQL versions and use cases:

Available Packages & Versions

Package	Description	PostgreSQL Versions	npm Package
libpg-query	Lightweight parser (parse only)	13, 14, 15, 16, 17	`libpg-query`
@pgsql/parser	Multi-version parser (runtime selection)	15, 16, 17	`@pgsql/parser`
@pgsql/types	TypeScript type definitions	13, 14, 15, 16, 17	`@pgsql/types`
@pgsql/enums	TypeScript enum definitions	13, 14, 15, 16, 17	`@pgsql/enums`
@libpg-query/parser	Full parser with all features	17 only	`@libpg-query/parser`

Version Tags

Each versioned package uses npm dist-tags for PostgreSQL version selection:

# Install specific PostgreSQL version
npm install libpg-query@pg17      # PostgreSQL 17 (latest)
npm install libpg-query@pg16      # PostgreSQL 16
npm install @pgsql/types@pg17     # Types for PostgreSQL 17
npm install @pgsql/enums@pg15     # Enums for PostgreSQL 15

# Install latest (defaults to pg17)
npm install libpg-query
npm install @pgsql/types
npm install @pgsql/enums

Which Package Should I Use?

Just need to parse SQL? → Use libpg-query (lightweight, all PG versions)
Need multiple versions at runtime? → Use @pgsql/parser (dynamic version selection)
Need TypeScript types? → Add @pgsql/types and/or @pgsql/enums
Need fingerprint, normalize, or deparse? → Use @libpg-query/parser (PG 17 only)

API Documentation

For detailed API documentation and usage examples, see the package-specific READMEs:

libpg-query - Parser API Documentation
@pgsql/parser - Multi-Version Parser Documentation
@pgsql/types - Types Documentation
@pgsql/enums - Enums Documentation
@libpg-query/parser - Full Parser Documentation

Build Instructions

This package uses a WASM-only build system for true cross-platform compatibility without native compilation dependencies.

Prerequisites

Node.js (version 16 or higher recommended)
pnpm (v8+ recommended)

Building WASM Artifacts

Install dependencies:
```
pnpm install
```
Build WASM artifacts:
```
pnpm run build
```
Clean WASM build (if needed):
```
pnpm run clean
```
Rebuild WASM artifacts from scratch:
```
pnpm run clean && pnpm run build
```

Build Process Details

The WASM build process:

Uses Emscripten SDK for compilation
Compiles C wrapper code to WebAssembly
Generates wasm/libpg-query.js and wasm/libpg-query.wasm files
No native compilation or node-gyp dependencies required

Testing

Running Tests

pnpm run test

Test Requirements

WASM artifacts must be built before running tests
If tests fail with "fetch failed" errors, rebuild WASM artifacts:
```
pnpm run clean && pnpm run build && pnpm run test
```

Troubleshooting

Common Issues

"fetch failed" errors during tests:

This indicates stale or missing WASM artifacts
Solution: pnpm run clean && pnpm run build

"WASM module not initialized" errors:

Ensure you call an async method first to initialize the WASM module
Or use the async versions of methods which handle initialization automatically

Build environment issues:

Ensure Emscripten SDK is properly installed and configured
Check that all required build dependencies are available

Template System

To avoid duplication across PostgreSQL versions, common files are maintained in the templates/ directory:

LICENSE, Makefile, src/index.ts, src/libpg-query.d.ts, src/wasm_wrapper.c

To update version-specific files from templates:

npm run copy:templates

This ensures consistency while allowing version-specific customizations (e.g., patches for version 13).

Build Artifacts

The build process generates these files:

wasm/libpg-query.js - Emscripten-generated JavaScript loader
wasm/libpg-query.wasm - WebAssembly binary
wasm/index.js - ES module exports
wasm/index.cjs - CommonJS exports with sync wrappers

Credits

Built on the excellent work of several contributors:

Dan Lynch — official maintainer since 2018 and architect of the current implementation
Lukas Fittl for libpg_query — the core PostgreSQL parser that powers this project
Greg Richardson for AST guidance and pushing the transition to WASM and multiple PG runtimes for better interoperability
Ethan Resnick for the original Node.js N-API bindings
Zac McCormick for the foundational node-pg-query-native parser

pgsql-parser: The real PostgreSQL parser for Node.js, providing symmetric parsing and deparsing of SQL statements with actual PostgreSQL parser integration.
pgsql-deparser: A streamlined tool designed for converting PostgreSQL ASTs back into SQL queries, focusing solely on deparser functionality to complement pgsql-parser.
@pgsql/parser: Multi-version PostgreSQL parser with dynamic version selection at runtime, supporting PostgreSQL 15, 16, and 17 in a single package.
@pgsql/types: Offers TypeScript type definitions for PostgreSQL AST nodes, facilitating type-safe construction, analysis, and manipulation of ASTs.
@pgsql/enums: Provides TypeScript enum definitions for PostgreSQL constants, enabling type-safe usage of PostgreSQL enums and constants in your applications.
@pgsql/utils: A comprehensive utility library for PostgreSQL, offering type-safe AST node creation and enum value conversions, simplifying the construction and manipulation of PostgreSQL ASTs.
pg-proto-parser: A TypeScript tool that parses PostgreSQL Protocol Buffers definitions to generate TypeScript interfaces, utility functions, and JSON mappings for enums.
libpg-query: The real PostgreSQL parser exposed for Node.js, used primarily in pgsql-parser for parsing and deparsing SQL queries.

Disclaimer

AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED "AS IS", AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.

No developer or entity involved in creating Software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the Software code or Software CLI, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.

Package detail

@pgsql/types

readme