pgsql-parser 13.7.3 → 13.8.0

package/module/utils/index.js

@@ -1,90 +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 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);
+    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 || 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);
+    // 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);
+            }
         }
-      } else {
-        copy[attr] = transform(obj[attr], props);
-      }
+        return copy;
     }
-
-    return copy;
-  }
-
-  throw new Error("Unable to copy obj! Its type isn't supported.");
+    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();
+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);
+            }
         }
-
-        return cleanTree(obj);
-      } else {
-        return cleanTree(obj);
-      }
-    }
-  });
+    });
+};
+export const cleanTreeWithStmt = (tree) => {
+    return transform(tree, {
+        stmt_location: noop,
+        location: noop
+    });
 };
-export const cleanTreeWithStmt = tree => {
-  return transform(tree, {
-    stmt_location: noop,
-    location: noop
-  });
-};

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "pgsql-parser",
-  "version": "13.7.3",
+  "version": "13.8.0",
   "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__"
   },
   "files": [
-    "main",
-    "module"
+    "types",
+    "module",
+    "src",
+    "main"
   ],
   "bin": {
     "pgsql-parser": "main/cli.js"
@@ -35,13 +38,15 @@
     "url": "https://github.com/launchql/pgsql-parser"
   },
   "scripts": {
-    "build:main": "cross-env BABEL_ENV=production babel src --out-dir main --delete-dir-on-start",
-    "build:module": "cross-env MODULE=true babel src --out-dir module --delete-dir-on-start",
+    "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 src --fix",
-    "dev": "cross-env NODE_ENV=development babel-node src/index",
-    "watch": "cross-env NODE_ENV=development babel-watch src/index",
+    "lint": "eslint .",
+    "format": "eslint . --fix",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
@@ -49,33 +54,40 @@
   "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": {
-    "@babel/cli": "7.11.6",
-    "@babel/core": "7.11.6",
-    "@babel/node": "^7.12.1",
-    "@babel/plugin-proposal-class-properties": "7.10.4",
-    "@babel/plugin-proposal-export-default-from": "7.10.4",
-    "@babel/plugin-proposal-object-rest-spread": "7.11.0",
-    "@babel/plugin-transform-runtime": "7.11.5",
-    "@babel/preset-env": "7.11.5",
-    "babel-core": "7.0.0-bridge.0",
-    "babel-eslint": "10.1.0",
-    "babel-watch": "^7.0.0",
-    "cross-env": "^7.0.2",
-    "eslint": "^6.8.0",
-    "eslint-config-prettier": "^6.10.0",
-    "eslint-plugin-prettier": "^3.1.2",
-    "glob": "7.1.6",
-    "jest": "^25.1.0",
-    "prettier": "^2.1.2",
-    "regenerator-runtime": "^0.13.7"
+    "@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": {
-    "@babel/runtime": "^7.11.2",
     "libpg-query": "13.3.2",
     "minimist": "^1.2.6",
-    "pgsql-deparser": "^13.6.3",
-    "pgsql-enums": "^13.2.2"
+    "pgsql-deparser": "^13.7.0",
+    "pgsql-enums": "^13.3.0"
   },
-  "gitHead": "36f81b1aa480303b6e778aa90353962439cbfb18"
+  "gitHead": "7d1df1770583c50d0fa68dd0cf90beedc9d46e40"
 }

package/src/cli.js

@@ -0,0 +1,25 @@
+#!/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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,92 @@
+/* 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

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

package/types/index.d.ts

@@ -0,0 +1,5 @@
+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

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