pgsql-parser 16.0.0 → 17.1.0

package/README.md

@@ -14,7 +14,7 @@
    <a href="https://www.npmjs.com/package/pgsql-parser"><img height="20" src="https://img.shields.io/github/package-json/v/launchql/pgsql-parser?filename=packages%2Fparser%2Fpackage.json"/></a>
 </p>
 
-The real PostgreSQL parser for Node.js. Built with the actual [PostgreSQL parser](https://github.com/pganalyze/libpg_query), `pgsql-parser` delivers true-to-spec SQL parsing and reconstruction. Transform SQL queries into ASTs, modify them programmatically, and convert them back to SQL with complete fidelity.
+The real PostgreSQL parser for Node.js, `pgsql-parser` provides symmetric parsing and deparsing of SQL statements using the actual [PostgreSQL parser](https://github.com/pganalyze/libpg_query). It allows you to parse SQL queries into AST and modify or reconstruct SQL queries from the AST.
 
 ## Installation
 
@@ -22,30 +22,38 @@ The real PostgreSQL parser for Node.js. Built with the actual [PostgreSQL parser
 npm install pgsql-parser
 ```
 
-## Features
+## Key Features
 
-* 🔄 **Symmetric Parsing & Deparsing** – Parse SQL to AST and reconstruct it back to SQL with perfect round-trip accuracy
-* 🧪 **Battle-Tested Reliability** – Validated against 23,000+ SQL statements ensuring production-grade stability  
-* 🔧 **Direct from PostgreSQL** – Uses the official Postgres C parser compiled to WebAssembly for 100% spec compliance
-* 🚀 **WebAssembly Powered:** - Cross-platform compatibility without native dependencies.
-* 🛠️ **AST Manipulation:** - Easily modify parts of a SQL statement through the AST.
+- **True PostgreSQL Parsing:** Utilizes the real PostgreSQL source code for accurate parsing.
+- **Symmetric Parsing and Deparsing:** Convert SQL to AST and back, enabling query manipulation.
+- **AST Manipulation:** Easily modify parts of a SQL statement through the AST.
+- **WebAssembly Powered:** Cross-platform compatibility without native dependencies.
 
 ## API
 
 The package exports both async and sync methods. Async methods handle initialization automatically, while sync methods require explicit initialization.
 
-⚠️ If you don't need the parser functionality, consider using the TS-only (no WASM, zero runtime dependencies) [`pgsql-deparser`](https://github.com/launchql/pgsql-parser/tree/main/packages/deparser) for a super fast, lightweight deparser. Battle-tested with 23,000+ SQL statements 🚀
+⚠️ We recommend using `@pgsql/deparser` instead of `deparse` from `pgsql-parser`. The deparser package is more complete, supports sub-expressions, and doesn't require the WebAssembly module, making it lighter and more flexible for most use cases. It will soon be deprecated, in a minor version bump.
 
 ### Async Methods (Recommended)
 
 ```typescript
-import { parse, deparse } from 'pgsql-parser';
+import { parse, deparse, parseFunction } from 'pgsql-parser';
 
 // Parse SQL to AST
 const stmts = await parse('SELECT * FROM test_table');
 
 // Deparse AST back to SQL
 const sql = await deparse(stmts);
+
+// Parse PL/pgSQL functions
+const funcAst = await parseFunction(`
+  CREATE FUNCTION get_count() RETURNS integer AS $$
+  BEGIN
+    RETURN (SELECT COUNT(*) FROM users);
+  END;
+  $$ LANGUAGE plpgsql;
+`);
 ```
 
 ### Sync Methods
@@ -89,21 +97,20 @@ The `pgsql-deparser` module serializes ASTs to SQL in pure TypeScript, avoiding
 Here's how you can use the deparser in your TypeScript code, using [`@pgsql/utils`](https://github.com/launchql/pgsql-parser/tree/main/packages/utils) to create an AST for `deparse`:
 
 ```ts
-import * as t from '@pgsql/utils';
-import { RangeVar, SelectStmt } from '@pgsql/types';
+import ast from '@pgsql/utils';
 import { deparse } from 'pgsql-deparser';
 
 // This could have been obtained from any JSON or AST, not necessarily @pgsql/utils
-const stmt: { SelectStmt: SelectStmt } = t.nodes.selectStmt({
+const stmt = ast.selectStmt({
   targetList: [
-    t.nodes.resTarget({
-      val: t.nodes.columnRef({
-        fields: [t.nodes.aStar()]
+    ast.resTarget({
+      val: ast.columnRef({
+        fields: [ast.aStar()]
       })
     })
   ],
   fromClause: [
-    t.nodes.rangeVar({
+    ast.rangeVar({
       relname: 'some_table',
       inh: true,
       relpersistence: 'p'
@@ -113,36 +120,66 @@ const stmt: { SelectStmt: SelectStmt } = t.nodes.selectStmt({
   op: 'SETOP_NONE'
 });
 
-// Modify the AST if needed  
-(stmt.SelectStmt.fromClause[0] as {RangeVar: RangeVar}).RangeVar.relname = 'another_table';
+// Modify the AST if needed
+stmt.SelectStmt.fromClause[0].RangeVar.relname = 'another_table';
 
 // Deparse the modified AST back to a SQL string
-console.log(await deparse(stmt));
+console.log(deparse(stmts));
 
 // Output: SELECT * FROM another_table
 ```
 
-## Credits
+## CLI
+
+```
+npm install -g pgsql-parser
+```
+
+### usage
+
+```sh
+pgsql-parser <sqlfile>
+```
+
+## Versions
+
+As of PG 13, PG majors versions maintained will have a matching dedicated major npm version. Only the latest Postgres stable release receives active updates.
 
-Built on the excellent work of several contributors:
+Our latest is built with `17-latest` branch from libpg_query
+
+| PostgreSQL Major Version | libpg_query | Status              | npm tag |
+|--------------------------|-------------|---------------------|---------|
+| 17                       | 17-latest   | Active Development  | `latest` |
+| 16                       | (n/a)       | Not supported       |
+| 15                       | (n/a)       | Not supported       |
+| 14                       | (n/a)       | Not supported       |
+| 13                       | 13-latest   | Only Critical Fixes | `13.16.0` |
+| 12                       | (n/a)       | Not supported       |
+| 11                       | (n/a)       | Not supported       |
+| 10                       | 10-latest   | Not supported       | `@1.3.1` ([tree](https://github.com/launchql/pgsql-parser/tree/39b7b1adc8914253226e286a48105785219a81ca))      | 
 
-* **[Dan Lynch](https://github.com/pyramation)** — official maintainer since 2018 and architect of the current implementation
-* **[Lukas Fittl](https://github.com/lfittl)** for [libpg_query](https://github.com/pganalyze/libpg_query) — the core PostgreSQL parser that powers this project
-* **[Greg Richardson](https://github.com/gregnr)** for AST guidance and pushing the transition to WASM and multiple PG runtimes for better interoperability
-* **[Ethan Resnick](https://github.com/ethanresnick)** for the original Node.js N-API bindings
-* **[Zac McCormick](https://github.com/zhm)** for the foundational [node-pg-query-native](https://github.com/zhm/node-pg-query-native) parser
 
 ## Related
 
-* [pgsql-parser](https://www.npmjs.com/package/pgsql-parser): The real PostgreSQL parser for Node.js, providing symmetric parsing and deparsing of SQL statements with actual PostgreSQL parser integration.
-* [pgsql-deparser](https://www.npmjs.com/package/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](https://www.npmjs.com/package/@pgsql/parser): Multi-version PostgreSQL parser with dynamic version selection at runtime, supporting PostgreSQL 15, 16, and 17 in a single package.
-* [@pgsql/types](https://www.npmjs.com/package/@pgsql/types): Offers TypeScript type definitions for PostgreSQL AST nodes, facilitating type-safe construction, analysis, and manipulation of ASTs.
-* [@pgsql/enums](https://www.npmjs.com/package/@pgsql/enums): Provides TypeScript enum definitions for PostgreSQL constants, enabling type-safe usage of PostgreSQL enums and constants in your applications.
-* [@pgsql/utils](https://www.npmjs.com/package/@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](https://www.npmjs.com/package/pg-proto-parser): A TypeScript tool that parses PostgreSQL Protocol Buffers definitions to generate TypeScript interfaces, utility functions, and JSON mappings for enums.
+* [pgsql-parser](https://github.com/launchql/pgsql-parser): The real PostgreSQL parser for Node.js, providing symmetric parsing and deparsing of SQL statements with actual PostgreSQL parser integration.
+* [pgsql-deparser](https://github.com/launchql/pgsql-parser/tree/main/packages/deparser): A streamlined tool designed for converting PostgreSQL ASTs back into SQL queries, focusing solely on deparser functionality to complement `pgsql-parser`.
+* [pgsql-enums](https://github.com/launchql/pgsql-parser/tree/main/packages/pgsql-enums): A utility package offering easy access to PostgreSQL enumeration types in JSON format, aiding in string and integer conversions of enums used within ASTs to compliment `pgsql-parser`
+* [@pgsql/enums](https://github.com/launchql/pgsql-parser/tree/main/packages/enums): Provides PostgreSQL AST enums in TypeScript, enhancing type safety and usability in projects interacting with PostgreSQL AST nodes.
+* [@pgsql/types](https://github.com/launchql/pgsql-parser/tree/main/packages/types): Offers TypeScript type definitions for PostgreSQL AST nodes, facilitating type-safe construction, analysis, and manipulation of ASTs.
+* [@pgsql/utils](https://github.com/launchql/pgsql-parser/tree/main/packages/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](https://github.com/launchql/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](https://github.com/launchql/libpg-query-node): The real PostgreSQL parser exposed for Node.js, used primarily in `pgsql-parser` for parsing and deparsing SQL queries.
 
+## Credits
+
+Thanks [@lfittl](https://github.com/lfittl) for building the core `libpg_query` suite:
+
+* [libpg_query](https://github.com/pganalyze/libpg_query)
+* [pg_query](https://github.com/lfittl/pg_query)
+* [pg_query.go](https://github.com/lfittl/pg_query.go)
+
+Thanks to [@zhm](https://github.com/zhm) for the [OG Parser](https://github.com/zhm/pg-query-parser/blob/master/LICENSE.md) that started it all.
+
 ## Disclaimer
 
 AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED "AS IS", AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.

package/esm/index.js

@@ -1,3 +1 @@
-export { parse as parse, parseSync as parseSync, loadModule as loadModule } from 'libpg-query';
-export { deparse, deparseSync, } from 'pgsql-deparser';
-export * from '@pgsql/types';
+export { parse as parse, parseSync as parseSync, parsePlPgSQL as parseFunction, deparseSync as deparseSync, deparse as deparse, loadModule as loadModule } from 'libpg-query';

package/esm/utils/index.js

@@ -0,0 +1,90 @@
+/* eslint-disable no-restricted-syntax */
+export const cleanLines = (sql) => {
+    return sql
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((a) => a)
+        .join('\n');
+};
+export const transform = (obj, props) => {
+    let copy = null;
+    // Handle the 3 simple types, and null or undefined
+    if (obj == null || typeof obj !== 'object') {
+        return obj;
+    }
+    // Handle Date
+    if (obj instanceof Date) {
+        copy = new Date();
+        copy.setTime(obj.getTime());
+        return copy;
+    }
+    // Handle Array
+    if (obj instanceof Array) {
+        copy = [];
+        for (let i = 0, len = obj.length; i < len; i++) {
+            copy[i] = transform(obj[i], props);
+        }
+        return copy;
+    }
+    // Handle Object
+    if (obj instanceof Object || typeof obj === 'object') {
+        copy = {};
+        for (const attr in obj) {
+            if (obj.hasOwnProperty(attr)) {
+                if (props.hasOwnProperty(attr)) {
+                    if (typeof props[attr] === 'function') {
+                        copy[attr] = props[attr](obj[attr]);
+                    }
+                    else if (props[attr].hasOwnProperty(obj[attr])) {
+                        copy[attr] = props[attr][obj[attr]];
+                    }
+                    else {
+                        copy[attr] = transform(obj[attr], props);
+                    }
+                }
+                else {
+                    copy[attr] = transform(obj[attr], props);
+                }
+            }
+            else {
+                copy[attr] = transform(obj[attr], props);
+            }
+        }
+        return copy;
+    }
+    throw new Error("Unable to copy obj! Its type isn't supported.");
+};
+const noop = () => undefined;
+export const cleanTree = (tree) => {
+    return transform(tree, {
+        stmt_len: noop,
+        stmt_location: noop,
+        location: noop,
+        DefElem: (obj) => {
+            if (obj.defname === 'as') {
+                if (Array.isArray(obj.arg) && obj.arg.length) {
+                    // function
+                    obj.arg[0].String.str = obj.arg[0].String.str.trim();
+                }
+                else if (obj.arg.List && obj.arg.List.items) {
+                    // function
+                    obj.arg.List.items[0].String.str = obj.arg.List.items[0].String.str.trim();
+                }
+                else {
+                    // do stmt
+                    obj.arg.String.str = obj.arg.String.str.trim();
+                }
+                return cleanTree(obj);
+            }
+            else {
+                return cleanTree(obj);
+            }
+        }
+    });
+};
+export const cleanTreeWithStmt = (tree) => {
+    return transform(tree, {
+        stmt_location: noop,
+        location: noop
+    });
+};

package/index.d.ts

@@ -1,3 +1 @@
-export { parse as parse, parseSync as parseSync, loadModule as loadModule } from 'libpg-query';
-export { deparse, deparseSync, } from 'pgsql-deparser';
-export * from '@pgsql/types';
+export { parse as parse, parseSync as parseSync, parsePlPgSQL as parseFunction, deparseSync as deparseSync, deparse as deparse, loadModule as loadModule } from 'libpg-query';

package/index.js

@@ -1,25 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deparseSync = exports.deparse = exports.loadModule = exports.parseSync = exports.parse = void 0;
+exports.loadModule = exports.deparse = exports.deparseSync = exports.parseFunction = exports.parseSync = exports.parse = void 0;
 var libpg_query_1 = require("libpg-query");
 Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return libpg_query_1.parse; } });
 Object.defineProperty(exports, "parseSync", { enumerable: true, get: function () { return libpg_query_1.parseSync; } });
+Object.defineProperty(exports, "parseFunction", { enumerable: true, get: function () { return libpg_query_1.parsePlPgSQL; } });
+Object.defineProperty(exports, "deparseSync", { enumerable: true, get: function () { return libpg_query_1.deparseSync; } });
+Object.defineProperty(exports, "deparse", { enumerable: true, get: function () { return libpg_query_1.deparse; } });
 Object.defineProperty(exports, "loadModule", { enumerable: true, get: function () { return libpg_query_1.loadModule; } });
-var pgsql_deparser_1 = require("pgsql-deparser");
-Object.defineProperty(exports, "deparse", { enumerable: true, get: function () { return pgsql_deparser_1.deparse; } });
-Object.defineProperty(exports, "deparseSync", { enumerable: true, get: function () { return pgsql_deparser_1.deparseSync; } });
-__exportStar(require("@pgsql/types"), exports);

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "pgsql-parser",
-  "version": "16.0.0",
+  "version": "17.1.0",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "description": "The real PostgreSQL query parser",
   "main": "index.js",
   "module": "esm/index.js",
   "types": "index.d.ts",
   "homepage": "https://github.com/launchql/pgsql-parser",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {
     "access": "public",
     "directory": "dist"
@@ -19,11 +19,18 @@
   "bugs": {
     "url": "https://github.com/launchql/pgsql-parser/issues"
   },
+  "bin": {
+    "pgsql-parser": "main/cli.js"
+  },
   "scripts": {
-    "copy": "copyfiles -f ../../../../LICENSE README.md package.json dist",
+    "copy": "copyfiles -f ../../LICENSE README.md package.json dist",
     "clean": "rimraf dist",
+    "prepare": "npm run build",
     "build": "npm run clean && tsc && tsc -p tsconfig.esm.json && npm run copy",
-    "publish:pkg": "npm publish --tag pg16"
+    "build:dev": "npm run clean && tsc --declarationMap && tsc -p tsconfig.esm.json && npm run copy",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
   },
   "keywords": [
     "sql",
@@ -35,8 +42,9 @@
     "database"
   ],
   "dependencies": {
-    "@pgsql/types": "16.1.1",
-    "libpg-query": "16.5.5",
-    "pgsql-deparser": "16.0.0"
-  }
-}
+    "@pgsql/types": "^17.1.0",
+    "libpg-query": "17.3.3",
+    "minimist": "^1.2.6"
+  },
+  "gitHead": "40ee618df37a501169847056a50558c453cd30a6"
+}

package/utils/index.d.ts

@@ -0,0 +1,4 @@
+export declare const cleanLines: (sql: string) => string;
+export declare const transform: (obj: any, props: any) => any;
+export declare const cleanTree: (tree: any) => any;
+export declare const cleanTreeWithStmt: (tree: any) => any;

package/utils/index.js

@@ -0,0 +1,97 @@
+"use strict";
+/* eslint-disable no-restricted-syntax */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanTreeWithStmt = exports.cleanTree = exports.transform = exports.cleanLines = void 0;
+const cleanLines = (sql) => {
+    return sql
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((a) => a)
+        .join('\n');
+};
+exports.cleanLines = cleanLines;
+const transform = (obj, props) => {
+    let copy = null;
+    // Handle the 3 simple types, and null or undefined
+    if (obj == null || typeof obj !== 'object') {
+        return obj;
+    }
+    // Handle Date
+    if (obj instanceof Date) {
+        copy = new Date();
+        copy.setTime(obj.getTime());
+        return copy;
+    }
+    // Handle Array
+    if (obj instanceof Array) {
+        copy = [];
+        for (let i = 0, len = obj.length; i < len; i++) {
+            copy[i] = (0, exports.transform)(obj[i], props);
+        }
+        return copy;
+    }
+    // Handle Object
+    if (obj instanceof Object || typeof obj === 'object') {
+        copy = {};
+        for (const attr in obj) {
+            if (obj.hasOwnProperty(attr)) {
+                if (props.hasOwnProperty(attr)) {
+                    if (typeof props[attr] === 'function') {
+                        copy[attr] = props[attr](obj[attr]);
+                    }
+                    else if (props[attr].hasOwnProperty(obj[attr])) {
+                        copy[attr] = props[attr][obj[attr]];
+                    }
+                    else {
+                        copy[attr] = (0, exports.transform)(obj[attr], props);
+                    }
+                }
+                else {
+                    copy[attr] = (0, exports.transform)(obj[attr], props);
+                }
+            }
+            else {
+                copy[attr] = (0, exports.transform)(obj[attr], props);
+            }
+        }
+        return copy;
+    }
+    throw new Error("Unable to copy obj! Its type isn't supported.");
+};
+exports.transform = transform;
+const noop = () => undefined;
+const cleanTree = (tree) => {
+    return (0, exports.transform)(tree, {
+        stmt_len: noop,
+        stmt_location: noop,
+        location: noop,
+        DefElem: (obj) => {
+            if (obj.defname === 'as') {
+                if (Array.isArray(obj.arg) && obj.arg.length) {
+                    // function
+                    obj.arg[0].String.str = obj.arg[0].String.str.trim();
+                }
+                else if (obj.arg.List && obj.arg.List.items) {
+                    // function
+                    obj.arg.List.items[0].String.str = obj.arg.List.items[0].String.str.trim();
+                }
+                else {
+                    // do stmt
+                    obj.arg.String.str = obj.arg.String.str.trim();
+                }
+                return (0, exports.cleanTree)(obj);
+            }
+            else {
+                return (0, exports.cleanTree)(obj);
+            }
+        }
+    });
+};
+exports.cleanTree = cleanTree;
+const cleanTreeWithStmt = (tree) => {
+    return (0, exports.transform)(tree, {
+        stmt_location: noop,
+        location: noop
+    });
+};
+exports.cleanTreeWithStmt = cleanTreeWithStmt;