Query compiler support for Date & typeHint (#5)

* Added Date object and typeHint support to query compiler.
Adjust DATE, TIME & TIMESTAMP automatically to accepted format.
Configured ESLint.

* Fixed conflicts.

* Restored .js imports.

Author: karmux

src/data-api-dialect.ts

@@ -46,7 +46,7 @@ export class DataApiDialect implements Dialect {
     throw new Error("Unknown mode " + this.#config.mode);
   }
 
-  createIntrospector(db: Kysely<any>): DatabaseIntrospector {
+  createIntrospector(db: Kysely<unknown>): DatabaseIntrospector {
     if (this.#config.mode === "postgres") return new PostgresIntrospector(db);
     if (this.#config.mode === "mysql") return new MysqlIntrospector(db);
 

src/data-api-driver.ts

@@ -1,7 +1,7 @@
 import { DatabaseConnection, QueryResult } from "kysely";
 import { Driver } from "kysely";
 import { CompiledQuery } from "kysely";
-import * as RDSDataService from "aws-sdk/clients/rdsdataservice.js";
+import RDSDataService, { SqlParametersList } from "aws-sdk/clients/rdsdataservice.js";
 
 export type DataApiDriverConfig = {
   client: RDSDataService;
@@ -17,7 +17,9 @@ export class DataApiDriver implements Driver {
     this.#config = config;
   }
 
-  async init(): Promise<void> {}
+  async init(): Promise<void> {
+    // do nothing
+  }
 
   async acquireConnection(): Promise<DatabaseConnection> {
     return new DataApiConnection(this.#config);
@@ -35,9 +37,13 @@ export class DataApiDriver implements Driver {
     await conn.rollbackTransaction();
   }
 
-  async releaseConnection(_connection: DatabaseConnection): Promise<void> {}
+  async releaseConnection(_connection: DatabaseConnection): Promise<void> {
+    // do nothing
+  }
 
-  async destroy(): Promise<void> {}
+  async destroy(): Promise<void> {
+    // do nothing
+  }
 }
 
 class DataApiConnection implements DatabaseConnection {
@@ -90,7 +96,7 @@ class DataApiConnection implements DatabaseConnection {
         secretArn: this.#config.secretArn,
         resourceArn: this.#config.resourceArn,
         sql: compiledQuery.sql,
-        parameters: compiledQuery.parameters as any,
+        parameters: compiledQuery.parameters as SqlParametersList,
         database: this.#config.database,
         includeResultMetadata: true,
       })
@@ -114,8 +120,8 @@ class DataApiConnection implements DatabaseConnection {
                 val.arrayValue ??
                 val.doubleValue ??
                 (val.isNull ? null : val.booleanValue),
-            ])
-          ) as unknown as O
+            ]),
+          ) as unknown as O,
       );
     const result: QueryResult<O> = {
       rows: rows || [],

src/data-api-query-compiler.ts

@@ -2,7 +2,7 @@ import { SqlParameter } from "aws-sdk/clients/rdsdataservice";
 import { MysqlQueryCompiler, PostgresQueryCompiler } from "kysely";
 
 export class PostgresDataApiQueryCompiler extends PostgresQueryCompiler {
-  protected override appendValue(value: any) {
+  protected override appendValue(value: unknown) {
     const name = this.numParameters;
     this.append(this.getCurrentParameterPlaceholder());
     this.addParameter({
@@ -17,7 +17,7 @@ export class PostgresDataApiQueryCompiler extends PostgresQueryCompiler {
 }
 
 export class MysqlDataApiQueryCompiler extends MysqlQueryCompiler {
-  protected override appendValue(value: any) {
+  protected override appendValue(value: unknown) {
     const name = this.numParameters;
     this.append(this.getCurrentParameterPlaceholder());
     this.addParameter({
@@ -31,74 +31,105 @@ export class MysqlDataApiQueryCompiler extends MysqlQueryCompiler {
   }
 }
 
-function serialize(value: any): SqlParameter {
-  if (value == null) return { value: { isNull: true } };
+function serialize(value: unknown): Pick<SqlParameter, "typeHint" | "value"> {
   switch (typeof value) {
-    case "number":
-      if (Number.isInteger(value))
-        return {
-          value: {
-            longValue: value,
-          },
-        };
-      else
-        return {
-          value: {
-            doubleValue: value,
-          }
-        };
-    case "bigint":
+  case "bigint":
+    return { value: { doubleValue: Number(value) } };
+  case "boolean":
+    return { value: { booleanValue: value } };
+  case "number":
+    if (Number.isInteger(value))
+      return { value: { longValue: value } };
+    else
+      return { value: { doubleValue: value } };
+  case "object":
+    if (value == null)
+      return { value: { isNull: true }};
+    else if (Buffer.isBuffer(value))
+      return { value: { blobValue: value } };
+    else if (value instanceof Date)
       return {
-        value: {
-          doubleValue: Number(value),
-        }
+        typeHint: "TIMESTAMP",
+        value: { stringValue: fixISOString(value.toISOString()) },
       };
-    case "string":
-      return {
-        value: {
-          stringValue: value,
-        }
-      };
-    case "boolean":
-      return {
-        value: {
-          booleanValue: value,
-        }
-      };
-    case "object":
-      if (Buffer.isBuffer(value))
-        return {
-          value: {
-            blobValue: value,
-          }
-        };
+    else if ((value as RSU)?.value && isValueObject((value as RSU).value as RSU)) {
+      if (
+        (value as RSU).typeHint && ((value as RSU).value as RSU).stringValue
+        && typeof ((value as RSU).value as RSU).stringValue === "string"
+      )
+        ((value as RSU).value as RSU).stringValue = fixStringValue(
+          (value as RSS).typeHint,
+          ((value as RSU).value as RSS).stringValue,
+        );
+      return value;
+    }
+    else
+      break;
+  case "string":
+    return {
+      value: { stringValue: value },
+    };
+  }
 
-      if (Array.isArray(value)) {
-        return {
-          value: {
-            arrayValue: {
-              stringValues: value,
-            }
-          }
-        }
-      }
+  throw new QueryCompilerError("Could not serialize value");
+}
 
-      if (value instanceof Date)
-        return {
-          typeHint: "TIMESTAMP",
-          value: { stringValue: serializeDate(value) },
-        }
+function fixStringValue(typeHint: SqlParameter["typeHint"], value: string) {
+  switch (typeHint) {
+  case "DATE":
+    return parseToISOString(value).slice(0, 10);
+  case "TIME":
+    if (value.match(/^\d{4}-\d{2}-\d{2}/)) {
+      return parseToISOString(value).slice(11, 23);
+    }
+    return fixTimeString(value);
+  case "TIMESTAMP":
+    return fixISOString(parseToISOString(value));
+  }
+  return value;
+}
 
-      return {
-        value: {
-          stringValue: JSON.stringify(value),
-        }
-      }
+function fixTimeString(s: string) {
+  const elements = (s || "00:00:00").split(":");
+  while (elements.length < 3) {
+    elements.push("00");
   }
+  return elements.join(":").slice(0, 12);
+}
+
+function fixISOString(s: string) {
+  return s.replace("T", " ").slice(0, 23);
+}
 
-  throw new Error(`Unsupported type: ${value}`);
+function parseToISOString(s: string) {
+  return new Date(Date.parse(s)).toISOString();
 }
 
-function serializeDate(input: Date) {
-  return input.toISOString().replace("T", " ").substring(0, 23);
+function isValueObject(value: Record<string, unknown>) {
+  for (const key of primitiveKeys) {
+    if (value[key]) {
+      return true;
+    }
+  }
+  if (value.arrayValue) {
+    for (const key of arrayKeys) {
+      if ((value.arrayValue as Record<string, unknown>)?.[key]) {
+        return true;
+      }
+    }
+  }
+  return false;
 }
+
+class QueryCompilerError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = QueryCompilerError.name;
+  }
+}
+
+const arrayKeys = ["booleanValues", "doubleValues", "longValues", "stringValues"];
+const primitiveKeys = ["blobValue", "booleanValue", "doubleValue", "isNull", "longValue", "stringValue"];
+
+type RSS = Record<string, string>;
+type RSU = Record<string, unknown>;

src/index.ts

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