npm - pgsql-parser - Versions diffs - 13.17.0 → 13.19.1 - Mend

pgsql-parser 13.17.0 → 13.19.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/README.md CHANGED Viewed

@@ -1,20 +1,20 @@
 # pgsql-parser
 <p align="center" width="100%">
-  <img height="120" src="https://github.com/launchql/pgsql-parser/assets/545047/6440fa7d-918b-4a3b-8d1b-755d85de8bea" />
+  <img height="120" src="https://github.com/constructive-io/pgsql-parser/assets/545047/6440fa7d-918b-4a3b-8d1b-755d85de8bea" />
 </p>
 <p align="center" width="100%">
-  <a href="https://github.com/launchql/pgsql-parser/actions/workflows/run-tests.yaml">
-    <img height="20" src="https://github.com/launchql/pgsql-parser/actions/workflows/run-tests.yaml/badge.svg" />
+  <a href="https://github.com/constructive-io/pgsql-parser/actions/workflows/run-tests.yaml">
+    <img height="20" src="https://github.com/constructive-io/pgsql-parser/actions/workflows/run-tests.yaml/badge.svg" />
   </a>
    <a href="https://www.npmjs.com/package/pgsql-parser"><img height="20" src="https://img.shields.io/npm/dt/pgsql-parser"></a>
    <a href="https://www.npmjs.com/package/pgsql-parser"><img height="20" src="https://img.shields.io/npm/dw/pgsql-parser"/></a>
-   <a href="https://github.com/launchql/pgsql-parser/blob/main/LICENSE-MIT"><img height="20" src="https://img.shields.io/badge/license-MIT-blue.svg"/></a>
-   <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>
+   <a href="https://github.com/constructive-io/pgsql-parser/blob/main/LICENSE-MIT"><img height="20" src="https://img.shields.io/badge/license-MIT-blue.svg"/></a>
+   <a href="https://www.npmjs.com/package/pgsql-parser"><img height="20" src="https://img.shields.io/github/package-json/v/constructive-io/pgsql-parser?filename=packages%2Fparser%2Fpackage.json"/></a>
 </p>
-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.
+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.
 ## Installation
@@ -22,11 +22,48 @@ The real PostgreSQL parser for Node.js, `pgsql-parser` provides symmetric parsin
 npm install pgsql-parser
 ```
-## Key Features
+## 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.
+* 🔄 **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.
+## 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/constructive-io/pgsql-parser/tree/main/packages/deparser) for a super fast, lightweight deparser. Battle-tested with 23,000+ SQL statements 🚀
+### Async Methods (Recommended)
+```typescript
+import { parse, deparse } 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);
+```
+### Sync Methods
+Sync methods require explicit initialization using `loadModule()`:
+```typescript
+import { loadModule, parseSync, deparseSync } from 'pgsql-parser';
+// Initialize first (required for sync methods)
+await loadModule();
+// Now safe to use sync methods
+const stmts = parseSync('SELECT * FROM test_table');
+const sql = deparseSync(stmts);
+```
+**Note:** We recommend using async methods as they handle initialization automatically. Use sync methods only when necessary, and always call `loadModule()` first.
 ## Parser Example
@@ -35,12 +72,12 @@ Rewrite part of a SQL query:
 ```js
 import { parse, deparse } from 'pgsql-parser';
-const stmts = parse('SELECT * FROM test_table');
+const stmts = await 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));
+console.log(await deparse(stmts));
 // SELECT * FROM "another_table"
 ```
@@ -49,23 +86,24 @@ console.log(deparse(stmts));
 The `pgsql-deparser` module serializes ASTs to SQL in pure TypeScript, avoiding the full parser's native dependencies. It's useful when only SQL string conversion from ASTs is needed, and is written in pure TypeScript for easy cross-environment deployment.
-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`:
+Here's how you can use the deparser in your TypeScript code, using [`@pgsql/utils`](https://github.com/constructive-io/pgsql-parser/tree/main/packages/utils) to create an AST for `deparse`:
 ```ts
-import ast, { SelectStmt } from '@pgsql/utils';
+import * as t from '@pgsql/utils';
+import { RangeVar, SelectStmt } from '@pgsql/types';
 import { deparse } from 'pgsql-deparser';
 // This could have been obtained from any JSON or AST, not necessarily @pgsql/utils
-const stmt: SelectStmt = ast.selectStmt({
+const stmt: { SelectStmt: SelectStmt } = t.nodes.selectStmt({
   targetList: [
-    ast.resTarget({
-      val: ast.columnRef({
-        fields: [ast.aStar()]
+    t.nodes.resTarget({
+      val: t.nodes.columnRef({
+        fields: [t.nodes.aStar()]
       })
     })
   ],
   fromClause: [
-    ast.rangeVar({
+    t.nodes.rangeVar({
       relname: 'some_table',
       inh: true,
       relpersistence: 'p'
@@ -75,104 +113,41 @@ const stmt: SelectStmt = ast.selectStmt({
   op: 'SETOP_NONE'
 });
-// Modify the AST if needed
-stmt.SelectStmt.fromClause[0].RangeVar.relname = 'another_table';
+// Modify the AST if needed
+(stmt.SelectStmt.fromClause[0] as {RangeVar: RangeVar}).RangeVar.relname = 'another_table';
 // Deparse the modified AST back to a SQL string
-console.log(deparse(stmts));
+console.log(await deparse(stmt));
 // Output: SELECT * FROM another_table
 ```
-## CLI
-```
-npm install -g pgsql-parser
-```
-### usage
-```sh
-pgsql-parser <sqlfile>
-```
-### Documentation
-### `parser.parse(sql)`
-Parses the query and returns a parse object.
-### Parameters
-| parameter            | type               | description                                               |
-| -------------------- | ------------------ | --------------------------------------------------------- |
-| `query`              | String             | SQL query                                                 |
-Returns an object in the format:
-```
-{ query: <query|Object>,
-  error: { message: <message|String>,
-           fileName: <fileName|String>,
-           lineNumber: <line|Number>,
-           cursorPosition: <cursor|Number> }
-```
-### `parser.deparse(query)`
-Deparses the query tree and returns a formatted SQL statement. This function takes as input a query AST
-in the same format as the `query` property of on the result of the `parse` method. This is the primary
-functionality of this module.
-### Parameters
-| parameter            | type               | description                                               |
-| -------------------- | ------------------ | --------------------------------------------------------- |
-| `query`              | Object             | Query tree obtained from `parse`                          |
-Returns a normalized formatted SQL string.
-## 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.
+## Credits
-Our latest is built with `13-latest` branch from libpg_query
+Built on the excellent work of several contributors:
-| PostgreSQL Major Version | libpg_query | Status              | npm
-|--------------------------|-------------|---------------------|---------|
-| 13                       | 13-latest   | Active development  | `latest`
-| 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
+**🛠 Built by the [Constructive](https://constructive.io) team — creators of modular Postgres tooling for secure, composable backends. If you like our work, contribute on [GitHub](https://github.com/constructive-io).**
 ## Related
-* [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.
-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)
-## Credits
-Thanks to [@zhm](https://github.com/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)
+* [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.
+* [@pgsql/traverse](https://www.npmjs.com/package/@pgsql/traverse): PostgreSQL AST traversal utilities for pgsql-parser, providing a visitor pattern for traversing PostgreSQL Abstract Syntax Tree nodes, similar to Babel's traverse functionality but specifically designed for PostgreSQL AST structures.
+* [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.
+* [libpg-query](https://github.com/constructive-io/libpg-query-node): 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.
+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/esm/index.js ADDED Viewed

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

package/index.d.ts ADDED Viewed

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

package/index.js ADDED Viewed

@@ -0,0 +1,25 @@
+"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;
+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, "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 CHANGED Viewed

@@ -1,28 +1,29 @@
 {
   "name": "pgsql-parser",
-  "version": "13.17.0",
+  "version": "13.19.1",
+  "author": "Constructive <developers@constructive.io>",
   "description": "The real PostgreSQL query parser",
-  "author": "Dan Lynch <pyramation@gmail.com>",
-  "homepage": "https://github.com/launchql/pgsql-parser",
-  "license": "SEE LICENSE IN LICENSE",
-  "main": "main/index.js",
-  "module": "module/index.js",
-  "typings": "types/index.d.ts",
-  "directories": {
-    "lib": "src",
-    "test": "__tests__"
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/pgsql-parser",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
   },
-  "files": [
-    "types",
-    "module",
-    "src",
-    "main"
-  ],
-  "bin": {
-    "pgsql-parser": "main/cli.js"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/pgsql-parser"
   },
-  "publishConfig": {
-    "access": "public"
+  "bugs": {
+    "url": "https://github.com/constructive-io/pgsql-parser/issues"
+  },
+  "scripts": {
+    "copy": "copyfiles -f ../../../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist",
+    "build": "npm run clean && tsc && tsc -p tsconfig.esm.json && npm run copy",
+    "publish:pkg": "npm publish --tag pg13"
   },
   "keywords": [
     "sql",
@@ -33,61 +34,9 @@
     "query",
     "database"
   ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/launchql/pgsql-parser"
-  },
-  "scripts": {
-    "build:main": "yarn tsc -p tsconfig.json --outDir main --module commonjs",
-    "build:module": "yarn tsc -p tsconfig.json --outDir module --module es2022",
-    "build": "npm run build:module && npm run build:main",
-    "buidl": "npm run build",
-    "buidl:clean": "npm run clean && npm run buidl",
-    "clean": "rimraf ./types",
-    "prepare": "npm run build",
-    "lint": "eslint .",
-    "format": "eslint . --fix",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
-  },
-  "bugs": {
-    "url": "https://github.com/launchql/pgsql-parser/issues"
-  },
-  "jest": {
-    "preset": "ts-jest",
-    "testEnvironment": "node",
-    "transform": {
-      "^.+\\.ts?$": "ts-jest"
-    },
-    "transformIgnorePatterns": [
-      "<rootDir>/node_modules/"
-    ],
-    "testPathIgnorePatterns": [
-      "main/",
-      "module/",
-      "types/"
-    ]
-  },
-  "devDependencies": {
-    "@types/jest": "^29.5.0",
-    "eslint": "8.38.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "esprima": "4.0.1",
-    "glob": "8.0.3",
-    "jest": "^29.5.0",
-    "prettier": "^2.8.7",
-    "rimraf": "5.0.5",
-    "ts-jest": "^29.1.0",
-    "ts-node": "10.9.2",
-    "typescript": "^5.0.4"
-  },
   "dependencies": {
-    "libpg-query": "13.3.2",
-    "minimist": "^1.2.6",
-    "pgsql-deparser": "^13.16.0",
-    "pgsql-enums": "^13.11.0"
-  },
-  "gitHead": "85346892e652a57e570562fdac7a768545113619"
-}
+    "@pgsql/types": "13.11.1",
+    "libpg-query": "13.6.0",
+    "pgsql-deparser": "13.19.1"
+  }
+}

package/main/cli.js DELETED Viewed

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-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);
-}
-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_1.parseFunction)(content);
-}
-else {
-    query = (0, index_1.parse)(content);
-}
-process.stdout.write(JSON.stringify((0, utils_1.cleanTreeWithStmt)(query), null, 2));

package/main/index.js DELETED Viewed

@@ -1,31 +0,0 @@
-"use strict";
-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
-        }
-    };
-}
-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;
-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 DELETED Viewed

@@ -1,97 +0,0 @@
-"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;

package/module/cli.js DELETED Viewed

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-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);
-}
-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);
-}
-process.stdout.write(JSON.stringify(cleanTreeWithStmt(query), null, 2));

package/module/index.js DELETED Viewed

@@ -1,24 +0,0 @@
-import { Deparser, deparse } from 'pgsql-deparser';
-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
-        }
-    };
-}
-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 { deparse, Deparser, parseFunction };

package/module/utils/index.js DELETED Viewed

@@ -1,90 +0,0 @@
-/* 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/src/cli.js DELETED Viewed

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-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);
-}
-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);
-}
-process.stdout.write(JSON.stringify(cleanTreeWithStmt(query), null, 2));

package/src/index.ts DELETED Viewed

@@ -1,30 +0,0 @@
-import { Deparser, deparse } from 'pgsql-deparser';
-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
-    }
-  };
-}
-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 { deparse, Deparser, parseFunction };

package/src/utils/index.ts DELETED Viewed

@@ -1,92 +0,0 @@
-/* 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/types/cli.d.ts DELETED Viewed

	@@ -1,2 +0,0 @@
1	- #!/usr/bin/env node
2	- export {};

package/types/index.d.ts DELETED Viewed

@@ -1,5 +0,0 @@
-import { Deparser, deparse } from 'pgsql-deparser';
-import { parsePlPgSQLSync as parseFunction } from 'libpg-query';
-export declare const parse: (sql: any) => any;
-export declare const parseAsync: (sql: any) => Promise<any>;
-export { deparse, Deparser, parseFunction };

package/types/utils/index.d.ts DELETED Viewed

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