Basics working

Author: thdxr

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+dist

jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  transform: {
+    "\\.ts$": "esbuild-runner/jest",
+  },
+};

module-fixup.sh

@@ -0,0 +1,11 @@
+cat > dist/cjs/package.json <<!EOF
+{
+    "type": "commonjs"
+}
+!EOF
+
+cat > dist/esm/package.json <<!EOF
+{
+    "type": "module"
+}
+!EOF

package.json

@@ -0,0 +1,34 @@
+{
+  "name": "kysely-data-api",
+  "version": "0.0.1",
+  "repository": "git@github.com:serverless-stack/kysely-data-api.git",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "license": "MIT",
+  "scripts": {
+    "clean": "rm -rf dist && rm -rf test/dist",
+    "build": "yarn clean && yarn build:esm && yarn build:cjs && ./module-fixup.sh",
+    "build:esm": "tsc -p tsconfig-esm.json",
+    "build:cjs": "tsc -p tsconfig-cjs.json"
+  },
+  "devDependencies": {
+    "@tsconfig/node14": "^1.0.1",
+    "@types/jest": "^27.0.2",
+    "@types/node": "^16.11.0",
+    "aws-sdk": "^2.1008.0",
+    "esbuild": "^0.13.6",
+    "esbuild-runner": "^2.2.1",
+    "jest": "^27.2.5",
+    "kysely": "^0.6.2"
+  },
+  "peerDependencies": {
+    "aws-sdk": "^2.1008.0",
+    "kysely": "^0.6.2"
+  }
+}

src/data-api-dialect.ts

@@ -0,0 +1,34 @@
+import { Driver } from "kysely";
+import { Kysely } from "kysely";
+import { QueryCompiler } from "kysely";
+import { Dialect } from "kysely";
+import { DatabaseIntrospector } from "kysely";
+import { PostgresIntrospector } from "kysely";
+import { DataApiDriver, DataApiDriverConfig } from "./data-api-driver";
+import { DataApiQueryCompiler } from "./data-api-query-compiler";
+
+type DataApiDialectConfig = {
+  driver: DataApiDriverConfig;
+};
+
+export class DataApiDialect implements Dialect {
+  #config: DataApiDialectConfig;
+
+  constructor(config: DataApiDialectConfig) {
+    this.#config = config;
+  }
+
+  createDriver(): Driver {
+    return new DataApiDriver(this.#config.driver);
+  }
+
+  createQueryCompiler(): QueryCompiler {
+    // The default query compiler is for postgres dialect.
+    return new DataApiQueryCompiler();
+  }
+
+  createIntrospector(db: Kysely<any>): DatabaseIntrospector {
+    console.log("Introspector");
+    return new PostgresIntrospector(db);
+  }
+}

src/data-api-driver.ts

@@ -0,0 +1,127 @@
+import { DatabaseConnection, QueryResult } from "kysely";
+import { Driver } from "kysely";
+import { CompiledQuery } from "kysely";
+import * as RDSDataService from "aws-sdk/clients/rdsdataservice";
+
+export type DataApiDriverConfig = {
+  client: RDSDataService;
+  secretArn: string;
+  resourceArn: string;
+  database: string;
+};
+
+export class DataApiDriver extends Driver {
+  #config: DataApiDriverConfig;
+
+  constructor(config: DataApiDriverConfig) {
+    super();
+    this.#config = config;
+  }
+
+  protected override async init(): Promise<void> {}
+
+  protected override async acquireConnection(): Promise<DatabaseConnection> {
+    return new DataApiConnection(this.#config);
+  }
+
+  override async beginTransaction(conn: DataApiConnection) {
+    await conn.beginTransaction();
+  }
+
+  override async commitTransaction(conn: DataApiConnection) {
+    await conn.commitTransaction();
+  }
+
+  override async rollbackTransaction(conn: DataApiConnection) {
+    await conn.rollbackTransaction();
+  }
+
+  protected override async releaseConnection(
+    _connection: DatabaseConnection
+  ): Promise<void> {}
+
+  protected override async destroy(): Promise<void> {}
+}
+
+class DataApiConnection implements DatabaseConnection {
+  #config: DataApiDriverConfig;
+  #transactionId?: string;
+
+  constructor(config: DataApiDriverConfig) {
+    this.#config = config;
+  }
+
+  async beginTransaction() {
+    const r = await this.#config.client
+      .beginTransaction({
+        secretArn: this.#config.secretArn,
+        resourceArn: this.#config.resourceArn,
+        database: this.#config.database,
+      })
+      .promise();
+    this.#transactionId = r.transactionId;
+  }
+
+  async commitTransaction() {
+    if (!this.#transactionId)
+      throw new Error("Cannot commit a transaction before creating it");
+    await this.#config.client
+      .commitTransaction({
+        secretArn: this.#config.secretArn,
+        resourceArn: this.#config.resourceArn,
+        transactionId: this.#transactionId,
+      })
+      .promise();
+  }
+
+  async rollbackTransaction() {
+    if (!this.#transactionId)
+      throw new Error("Cannot rollback a transaction before creating it");
+    await this.#config.client
+      .rollbackTransaction({
+        secretArn: this.#config.secretArn,
+        resourceArn: this.#config.resourceArn,
+        transactionId: this.#transactionId,
+      })
+      .promise();
+  }
+
+  async executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>> {
+    const r = await this.#config.client
+      .executeStatement({
+        transactionId: this.#transactionId,
+        secretArn: this.#config.secretArn,
+        resourceArn: this.#config.resourceArn,
+        sql: compiledQuery.sql,
+        parameters: compiledQuery.bindings as any,
+        database: this.#config.database,
+        includeResultMetadata: true,
+      })
+      .promise();
+    if (!r.columnMetadata) {
+      return {
+        numUpdatedOrDeletedRows: r.numberOfRecordsUpdated,
+      };
+    }
+    const rows = r.records
+      ?.filter((r) => r.length !== 0)
+      .map(
+        (rec) =>
+          Object.fromEntries(
+            rec.map((val, i) => [
+              r.columnMetadata![i].name,
+              val.stringValue ||
+                val.blobValue ||
+                val.longValue ||
+                val.arrayValue ||
+                val.doubleValue ||
+                (val.isNull ? null : val.booleanValue),
+            ])
+          ) as O
+      );
+    const result: QueryResult<O> = {
+      rows,
+    };
+    return result;
+  }
+}

src/data-api-query-compiler.ts

@@ -0,0 +1,41 @@
+import { Field } from "aws-sdk/clients/rdsdataservice";
+import { DefaultQueryCompiler } from "kysely";
+
+export class DataApiQueryCompiler extends DefaultQueryCompiler {
+  protected override appendValue(value: any) {
+    const name = this.numBindings;
+    this.append(this.getCurrentParameterPlaceholder());
+    this.addBinding({
+      name: name.toString(),
+      value: serialize(value),
+    });
+  }
+
+  protected override getCurrentParameterPlaceholder() {
+    return ":" + this.numBindings;
+  }
+}
+
+function serialize(value: any): Field {
+  if (value == null) return { isNull: true };
+  switch (typeof value) {
+    case "number":
+      return {
+        longValue: value,
+      };
+    case "bigint":
+      return {
+        doubleValue: Number(value),
+      };
+    case "string":
+      return {
+        stringValue: value,
+      };
+    case "boolean":
+      return {
+        booleanValue: value,
+      };
+  }
+
+  throw "wtf";
+}

src/index.ts

@@ -0,0 +1 @@
+export * from "./data-api-dialect";

test/harness.ts

@@ -0,0 +1,98 @@
+import RDSDataService from "aws-sdk/clients/rdsdataservice";
+import { Kysely } from "kysely";
+import { DataApiDialect } from "../src";
+import { DataApiDriverConfig } from "../src/data-api-driver";
+
+const TEST_DATABASE = "scratch";
+
+const opts: DataApiDriverConfig = {
+  client: new RDSDataService(),
+  database: TEST_DATABASE,
+  secretArn: process.env.RDS_SECRET,
+  resourceArn: process.env.RDS_ARN,
+};
+const dialect = new DataApiDialect({
+  driver: opts,
+});
+
+interface Person {
+  id: number;
+  first_name: string;
+  last_name: string;
+  gender: "male" | "female" | "other";
+}
+
+interface Pet {
+  id: number;
+  name: string;
+  owner_id: number;
+  species: "dog" | "cat";
+}
+
+interface Movie {
+  id: string;
+  stars: number;
+}
+
+// Keys are table names.
+interface Database {
+  person: Person;
+  pet: Pet;
+  movie: Movie;
+}
+
+export const db = new Kysely<Database>({ dialect });
+
+export async function reset() {
+  await opts.client
+    .executeStatement({
+      sql: `
+      SELECT pg_terminate_backend(pid) FROM  pg_stat_activity WHERE pid <> pg_backend_pid() AND datname = '${TEST_DATABASE}'`,
+      database: "postgres",
+      secretArn: opts.secretArn,
+      resourceArn: opts.resourceArn,
+    })
+    .promise();
+
+  await opts.client
+    .executeStatement({
+      sql: `DROP DATABASE IF EXISTS ${TEST_DATABASE}`,
+      database: "postgres",
+      secretArn: opts.secretArn,
+      resourceArn: opts.resourceArn,
+    })
+    .promise();
+
+  await opts.client
+    .executeStatement({
+      sql: `CREATE DATABASE ${TEST_DATABASE}`,
+      database: "postgres",
+      secretArn: opts.secretArn,
+      resourceArn: opts.resourceArn,
+    })
+    .promise();
+
+  await db.schema
+    .createTable("person")
+    .addColumn("id", "integer", (col) => col.increments().primaryKey())
+    .addColumn("first_name", "varchar")
+    .addColumn("last_name", "varchar")
+    .addColumn("gender", "varchar(50)")
+    .execute();
+
+  await db.schema
+    .createTable("pet")
+    .addColumn("id", "integer", (col) => col.increments().primaryKey())
+    .addColumn("name", "varchar", (col) => col.notNull().unique())
+    .addColumn("owner_id", "integer", (col) =>
+      col.references("person.id").onDelete("cascade")
+    )
+    .addColumn("species", "varchar")
+    .execute();
+
+  await db.schema
+    .createIndex("pet_owner_id_index")
+    .on("pet")
+    .column("owner_id")
+    .execute();
+}