Add Support for Query Parameters

src/client.ts

@@ -1,11 +1,11 @@
 import {
   ExecutionResponse,
-  ExecutionState,
   GetStatusResponse,
   ResultsResponse,
   DuneError,
 } from "./responseTypes";
 import fetch from "cross-fetch";
+import { QueryParameter } from "./queryParameter";
 const BASE_URL = "https://api.dune.com/api/v1";
 
 export class DuneClient {
@@ -15,8 +15,8 @@ export class DuneClient {
     this.apiKey = apiKey;
   }
 
-  private async _handleResponse(responsePromise: Promise<Response>): Promise<any> {
-    const response = await responsePromise
+  private async _handleResponse<T>(responsePromise: Promise<Response>): Promise<T> {
+    const apiResponse = await responsePromise
       .then((response) => {
         if (response.status > 400) {
           console.error(`response error ${response.status} - ${response.statusText}`);
@@ -27,43 +27,53 @@ export class DuneClient {
         console.error(`caught unhandled response error ${JSON.stringify(error)}`);
         throw error;
       });
-    if (response.error) {
-      console.error(`caught unhandled response error ${JSON.stringify(response)}`);
-      if (response.error instanceof Object) {
-        throw new DuneError(response.error.type);
+    if (apiResponse.error) {
+      console.error(`error contained in response ${JSON.stringify(apiResponse)}`);
+      if (apiResponse.error instanceof Object) {
+        throw new DuneError(apiResponse.error.type);
       } else {
-        throw new DuneError(response.error);
+        throw new DuneError(apiResponse.error);
       }
     }
-    return response;
+    return apiResponse;
   }
 
-  private async _get(url: string): Promise<any> {
+  private async _get<T>(url: string): Promise<T> {
     console.debug(`GET received input url=${url}`);
     const response = fetch(url, {
       method: "GET",
       headers: {
         "x-dune-api-key": this.apiKey,
       },
     });
-    return this._handleResponse(response);
+    return this._handleResponse<T>(response);
   }
 
-  private async _post(url: string, params?: any): Promise<any> {
+  private async _post<T>(url: string, params?: QueryParameter[]): Promise<T> {
     console.debug(`POST received input url=${url}, params=${JSON.stringify(params)}`);
+    // Transform Query Parameter list into "dict"
+    const reducedParams = params?.reduce<Record<string, string>>(
+      (acc, { name, value }) => ({ ...acc, [name]: value }),
+      {},
+    );
     const response = fetch(url, {
       method: "POST",
-      body: JSON.stringify(params),
+      body: JSON.stringify({ query_parameters: reducedParams || {} }),
       headers: {
         "x-dune-api-key": this.apiKey,
       },
     });
-    return this._handleResponse(response);
+    return this._handleResponse<T>(response);
   }
 
-  async execute(queryID: number): Promise<ExecutionResponse> {
-    // TODO - Add Query Parameters to Execution
-    const response = await this._post(`${BASE_URL}/query/${queryID}/execute`, {});
+  async execute(
+    queryID: number,
+    parameters?: QueryParameter[],
+  ): Promise<ExecutionResponse> {
+    const response = await this._post<ExecutionResponse>(
+      `${BASE_URL}/query/${queryID}/execute`,
+      parameters,
+    );
     console.debug(`execute response ${JSON.stringify(response)}`);
     return {
       execution_id: response.execution_id,
@@ -76,10 +86,11 @@ export class DuneClient {
       `${BASE_URL}/execution/${jobID}/status`,
     );
     console.debug(`get_status response ${JSON.stringify(response)}`);
+    const { execution_id, query_id, state } = response;
     return {
-      execution_id: response.execution_id,
-      query_id: response.query_id,
-      state: response.state,
+      execution_id,
+      query_id,
+      state,
       // times: parseTimesFrom(data)
     };
   }
@@ -102,8 +113,9 @@ export class DuneClient {
   }
 
   async cancel_execution(jobID: string): Promise<boolean> {
-    const data = await this._post(`${BASE_URL}/execution/${jobID}/cancel`);
-    const success: boolean = data.success;
+    const { success }: { success: boolean } = await this._post(
+      `${BASE_URL}/execution/${jobID}/cancel`,
+    );
     return success;
   }
 }

src/index.ts

@@ -1,3 +1,4 @@
 export { DuneClient } from "./client";
 
 export * from "./responseTypes";
+export * from "./queryParameter";

src/queryParameter.ts

@@ -0,0 +1,35 @@
+export enum ParameterType {
+  TEXT = "text",
+  NUMBER = "number",
+  DATE = "date",
+  ENUM = "enum",
+}
+
+export class QueryParameter {
+  type: ParameterType;
+  value: string;
+  name: string;
+
+  constructor(type: ParameterType, name: string, value: any) {
+    this.type = type;
+    this.value = value.toString();
+    this.name = name;
+  }
+
+  static text(name: string, value: string): QueryParameter {
+    return new QueryParameter(ParameterType.TEXT, name, value);
+  }
+
+  static number(name: string, value: string | number): QueryParameter {
+    // TODO - investigate large numbers here...
+    return new QueryParameter(ParameterType.NUMBER, name, value.toString());
+  }
+
+  static date(name: string, value: string | Date): QueryParameter {
+    return new QueryParameter(ParameterType.DATE, name, value.toString());
+  }
+
+  static enum(name: string, value: string): QueryParameter {
+    return new QueryParameter(ParameterType.ENUM, name, value.toString());
+  }
+}

tests/e2e/client.test.ts

@@ -1,12 +1,7 @@
 import { expect } from "chai";
-
+import { QueryParameter } from "../../src/queryParameter";
 import { DuneClient } from "../../src/client";
-import {
-  DuneError,
-  ExecutionResponse,
-  ExecutionState,
-  GetStatusResponse,
-} from "../../src/responseTypes";
+import { DuneError, ExecutionState, GetStatusResponse } from "../../src/responseTypes";
 
 const { DUNE_API_KEY } = process.env;
 const apiKey: string = DUNE_API_KEY ? DUNE_API_KEY : "No API Key";
@@ -26,16 +21,16 @@ const expectAsyncThrow = async (promise: Promise<any>, message?: string | object
   }
 };
 
-// beforeEach(() => {
-//   console.log = function () {};
-//   console.debug = function () {};
-//   console.error = function () {};
-// });
+beforeEach(() => {
+  // console.log = function () {};
+  console.debug = function () {};
+  console.error = function () {};
+});
 
 describe("DuneClient: execute", () => {
   // This doesn't work if run too many times at once:
   // https://discord.com/channels/757637422384283659/1019910980634939433/1026840715701010473
-  it.skip("returns expected results on sequence execute-cancel-get_status", async () => {
+  it("returns expected results on sequence execute-cancel-get_status", async () => {
     const client = new DuneClient(apiKey);
     // Long running query ID.
     const queryID = 1229120;
@@ -60,6 +55,20 @@ describe("DuneClient: execute", () => {
     expect(expectedStatus).to.be.deep.equal(status);
   });
 
+  it("successfully executes with query parameters", async () => {
+    const client = new DuneClient(apiKey);
+    const queryID = 1215383;
+    const parameters = [
+      QueryParameter.text("TextField", "Plain Text"),
+      QueryParameter.number("NumberField", 3.1415926535),
+      QueryParameter.date("DateField", "2022-05-04 00:00:00"),
+      QueryParameter.enum("ListField", "Option 1"),
+    ];
+    // Execute and check state
+    const execution = await client.execute(queryID, parameters);
+    expect(execution.execution_id).is.not.null;
+  });
+
   it("returns expected results on sequence execute-cancel-get_status", async () => {
     const client = new DuneClient(apiKey);
     // Execute and check state
@@ -79,6 +88,10 @@ describe("DuneClient: execute", () => {
 });
 
 describe("DuneClient: Errors", () => {
+  // TODO these errors can't be reached because post method is private
+  // {"error":"unknown parameters (undefined)"}
+  // {"error":"Invalid request body payload"}
+
   it("returns invalid API key", async () => {
     const client = new DuneClient("Bad Key");
     await expectAsyncThrow(client.execute(1), "invalid API Key");
@@ -102,6 +115,16 @@ describe("DuneClient: Errors", () => {
     await expectAsyncThrow(client.get_result(invalidJobID), expectedErrorMessage);
     await expectAsyncThrow(client.cancel_execution(invalidJobID), expectedErrorMessage);
   });
+  it.only("fails execute with unknown query parameter", async () => {
+    const client = new DuneClient(apiKey);
+    const queryID = 1215383;
+    const invalidParameterName = "Invalid Parameter Name";
+    const parameters = [QueryParameter.text(invalidParameterName, "")];
+    await expectAsyncThrow(
+      client.execute(queryID, parameters),
+      `unknown parameters (${invalidParameterName})`,
+    );
+  });
   it("does not allow to execute private queries for other accounts.", async () => {
     const client = new DuneClient(apiKey);
     await expectAsyncThrow(

tslint.json

@@ -1,3 +1,6 @@
 {
-  "extends": ["tslint:recommended", "tslint-config-prettier"]
-}
+  "extends": ["tslint:recommended", "tslint-config-prettier"],
+  "rules": {
+    "no-console": false
+  }
+}