pgsql-parser 13.7.2 → 13.8.0

package/README.md

@@ -14,9 +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 nodejs. The primary objective of this module is to provide symmetric parsing and deparsing of SQL statements. With this module you can modify parts of a SQL query statement and serialize the query tree back into a formatted SQL statement. It uses the *real* [PostgreSQL parser](https://github.com/pganalyze/libpg_query).
-
-The main functionality provided by this module is deparsing, which PostgreSQL does not have internally.
+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
 
@@ -24,15 +22,22 @@ The main functionality provided by this module is deparsing, which PostgreSQL do
 npm install pgsql-parser
 ```
 
+## Key Features
+
+- **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.
+
 ## Parser Example
 
 Rewrite part of a SQL query:
 
 ```js
-const { parse, deparse } = require('pgsql-parser');
+import { parse, deparse } from 'pgsql-parser';
 
 const stmts = parse('SELECT * FROM test_table');
 
+// Assuming the structure of stmts is known and matches the expected type
 stmts[0].RawStmt.stmt.SelectStmt.fromClause[0].RangeVar.relname = 'another_table';
 
 console.log(deparse(stmts));
@@ -42,19 +47,25 @@ console.log(deparse(stmts));
 
 ## Deparser Example
 
-The deparser can be used separately, which removes many deps required for the parser:
+The deparser functionality is provided as a standalone module, enabling you to serialize AST (Abstract Syntax Tree) objects back to SQL statements without the need for the full parsing engine. This separation is particularly beneficial for environments where the native dependencies of the full parser are problematic or unnecessary. For instance, if you already have an AST representation of your SQL query and merely need to convert it back to a SQL string, you can use the pgsql-deparser module directly. This module is implemented in pure TypeScript, avoiding the need for native bindings and thereby simplifying deployment and compatibility across different environments.
 
-```js
-const { parse } = require('pgsql-parser');
-const { deparse } = require('pgsql-deparser');
+Here's how you can use the deparser in your TypeScript code:
 
-const stmts = parse('SELECT * FROM test_table');
+```ts
+import { deparse } from 'pgsql-deparser';
+
+// Assuming `stmts` is an AST object for the query 'SELECT * FROM test_table'
+// This could have been obtained from any source, not necessarily the pgsql-parser
+const stmts = getAstFromSomewhere();
 
+// Modify the AST as needed
 stmts[0].RawStmt.stmt.SelectStmt.fromClause[0].RangeVar.relname = 'another_table';
 
+// Deparse the modified AST back to a SQL string
 console.log(deparse(stmts));
 
-// SELECT * FROM "another_table"
+// Output: SELECT * FROM "another_table"
+
 ```
 
 ## CLI
@@ -121,16 +132,31 @@ Our latest is built with `13-latest` branch from libpg_query
 
 ## Related
 
-* [libpg-query-node](https://github.com/pyramation/libpg-query-node)
+* [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-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-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/master/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/master/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/master/packages/utils): A utility library for working with PostgreSQL AST node enumerations in a type-safe way, easing enum name and value conversions.
+* [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-node](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.
+
+Thanks @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)
 
 ## Credits
 
+Thanks to @zhm for the OG parser that started it all:
+
 * [pg-query-parser](https://github.com/zhm/pg-query-parser)
 * [pg-query-native](https://github.com/zhm/node-pg-query-native)
+* [Original LICENSE](https://github.com/zhm/pg-query-parser/blob/master/LICENSE.md)
+
+## Disclaimer
 
-License: https://github.com/zhm/pg-query-parser/blob/master/LICENSE.md
+AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED “AS IS”, AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.
 
-Thanks to https://github.com/zhm/pg-query-parser we've been able to start this repo and add a lot of functionality
+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/main/cli.js

@@ -1,33 +1,27 @@
 #!/usr/bin/env node
 "use strict";
-
-var _path = require("path");
-
-var _fs = require("fs");
-
-var _index = require("./index");
-
-var _utils = require("./utils");
-
-var argv = require('minimist')(process.argv.slice(2));
-
-var args = argv._;
-
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const index_1 = require("./index");
+const utils_1 = require("./utils");
+const argv = require('minimist')(process.argv.slice(2));
+const args = argv._;
 if (args.length !== 1) {
-  console.log(argv);
-  console.warn('Usage: pgsql-parser <sqlfile>');
-  process.exit(1);
+    console.log(argv);
+    console.warn('Usage: pgsql-parser <sqlfile>');
+    process.exit(1);
 }
-
-var pth = args[0].startsWith('/') ? args[0] : (0, _path.resolve)((0, _path.join)(process.cwd(), args[0]));
-var content = (0, _fs.readFileSync)(pth, 'utf-8');
-var query;
-
+const pth = args[0].startsWith('/')
+    ? args[0]
+    : (0, path_1.resolve)((0, path_1.join)(process.cwd(), args[0]));
+const content = (0, fs_1.readFileSync)(pth, 'utf-8');
+let query;
 if (argv.pl) {
-  // plpgsql ONLY
-  query = (0, _index.parseFunction)(content);
-} else {
-  query = (0, _index.parse)(content);
+    // plpgsql ONLY
+    query = (0, index_1.parseFunction)(content);
 }
-
-process.stdout.write(JSON.stringify((0, _utils.cleanTreeWithStmt)(query), null, 2));
+else {
+    query = (0, index_1.parse)(content);
+}
+process.stdout.write(JSON.stringify((0, utils_1.cleanTreeWithStmt)(query), null, 2));

package/main/index.js

@@ -1,100 +1,31 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "Deparser", {
-  enumerable: true,
-  get: function get() {
-    return _pgsqlDeparser.Deparser;
-  }
-});
-Object.defineProperty(exports, "deparse", {
-  enumerable: true,
-  get: function get() {
-    return _pgsqlDeparser.deparse;
-  }
-});
-Object.defineProperty(exports, "enums", {
-  enumerable: true,
-  get: function get() {
-    return _pgsqlEnums.enums;
-  }
-});
-Object.defineProperty(exports, "parseFunction", {
-  enumerable: true,
-  get: function get() {
-    return _libpgQuery.parsePlPgSQLSync;
-  }
-});
-exports.parseAsync = exports.parse = void 0;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _pgsqlDeparser = require("pgsql-deparser");
-
-var _pgsqlEnums = require("pgsql-enums");
-
-var _libpgQuery = require("libpg-query");
-
-function mapStmt(_ref) {
-  var stmt = _ref.stmt,
-      stmt_len = _ref.stmt_len,
-      stmt_location = _ref.stmt_location;
-  return {
-    RawStmt: {
-      stmt: stmt,
-      stmt_len: stmt_len,
-      stmt_location: stmt_location || 0
-    }
-  };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFunction = exports.Deparser = exports.deparse = exports.parseAsync = exports.parse = void 0;
+const pgsql_deparser_1 = require("pgsql-deparser");
+Object.defineProperty(exports, "Deparser", { enumerable: true, get: function () { return pgsql_deparser_1.Deparser; } });
+Object.defineProperty(exports, "deparse", { enumerable: true, get: function () { return pgsql_deparser_1.deparse; } });
+const libpg_query_1 = require("libpg-query");
+Object.defineProperty(exports, "parseFunction", { enumerable: true, get: function () { return libpg_query_1.parsePlPgSQLSync; } });
+function mapStmt({ stmt, stmt_len, stmt_location }) {
+    return {
+        RawStmt: {
+            stmt,
+            stmt_len,
+            stmt_location: stmt_location || 0
+        }
+    };
 }
-
-var parse = function parse(sql) {
-  if (!sql) throw new Error('no SQL provided to parser');
-  var result = (0, _libpgQuery.parseQuerySync)(sql);
-  return result.stmts.map(mapStmt);
+const parse = (sql) => {
+    if (!sql)
+        throw new Error('no SQL provided to parser');
+    const result = (0, libpg_query_1.parseQuerySync)(sql);
+    return result.stmts.map(mapStmt);
 };
-
 exports.parse = parse;
-
-var parseAsync = /*#__PURE__*/function () {
-  var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(sql) {
-    var result;
-    return _regenerator["default"].wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            if (sql) {
-              _context.next = 2;
-              break;
-            }
-
-            throw new Error('no SQL provided to parser');
-
-          case 2:
-            _context.next = 4;
-            return (0, _libpgQuery.parseQuery)(sql);
-
-          case 4:
-            result = _context.sent;
-            return _context.abrupt("return", result.stmts.map(mapStmt));
-
-          case 6:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-
-  return function parseAsync(_x) {
-    return _ref2.apply(this, arguments);
-  };
-}();
-
-exports.parseAsync = parseAsync;
+const parseAsync = async (sql) => {
+    if (!sql)
+        throw new Error('no SQL provided to parser');
+    const result = await (0, libpg_query_1.parseQuery)(sql);
+    return result.stmts.map(mapStmt);
+};
+exports.parseAsync = parseAsync;

package/main/utils/index.js

@@ -1,117 +1,97 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.cleanTreeWithStmt = exports.cleanTree = exports.transform = exports.cleanLines = void 0;
-
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
 /* eslint-disable no-restricted-syntax */
-var cleanLines = function cleanLines(sql) {
-  return sql.split('\n').map(function (l) {
-    return l.trim();
-  }).filter(function (a) {
-    return a;
-  }).join('\n');
+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;
-
-var transform = function transform(obj, props) {
-  var copy = null; // Handle the 3 simple types, and null or undefined
-
-  if (obj == null || (0, _typeof2["default"])(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 (var i = 0, len = obj.length; i < len; i++) {
-      copy[i] = transform(obj[i], props);
+const transform = (obj, props) => {
+    let copy = null;
+    // Handle the 3 simple types, and null or undefined
+    if (obj == null || typeof obj !== 'object') {
+        return obj;
     }
-
-    return copy;
-  } // Handle Object
-
-
-  if (obj instanceof Object || (0, _typeof2["default"])(obj) === 'object') {
-    copy = {};
-
-    for (var 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);
+    // 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);
         }
-      } else {
-        copy[attr] = transform(obj[attr], props);
-      }
+        return copy;
     }
-
-    return copy;
-  }
-
-  throw new Error("Unable to copy obj! Its type isn't supported.");
+    // 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;
-
-var noop = function noop() {
-  return undefined;
-};
-
-var cleanTree = function cleanTree(tree) {
-  return transform(tree, {
-    stmt_len: noop,
-    stmt_location: noop,
-    location: noop,
-    DefElem: function 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();
+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);
+            }
         }
-
-        return cleanTree(obj);
-      } else {
-        return cleanTree(obj);
-      }
-    }
-  });
+    });
 };
-
 exports.cleanTree = cleanTree;
-
-var cleanTreeWithStmt = function cleanTreeWithStmt(tree) {
-  return transform(tree, {
-    stmt_location: noop,
-    location: noop
-  });
+const cleanTreeWithStmt = (tree) => {
+    return (0, exports.transform)(tree, {
+        stmt_location: noop,
+        location: noop
+    });
 };
-
-exports.cleanTreeWithStmt = cleanTreeWithStmt;
+exports.cleanTreeWithStmt = cleanTreeWithStmt;

package/module/cli.js

@@ -3,26 +3,23 @@ import { resolve, join } from 'path';
 import { readFileSync } from 'fs';
 import { parse, parseFunction } from './index';
 import { cleanTreeWithStmt } from './utils';
-
 const argv = require('minimist')(process.argv.slice(2));
-
 const args = argv._;
-
 if (args.length !== 1) {
-  console.log(argv);
-  console.warn('Usage: pgsql-parser <sqlfile>');
-  process.exit(1);
+    console.log(argv);
+    console.warn('Usage: pgsql-parser <sqlfile>');
+    process.exit(1);
 }
-
-const pth = args[0].startsWith('/') ? args[0] : resolve(join(process.cwd(), args[0]));
+const pth = args[0].startsWith('/')
+    ? args[0]
+    : resolve(join(process.cwd(), args[0]));
 const content = readFileSync(pth, 'utf-8');
 let query;
-
 if (argv.pl) {
-  // plpgsql ONLY
-  query = parseFunction(content);
-} else {
-  query = parse(content);
+    // plpgsql ONLY
+    query = parseFunction(content);
 }
-
-process.stdout.write(JSON.stringify(cleanTreeWithStmt(query), null, 2));
+else {
+    query = parse(content);
+}
+process.stdout.write(JSON.stringify(cleanTreeWithStmt(query), null, 2));

package/module/index.js

@@ -1,29 +1,24 @@
 import { Deparser, deparse } from 'pgsql-deparser';
-import { enums } from 'pgsql-enums';
 import { parseQuery, parseQuerySync, parsePlPgSQLSync as parseFunction } from 'libpg-query';
-
-function mapStmt({
-  stmt,
-  stmt_len,
-  stmt_location
-}) {
-  return {
-    RawStmt: {
-      stmt,
-      stmt_len,
-      stmt_location: stmt_location || 0
-    }
-  };
+function mapStmt({ stmt, stmt_len, stmt_location }) {
+    return {
+        RawStmt: {
+            stmt,
+            stmt_len,
+            stmt_location: stmt_location || 0
+        }
+    };
 }
-
-export const parse = sql => {
-  if (!sql) throw new Error('no SQL provided to parser');
-  const result = parseQuerySync(sql);
-  return result.stmts.map(mapStmt);
+export const parse = (sql) => {
+    if (!sql)
+        throw new Error('no SQL provided to parser');
+    const result = parseQuerySync(sql);
+    return result.stmts.map(mapStmt);
 };
-export const parseAsync = async sql => {
-  if (!sql) throw new Error('no SQL provided to parser');
-  const result = await parseQuery(sql);
-  return result.stmts.map(mapStmt);
+export const parseAsync = async (sql) => {
+    if (!sql)
+        throw new Error('no SQL provided to parser');
+    const result = await parseQuery(sql);
+    return result.stmts.map(mapStmt);
 };
-export { deparse, Deparser, enums, parseFunction };
+export { deparse, Deparser, parseFunction };