Adds Prettier configuration and Prettier scripts (#95)

TODO: Add a GitHub Action that checks this on every PR.

```
$ npm run prettier:fmt:check
$ npm run prettier:fmt:fix
```

**Once this commit lands, I will add a `.git-blame-ignore-revs` at the
top of the repo with the commit hash for this commit so that git blame
ignores this mega-commit.

Author: davidgomes

.editorconfig

@@ -0,0 +1,2 @@
+[*]
+quote_type = single

.prettierignore

@@ -0,0 +1 @@
+dist

.vscode/settings.json

@@ -26,10 +26,9 @@ const rows = await sql`SELECT * FROM posts WHERE id = ${postId}`;
 
 However, you can customise the return format of the query function using the configuration options `fullResults` and `arrayMode`. These options are available both on the `neon(...)` function and on the query function it returns (but only when the query function is called as an ordinary function, not as a tagged-template function).
 
-
 ### `arrayMode: boolean`
 
-When `arrayMode` is true, rows are returned as an array of arrays instead of an array of objects: 
+When `arrayMode` is true, rows are returned as an array of arrays instead of an array of objects:
 
 ```typescript
 import { neon } from '@neondatabase/serverless';
@@ -43,11 +42,12 @@ Or, with the same effect:
 ```typescript
 import { neon } from '@neondatabase/serverless';
 const sql = neon(process.env.DATABASE_URL);
-const rows = await sql('SELECT * FROM posts WHERE id = $1', [postId], { arrayMode: true });
+const rows = await sql('SELECT * FROM posts WHERE id = $1', [postId], {
+  arrayMode: true,
+});
 // -> [[12, "My post", ...]]
 ```
 
-
 ### `fullResults: boolean`
 
 When `fullResults` is true, additional metadata is returned alongside the result rows, which are then found in the `rows` property of the return value. The metadata matches what would be returned by node-postgres:
@@ -75,11 +75,12 @@ Or, with the same effect:
 ```typescript
 import { neon } from '@neondatabase/serverless';
 const sql = neon(process.env.DATABASE_URL);
-const results = await sql('SELECT * FROM posts WHERE id = $1', [postId], { fullResults: true });
+const results = await sql('SELECT * FROM posts WHERE id = $1', [postId], {
+  fullResults: true,
+});
 // -> { ... same as above ... }
 ```
 
-
 ### `fetchOptions: Record<string, any>`
 
 The `fetchOptions` option can be passed to `neon(...)`, the `transaction` function, or the query function (if not within a `transaction` function). This option takes an object that is merged with the options to the `fetch` call.
@@ -88,7 +89,9 @@ For example, to increase the priority of every database `fetch` request:
 
 ```typescript
 import { neon } from '@neondatabase/serverless';
-const sql = neon(process.env.DATABASE_URL, { fetchOptions: { priority: 'high' } });
+const sql = neon(process.env.DATABASE_URL, {
+  fetchOptions: { priority: 'high' },
+});
 const rows = await sql`SELECT * FROM posts WHERE id = ${postId}`;
 ```
 
@@ -99,14 +102,12 @@ import { neon } from '@neondatabase/serverless';
 const sql = neon(process.env.DATABASE_URL);
 const abortController = new AbortController();
 const timeout = setTimeout(() => abortController.abort('timed out'), 10000);
-const rows = await sql(
-  'SELECT * FROM posts WHERE id = $1', [postId], 
-  { fetchOptions: { signal: abortController.signal } }
-);  // throws an error if no result received within 10s
+const rows = await sql('SELECT * FROM posts WHERE id = $1', [postId], {
+  fetchOptions: { signal: abortController.signal },
+}); // throws an error if no result received within 10s
 clearTimeout(timeout);
 ```
 
-
 ## `transaction(...)` function
 
 The `transaction(queriesOrFn, options)` function is exposed as a property on the query function. It allows multiple queries to be executed within a single, non-interactive transaction.
@@ -120,50 +121,47 @@ import { neon } from '@neondatabase/serverless';
 const sql = neon(process.env.DATABASE_URL);
 const showLatestN = 10;
 
-const [posts, tags] = await sql.transaction([
-  sql`SELECT * FROM posts ORDER BY posted_at DESC LIMIT ${showLatestN}`,
-  sql`SELECT * FROM tags`,
-], { 
-  isolationLevel: 'RepeatableRead',
-  readOnly: true, 
-});
+const [posts, tags] = await sql.transaction(
+  [
+    sql`SELECT * FROM posts ORDER BY posted_at DESC LIMIT ${showLatestN}`,
+    sql`SELECT * FROM tags`,
+  ],
+  {
+    isolationLevel: 'RepeatableRead',
+    readOnly: true,
+  },
+);
 ```
 
 Or as an example of the function case:
 
 ```javascript
-const [authors, tags] = await neon(process.env.DATABASE_URL)
-  .transaction(txn => [
-    txn`SELECT * FROM authors`,
-    txn`SELECT * FROM tags`,
-  ]);
+const [authors, tags] = await neon(process.env.DATABASE_URL).transaction(
+  (txn) => [txn`SELECT * FROM authors`, txn`SELECT * FROM tags`],
+);
 ```
 
 The optional second argument to `transaction()`, `options`, has the same keys as the options to the ordinary query function -- `arrayMode`, `fullResults` and `fetchOptions` -- plus three additional keys that concern the transaction configuration. These transaction-related keys are: `isolationMode`, `readOnly` and `deferrable`. They are described below. Defaults for the transaction-related keys can also be set as options to the `neon` function.
 
 The `fetchOptions` option cannot be supplied for individual queries inside `transaction()`, since only a single `fetch` is performed for the transaction as a whole. The TypeScript types also currently do not allow `arrayMode` or `fullResults` options to be supplied for individual queries within `transaction()` (although this does have the expected effect if the type errors are ignored).
 
-
 ### `isolationMode`
 
 This option selects a Postgres [transaction isolation mode](https://www.postgresql.org/docs/current/transaction-iso.html). If present, it must be one of: `'ReadUncommitted'`, `'ReadCommitted'`, `'RepeatableRead'` or `'Serializable'`.
 
-
 ### `readOnly`
 
 If `true`, this option ensures that a `READ ONLY` transaction is used to execute the queries passed.
 
-
 ### `deferrable`
 
 If `true` (and if `readOnly` is also `true`, and `isolationMode` is `'Serializable'`), this option ensures that a `DEFERRABLE` transaction is used to execute the queries passed.
 
-
 ## `neonConfig` configuration
 
 In most cases, there are two ways to set configuration options:
 
-1. Import `neonConfig` from the package and set global default options on that. 
+1. Import `neonConfig` from the package and set global default options on that.
 2. Set options on individual `Client` instances using their `neonConfig` property.
 
 For example:
@@ -182,7 +180,6 @@ client.neonConfig.webSocketConstructor = ws;
 
 A few configuration options can only be set globally, and these are noted as such below.
 
-
 #### `webSocketConstructor: typeof WebSocket | undefined`
 
 Set this parameter if you're using the driver in an environment where the `WebSocket` global is not defined, such as Node.js, and you need transaction or session support.
@@ -192,15 +189,13 @@ For example:
 ```javascript
 import { neonConfig } from '@neondatabase/serverless';
 import ws from 'ws';
-neonConfig.webSocketConstructor = ws; 
+neonConfig.webSocketConstructor = ws;
 ```
 
-
 ### Advanced configuration
 
 If you're using `@neondatabase/serverless` to connect to a Neon database, you usually **won't** need to touch the following configuration options. These options are intended for testing, troubleshooting, and supporting access to non-Neon Postgres instances via self-hosted WebSocket proxies.
 
-
 #### `poolQueryViaFetch: boolean`
 
 **Experimentally**, when `poolQueryViaFetch` is `true` and no listeners for the `"connect"`, `"acquire"`, `"release"` or `"remove"` events are set on the `Pool`, queries via `Pool.query()` will be sent by low-latency HTTP `fetch` request.
@@ -209,10 +204,9 @@ Default: currently `false` (but may be `true` in future).
 
 Note: this option can only be set globally, **not** on an individual `Client` instance.
 
-
 #### `fetchEndpoint: string | ((host: string, port: number | string) => string)`
 
-Set `fetchEndpoint` to set the server endpoint to be sent queries via http fetch. 
+Set `fetchEndpoint` to set the server endpoint to be sent queries via http fetch.
 
 This may be useful for local development (e.g. to set a port that's not the default 443).
 
@@ -222,7 +216,6 @@ Default: `host => 'https://' + host + '/sql'`
 
 Note: this option can only be set globally, **not** on an individual `Client` instance.
 
-
 #### `fetchFunction: any`
 
 The `fetchFunction` option allows you to supply an alternative function for making http requests. The function must accept the same arguments as native `fetch`.
@@ -231,55 +224,50 @@ Default: `undefined`.
 
 Note: this option can only be set globally, **not** on an individual `Client` instance.
 
-
 #### `wsProxy: string | (host: string, port: number | string) => string`
 
 If connecting to a non-Neon database, the `wsProxy` option should point to [your WebSocket proxy](DEPLOY.md). It can either be a string, which will have `?address=host:port` appended to it, or a function with the signature `(host: string, port: number | string) => string`. Either way, the protocol must _not_ be included, because this depends on other options. For example, when using the `wsproxy` proxy, the `wsProxy` option should look something like this:
 
 ```javascript
 // either:
-neonConfig.wsProxy = (host, port) => `my-wsproxy.example.com/v1?address=${host}:${port}`
+neonConfig.wsProxy = (host, port) =>
+  `my-wsproxy.example.com/v1?address=${host}:${port}`;
 // or (with identical effect):
 neonConfig.wsProxy = 'my-wsproxy.example.com/v1';
 ```
 
 Default: `host => host + '/v2'`.
 
-
 #### `pipelineConnect: "password" | false`
 
-To speed up connection times, the driver will pipeline the first three messages to the database (startup, authentication and first query) if `pipelineConnect` is set to `"password"`. Note that this will only work if you've configured cleartext password authentication for the relevant user and database. 
+To speed up connection times, the driver will pipeline the first three messages to the database (startup, authentication and first query) if `pipelineConnect` is set to `"password"`. Note that this will only work if you've configured cleartext password authentication for the relevant user and database.
 
 If your connection doesn't support password authentication, set `pipelineConnect` to `false` instead.
 
 Default: `"password"`.
 
-
 #### `coalesceWrites: boolean`
 
 When this option is `true`, multiple network writes generated in a single iteration of the JavaScript run-loop are coalesced into a single WebSocket message. Since node-postgres sends a lot of very short messages, this may reduce TCP/IP overhead.
 
 Default: `true`.
 
-
 #### `forceDisablePgSSL: boolean`
 
 This option disables TLS encryption in the Postgres protocol (as set via e.g. `?sslmode=require` in the connection string). Security is not compromised if used in conjunction with `useSecureWebSocket = true`.
 
 Default: `true`.
 
-
 #### `useSecureWebSocket: boolean`
 
-This option switches between secure (the default) and insecure WebSockets. 
+This option switches between secure (the default) and insecure WebSockets.
 
 To use experimental pure-JS encryption, set `useSecureWebSocket = false` and `forceDisablePgSSL = false`, and append `?sslmode=verify-full` to your database connection string.
 
 **Remember that pure-JS encryption is currently experimental and not suitable for use in production.**
 
 Default: `true`.
 
-
 #### `subtls: any`
 
 **Only when using experimental pure-JS TLS encryption**, you must supply the [subtls](https://github.com/jawj/subtls) TLS library to the `subtls` option like so:
@@ -292,7 +280,6 @@ neonConfig.subtls = subtls;
 
 Default: `undefined`.
 
-
 #### `rootCerts: string /* PEM format */`
 
 **Only when using experimental pure-JS TLS encryption**, the `rootCerts` option determines what root (certificate authority) certificates are trusted.
@@ -301,7 +288,6 @@ Its value is a string containing zero or more certificates in PEM format.
 
 Default: `""` (the empty string).
 
-
 #### `pipelineTLS: boolean`
 
 **Only when using experimental pure-JS encryption**, the driver will pipeline the SSL request message and TLS Client Hello if `pipelineTLS` is set to `true`. Currently, this is only supported by Neon database hosts, and will fail when communicating with an ordinary Postgres or pgbouncer back-end.

CONFIG.md

@@ -10,11 +10,10 @@ There are then two ways you can secure this:
 
 1. Set up nginx as a TLS proxy in front of `wsproxy`. Example shell commands to achieve this can be found below. Onward traffic to Postgres is not secured by this method, so Postgres should be running on the same machine or be reached over a private network.
 
-2. Use experimental pure-JS Postgres connection encryption via [subtls](https://github.com/jawj/subtls). There's no need for nginx in this scenario, and the Postgres connection is encrypted end-to-end. You get this form of encryption if you set both `neonConfig.useSecureWebSocket`  and `neonConfig.forceDisablePgSSL` to `false`, and append `?sslmode=verify-full` (or similar) to your connection string. TLS version 1.3 must be supported by the Postgres back-end. **Please note that subtls is experimental software and this configuration is not recommended for production use.**
+2. Use experimental pure-JS Postgres connection encryption via [subtls](https://github.com/jawj/subtls). There's no need for nginx in this scenario, and the Postgres connection is encrypted end-to-end. You get this form of encryption if you set both `neonConfig.useSecureWebSocket` and `neonConfig.forceDisablePgSSL` to `false`, and append `?sslmode=verify-full` (or similar) to your connection string. TLS version 1.3 must be supported by the Postgres back-end. **Please note that subtls is experimental software and this configuration is not recommended for production use.**
 
 Second, you'll need to set some [configuration options](CONFIG.md) on this package: at a minimum the `wsProxy` option and (if using experimental encryption) `subtls` and `rootCerts`.
 
-
 ## Example shell commands
 
 To deploy `wsproxy` behind nginx (for TLS) on a host `ws.example.com` running Ubuntu 22.04 (and Postgres locally), you'd do something similar to the following.
@@ -88,7 +87,7 @@ apt install -y golang nginx certbot python3-certbot-nginx
 
 echo "127.0.0.1 ${HOSTDOMAIN}" >> /etc/hosts
 
-echo "                                                                       
+echo "
 server {
   listen 80;
   listen [::]:80;
@@ -100,7 +99,7 @@ server {
     proxy_set_header Host \$host;
   }
 }
-" > /etc/nginx/sites-available/wsproxy   
+" > /etc/nginx/sites-available/wsproxy
 
 ln -s /etc/nginx/sites-available/wsproxy /etc/nginx/sites-enabled/wsproxy
 
@@ -130,4 +129,4 @@ server {
 " > /etc/nginx/sites-available/wsproxy
 
 service nginx restart
-```
+```