Neon Serverless Connection

package.json

@@ -31,11 +31,14 @@
     "author": "Outerbase",
     "license": "MIT",
     "dependencies": {
-        "handlebars": "^4.7.8"
+        "@neondatabase/serverless": "^0.9.3",
+        "handlebars": "^4.7.8",
+        "ws": "^8.17.1"
     },
     "devDependencies": {
         "@jest/globals": "^29.7.0",
         "@types/node": "^20.12.12",
+        "@types/ws": "^8.5.10",
         "husky": "^9.0.11",
         "jest": "^29.7.0",
         "lint-staged": "^15.2.4",

playground/index.js

@@ -1,11 +1,28 @@
-import { CloudflareD1Connection, Outerbase, OuterbaseConnection, equalsNumber } from '../dist/index.js';
+import { CloudflareD1Connection, Outerbase, NeonHttpConnection, OuterbaseConnection, equalsNumber } from '../dist/index.js';
 import express from 'express';
 
 const app = express();
 const port = 4000;
 
 app.get('/', async (req, res) => {
-    const data = {}
+    // Establish connection to your provider database
+    const d1 = new CloudflareD1Connection('API_KEY', 'ACCOUNT_ID', 'DATABASE_ID');
+    const neon = new NeonHttpConnection({
+        databaseUrl: 'postgresql://USER:[email protected]/neondb?sslmode=require'
+    });
+
+    // Create an Outerbase instance from the data connection
+    await neon.connect();
+    const db = Outerbase(neon);
+
+    // SELECT:
+    // let { data, query } = await db.selectFrom([
+    //     { table: 'playing_with_neon', columns: ['id', 'name', 'value'] }
+    // ])
+    // .where(equalsNumber('id', 1))
+    // .query()
+
+    let { data } = await db.queryRaw('SELECT * FROM playing_with_neon WHERE id = $1', ['1']);
     res.json(data);
 });
 

src/connections/neon-http.ts

@@ -0,0 +1,86 @@
+import { Client } from '@neondatabase/serverless';
+import ws from 'ws';
+import { Connection } from './index';
+import { Query, constructRawQuery } from '../query';
+import { QueryParamsPositional, QueryType } from '../query-params';
+
+export type NeonConnectionDetails = {
+    databaseUrl: string
+};
+
+export class NeonHttpConnection implements Connection {
+    databaseUrl: string;
+    client: Client;
+
+    // Default query type to named for Outerbase
+    queryType = QueryType.positional
+
+    /**
+     * Creates a new NeonHttpConnection object with the provided API key,
+     * account ID, and database ID.
+     * 
+     * @param databaseUrl - The URL to the database to be used for the connection.
+     */
+    constructor(private _: NeonConnectionDetails) {
+        this.databaseUrl = _.databaseUrl;
+
+        this.client = new Client(this.databaseUrl);
+        this.client.neonConfig.webSocketConstructor = ws;
+    }
+
+    /**
+     * Performs a connect action on the current Connection object.
+     * 
+     * @param details - Unused in the Neon scenario.
+     * @returns Promise<any>
+     */
+    async connect(): Promise<any> {
+        return this.client.connect();
+    }
+
+    /**
+     * Performs a disconnect action on the current Connection object.
+     * 
+     * @returns Promise<any>
+     */
+    async disconnect(): Promise<any> {
+        return this.client.end();
+    }
+
+    /**
+     * Triggers a query action on the current Connection object. The query
+     * is a SQL query that will be executed on a Neon database. Neon's driver
+     * requires positional parameters to be used in the specific format of `$1`,
+     * `$2`, etc. The query is sent to the Neon database and the response is returned.
+     * 
+     * @param query - The SQL query to be executed.
+     * @param parameters - An object containing the parameters to be used in the query.
+     * @returns Promise<{ data: any, error: Error | null }>
+     */
+    async query(query: Query): Promise<{ data: any; error: Error | null; query: string }> {
+        let items = null
+        let error = null
+
+        // Replace all `?` with `$1`, `$2`, etc.
+        let index = 0;
+        const formattedQuery = query.query.replace(/\?/g, () => `$${++index}`);
+
+        try {
+            await this.client.query('BEGIN');
+            const { rows } = await this.client.query(formattedQuery, query.parameters as QueryParamsPositional);
+            items = rows;
+            await this.client.query('COMMIT');
+        } catch (error) {
+            await this.client.query('ROLLBACK');
+            throw error;
+        }
+
+        const rawSQL = constructRawQuery(query)
+
+        return {
+            data: items,
+            error: error,
+            query: rawSQL
+        };
+    }
+};

src/index.ts

@@ -1,6 +1,7 @@
 export * from './connections';
 export * from './connections/outerbase';
 export * from './connections/cloudflare';
+export * from './connections/neon-http';
 export * from './client';
 export * from './models';
 export * from './models/decorators';

tests/connections/neon.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from '@jest/globals'
+
+import { NeonHttpConnection } from 'src/connections/neon-http'
+import { QueryType } from 'src/query-params'
+
+describe('NeonHttpConnection', () => {
+    describe('Query Type', () => {
+        const connection = new NeonHttpConnection({
+            databaseUrl: 'postgresql://USER:[email protected]/neondb?sslmode=require'
+        })
+
+        test('Query type is set to positional', () => {
+            expect(connection.queryType).toBe(QueryType.positional)
+        })
+
+        test('Query type is set not named', () => {
+            expect(connection.queryType).not.toBe(QueryType.named)
+        })
+    })
+})