Use postgres.js

- Remove the bundled version of node-postgres

- Bundle a modified version of postgres.js instead, and use it for
  sqltyper's own purposes

- Add code generation for postgres.js with the `-t postgres` CLI option

- Add tests for the CLI

Author: akheron

.circleci/config.yml

@@ -16,6 +16,10 @@ jobs:
           POSTGRES_PASSWORD: sqltyper
 
     steps:
+      # Install psql
+      - run: sudo apt-get update
+      - run: sudo apt-get install postgresql-client-9.6
+
       - checkout
 
       # Restore bundle cache

.eslintignore

@@ -0,0 +1,2 @@
+dist/
+src/postgres/

.eslintrc.js

@@ -8,6 +8,13 @@ module.exports = {
     'plugin:@typescript-eslint/recommended',
   ],
   rules: {
+    '@typescript-eslint/ban-types': [
+      'error',
+      {
+        types: { '{}': false },
+        extendDefaults: true,
+      }
+    ],
     '@typescript-eslint/explicit-function-return-type': 'off',
     '@typescript-eslint/member-delimiter-style': [
       'error',

.prettierignore

@@ -1 +1,3 @@
+package.json
 dist/
+src/postgres/

README.md

@@ -66,23 +66,20 @@ perfectly safe to use it with any query.
 ## Installation
 
 ```
-npm install --save pg
 npm install --save-dev sqltyper
 ```
 
-Or:
+The generated TypeScript code uses [node-postgres] or [postgres.js] to execute
+the queries, so either `pg` or `postgres` is a required runtime dependency:
 
 ```
-yarn add pg
-yarn add --dev sqltyper
+npm install --save pg
+# or
+npm install --save postgres@beta
 ```
 
-sqltyper generates TypeScript code, so it isn't needed on
-application runtime. However, the generated TypeScript code uses
-[node-postgres] to execute the queries, so `pg` is a required runtime
-dependency.
-
-[node-postgres]: https://node-postgres.com/
+At the time of writing, you need to install the `@beta` verson of postgres.js to
+get TypeScript support.
 
 ## Tutorial
 
@@ -101,9 +98,9 @@ src/
 Run sqltyper on the `sqls` directory:
 
 ```
-yarn sqltyper --database postgres://user:pass@host/dbname src/sqls
+npx sqltyper --database postgres://user:pass@host/dbname src/sqls
 
-# or npx sqltyper, or ./node_modules/.bin/sqltyper, ...
+# or yarn sqltyper, or ./node_modules/.bin/sqltyper, ...
 ```
 
 sqltyper connects to the PostgreSQL database you give in the
@@ -194,7 +191,21 @@ nullability. Default: `false`.
 Watch files and run the conversion when something changes. Default:
 `false`.
 
-`--check`, `-c`
+`--target`, `-t`
+
+Whether to generate code for `pg` ([node-postgres]) or `postgres`
+([postgres.js]). Default: `pg`.
+
+`--module`, `-m`
+
+Where to import node-postgres or postgres.js from. Default: `pg` for
+node-postgres, `postgres` for postgres.js.
+
+`--pg-module` (deprecated)
+
+Alias of `--module`.
+
+`--check`,`-c`
 
 Check whether all output files are up-to-date without actually
 updating them. If they are, exit with status 0, otherwise exit with
@@ -210,10 +221,6 @@ installed and configured for your project. Default: `false`.
 Whether to generate and `index.ts` file that re-exports all the
 generated functions. Default: `true`.
 
-`--pg-module`
-
-Where to import node-postgres from. Default: `pg`.
-
 [connecting logic]: https://node-postgres.com/features/connecting
 [libpq environment variables]: https://www.postgresql.org/docs/current/libpq-envars.html
 [prettier]: https://prettier.io/
@@ -259,4 +266,6 @@ does more or less the same as sqltyper, but for Scala, and is designed
 to be used with MySQL. It uses JDBC, and is implemented as a Scala
 macro rather than an offline code generation tool.
 
+[node-postgres]: https://node-postgres.com/
+[postgres.js]: https://github.com/porsager/postgres
 [sqlτyped]: https://github.com/jonifreeman/sqltyped

jest.config.js

@@ -1,5 +1,10 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
-  testPathIgnorePatterns: ['/node_modules/', '/dist/'],
+  testPathIgnorePatterns: [
+    '/node_modules/',
+    '<rootDir>/dist/',
+    '<rootDir>/src/postgres/',
+  ],
+  modulePathIgnorePatterns: ['<rootDir>/dist'],
 }

package.json

@@ -6,25 +6,18 @@
   "repository": "https://github.com/akheron/sqltyper",
   "author": "Petri Lehtinen <petri@digip.org>",
   "license": "MIT",
-  "keywords": [
-    "database",
-    "postgres",
-    "postgresql",
-    "typescript"
-  ],
-  "files": [
-    "dist"
-  ],
+  "keywords": ["database", "postgres", "postgresql", "typescript"],
+  "files": ["dist"],
   "bin": {
     "sqltyper": "dist/src/cli.js"
   },
   "scripts": {
-    "sql": "ts-node src/cli.ts --prettify --pg-module ../pg src/sql/",
+    "sql": "ts-node src/cli.ts --target postgres --module '../postgres' --prettify src/sql/",
     "sql:check": "yarn run sql --check",
     "sql:watch": "yarn run sql --watch",
     "lint": "eslint '**/*.ts' && prettier --check \"**/*.{json,md}\"",
     "lint:fix": "eslint --fix '**/*.ts' && prettier --write '**/*.{json,md}'",
-    "build": "tsc",
+    "build": "tsc -p tsconfig.dist.json",
     "clean": "rm -rf dist/",
     "prepublishOnly": "yarn clean && yarn build",
     "test": "jest"
@@ -51,10 +44,6 @@
     "fp-ts": "^2.5.3",
     "node-watch": "^0.6.3",
     "packet-reader": "^1.0.0",
-    "pg-connection-string": "^2.2.0",
-    "pg-pool": "^3.0.0",
-    "pg-types": "^3.0.0",
-    "pgpass": "^1.0.2",
     "ramda": "^0.27.0",
     "typed-parser": "^0.1.4",
     "typescript": "^3.8.3",

src/cli.ts

@@ -17,6 +17,7 @@ import { pipe } from 'fp-ts/lib/pipeable'
 import * as yargs from 'yargs'
 
 import { Clients, connect, disconnect } from './clients'
+import { CodegenTarget, codegenTargets } from './codegen'
 import {
   sqlToStatementDescription,
   generateTSCode,
@@ -31,7 +32,8 @@ type Options = {
   verbose: boolean
   index: boolean
   prettify: boolean
-  pgModule: string
+  target: CodegenTarget
+  module: string
   terminalColumns: number | undefined
 }
 
@@ -51,7 +53,8 @@ async function main(): Promise<number> {
     verbose: args.verbose,
     index: args.index,
     prettify: args.prettify,
-    pgModule: args['pg-module'],
+    target: args.target,
+    module: args.module ?? args['pg-module'] ?? args.target,
     terminalColumns: process.stdout.columns,
   }
 
@@ -68,7 +71,7 @@ async function main(): Promise<number> {
   const clients = await connect(args.database)
   if (Either.isLeft(clients)) {
     console.error(clients.left)
-    throw process.exit(1)
+    return 1
   }
 
   let status = 0
@@ -87,7 +90,13 @@ Some files are out of date!`)
       status = 1
     }
   } else {
-    await processDirectories(clients.right, fileExtensions, dirPaths, options)()
+    const moduleDirs = await processDirectories(
+      clients.right,
+      fileExtensions,
+      dirPaths,
+      options
+    )()
+    if (moduleDirs.some(moduleDir => moduleDir.hasErrors)) status = 1
   }
 
   await disconnect(clients.right)
@@ -130,6 +139,18 @@ function parseArgs() {
       type: 'boolean',
       default: false,
     })
+    .option('target', {
+      alias: 't',
+      description:
+        'Postgres client library to use in generated TypeScript code',
+      choices: codegenTargets,
+      default: codegenTargets[0],
+    })
+    .option('module', {
+      alias: 'm',
+      description: 'Where to import node-postgres or postgres.js from.',
+      type: 'string',
+    })
     .option('check', {
       alias: 'c',
       description:
@@ -146,9 +167,9 @@ function parseArgs() {
       default: false,
     })
     .option('pg-module', {
-      description: 'Where to import node-postgres from.',
+      description:
+        'Where to import node-postgres from. (deprecated, use --module instead)',
       type: 'string',
-      default: 'pg',
     })
     .epilogue(
       `\
@@ -246,7 +267,11 @@ async function handleWatchEvents(
     moduleDirs = pipe(
       modifyWhere(
         moduleDir => moduleDir.dirPath === dirPath,
-        moduleDir => ({ dirPath: moduleDir.dirPath, modules: newModules }),
+        moduleDir => ({
+          dirPath: moduleDir.dirPath,
+          modules: newModules,
+          hasErrors: moduleDir.hasErrors,
+        }),
         moduleDirs
       ),
       Option.getOrElse(() => moduleDirs)
@@ -362,9 +387,13 @@ function processDirectories(
         (dirPath, tsModules) => processSQLDirectory(dirPath, tsModules, options)
       )
     ),
-    Task.map(result => {
-      console.log('done.')
-      return result
+    Task.map(moduleDirs => {
+      if (moduleDirs.some(moduleDir => moduleDir.hasErrors)) {
+        console.log('Compilation failed.')
+      } else {
+        console.log('done.')
+      }
+      return moduleDirs
     })
   )
 }
@@ -436,7 +465,8 @@ function processSQLFile(
     TaskEither.chain(source =>
       generateTSCode(clients, path.basename(filePath), source, fnName, {
         prettierFileName: options.prettify ? tsPath : undefined,
-        pgModule: options.pgModule,
+        target: options.target,
+        module: options.module,
       })
     ),
     TaskEither.chain(tsCode => async () => {
@@ -474,14 +504,15 @@ function processSQLDirectory(
   options: Options
 ): Task.Task<TsModuleDir> {
   const successfulModules = pipe(modules, Array.filterMap(identity))
+  const hasErrors = modules.some(Option.isNone)
   return pipe(
     maybeWriteIndexModule(
       options.index,
       dirPath,
       successfulModules,
       options.prettify
     ),
-    Task.map(modules => ({ dirPath, modules }))
+    Task.map(modules => ({ hasErrors, dirPath, modules }))
   )
 }
 

src/clients.ts

@@ -1,40 +1,40 @@
 import * as Either from 'fp-ts/lib/Either'
 
-import * as pg from './pg'
+import * as postgres from './postgres'
 import { SchemaClient, schemaClient } from './schema'
 import { TypeClient, typeClient } from './tstype'
 
 export type Clients = {
-  pg: pg.Client
+  postgres: postgres.Sql<{}>
   schema: SchemaClient
   types: TypeClient
 }
 
 export async function connect(
   connectionString?: string | undefined
 ): Promise<Either.Either<string, Clients>> {
-  const pgClient = new pg.Client(
-    connectionString == null ? undefined : { connectionString }
-  )
-  try {
-    await pgClient.connect()
-  } catch (err) {
-    return Either.left(`Error connecting to database: ${err.message}`)
-  }
+  const postgresClient = connectionString
+    ? postgres(connectionString)
+    : postgres()
 
-  const schema = schemaClient(pgClient)
-  const types = await typeClient(pgClient)
+  return Either.right(await clients(postgresClient))
+}
 
-  return Either.right({ pg: pgClient, schema, types })
+export async function clients(
+  postgresClient: postgres.Sql<{}>
+): Promise<Clients> {
+  const schema = schemaClient(postgresClient)
+  const types = await typeClient(postgresClient)
+  return { postgres: postgresClient, schema, types }
 }
 
 export async function disconnect(clients: Clients): Promise<void> {
-  await clients.pg.end()
+  await clients.postgres.end({ timeout: 5 })
 }
 
 export async function clearCache(clients: Clients): Promise<Clients> {
   // The type client caches stuff about user-defined SQL types.
   // Recreate it to clear the cache.
-  const types = await typeClient(clients.pg)
+  const types = await typeClient(clients.postgres)
   return { ...clients, types }
 }