get rid of BASIC and PLUS keys

Author: mewwts

tests/e2e/client.spec.ts

@@ -1,6 +1,6 @@
 import { DuneClient, QueryParameter } from "../../src/";
 import log from "loglevel";
-import { BASIC_KEY, PLUS_KEY } from "./util";
+import { API_KEY } from "./util";
 import * as fs from "fs/promises";
 
 log.setLevel("silent", true);
@@ -11,7 +11,7 @@ describe("DuneClient Extensions", () => {
   let multiRowQuery: number;
 
   beforeAll(() => {
-    client = new DuneClient(BASIC_KEY);
+    client = new DuneClient(API_KEY);
     parameterizedQuery = 1215383;
     multiRowQuery = 3463180;
   });
@@ -107,15 +107,14 @@ describe("DuneClient Extensions", () => {
   });
 
   it("runSQL", async () => {
-    const premiumClient = new DuneClient(PLUS_KEY);
-    const results = await premiumClient.runSql({
+    const results = await client.runSql({
       query_sql: "select 1",
       archiveAfter: true,
       isPrivate: true,
     });
     const queryID = results.query_id;
     expect(results.result?.rows).toEqual([{ _col0: 1 }]);
-    const query = await premiumClient.query.readQuery(queryID);
+    const query = await client.query.readQuery(queryID);
     expect(query.is_archived).toEqual(true);
   });
 });

tests/e2e/custom.spec.ts

@@ -1,6 +1,6 @@
 import { CustomAPI } from "../../src/";
 import log from "loglevel";
-import { BASIC_KEY } from "./util";
+import { API_KEY } from "./util";
 
 log.setLevel("silent", true);
 
@@ -9,7 +9,7 @@ describe("Custom API", () => {
   const slug = "test-custom-api";
 
   beforeAll(() => {
-    client = new CustomAPI(BASIC_KEY);
+    client = new CustomAPI(API_KEY);
   });
 
   // Skip: This endpoint is very "user specific"

tests/e2e/execution.spec.ts

@@ -1,7 +1,7 @@
 import { QueryParameter, ExecutionState, ExecutionAPI, DuneClient } from "../../src";
 import log from "loglevel";
 import { QueryEngine } from "../../src/types/requestArgs";
-import { BASIC_KEY, PLUS_KEY, expectAsyncThrow } from "./util";
+import { API_KEY, expectAsyncThrow } from "./util";
 import { sleep } from "../../src/utils";
 
 log.setLevel("silent", true);
@@ -15,7 +15,7 @@ describe("ExecutionAPI: native routes", () => {
   let simpleExecutionId: string;
 
   beforeAll(async () => {
-    client = new ExecutionAPI(BASIC_KEY);
+    client = new ExecutionAPI(API_KEY);
     // https://dune.com/queries/1215383
     testQueryId = 1215383;
     // https://dune.com/queries/3463180
@@ -85,8 +85,8 @@ describe("ExecutionAPI: native routes", () => {
     expect(execution.execution_id).not.toEqual(null);
   });
 
-  it("executes with Large tier performance", async () => {
-    client = new ExecutionAPI(PLUS_KEY);
+  it.skip("executes with Large tier performance", async () => {
+    // Skipped: This test requires specific premium permissions
     const execution = await client.executeQuery(testQueryId, {
       performance: QueryEngine.Large,
     });
@@ -228,7 +228,7 @@ describe("ExecutionAPI: Errors", () => {
   let client: ExecutionAPI;
 
   beforeAll(() => {
-    client = new ExecutionAPI(BASIC_KEY);
+    client = new ExecutionAPI(API_KEY);
   });
 
   beforeEach((done) => {
@@ -276,7 +276,7 @@ describe("ExecutionAPI: Errors", () => {
 
   it("returns error when query execution fails", async () => {
     // Use DuneClient to create a query with bad SQL, execute it, and check the error
-    const fullClient = new DuneClient(PLUS_KEY);
+    const fullClient = new DuneClient(API_KEY);
 
     // Create a query with intentionally bad SQL
     const queryId = await fullClient.query.createQuery({
@@ -286,13 +286,13 @@ describe("ExecutionAPI: Errors", () => {
     });
 
     try {
-      // Execute the query - use fullClient.exec (with PLUS_KEY) since query is private
+      // Execute the query
       const execution = await fullClient.exec.executeQuery(queryId);
 
       // Wait a bit for it to fail
       await sleep(3);
 
-      // Get the results - should have an error - use fullClient.exec (with PLUS_KEY)
+      // Get the results - should have an error
       const result = await fullClient.exec.getExecutionResults(execution.execution_id);
 
       // Verify error structure exists

tests/e2e/paginator.spec.ts

@@ -1,11 +1,11 @@
 import { DuneClient, Paginator } from "../../src/";
-import { BASIC_KEY } from "./util";
+import { API_KEY } from "./util";
 
 describe("Paginator Class", () => {
   let client: DuneClient;
 
   beforeAll(() => {
-    client = new DuneClient(BASIC_KEY);
+    client = new DuneClient(API_KEY);
   });
   it("Paginator does the stuff", async () => {
     // Ususally the user would call: client.refreshResults(:966920);

tests/e2e/query.spec.ts

@@ -1,24 +1,24 @@
 import { QueryParameter, QueryAPI } from "../../src";
-import { PLUS_KEY } from "./util";
+import { API_KEY } from "./util";
 
-describe("QueryAPI: Premium - CRUD Operations", () => {
-  let plusClient: QueryAPI;
+describe("QueryAPI: CRUD Operations", () => {
+  let client: QueryAPI;
 
   beforeAll(() => {
-    plusClient = new QueryAPI(PLUS_KEY);
+    client = new QueryAPI(API_KEY);
   });
 
   // This creates too many queries!
   it.skip("create, get & update", async () => {
-    const newQueryId = await plusClient.createQuery({
+    const newQueryId = await client.createQuery({
       name: "Query Name",
       query_sql: "select 1",
       query_parameters: [QueryParameter.text("What", "name")],
       is_private: true,
     });
-    const recoveredQuery = await plusClient.readQuery(newQueryId);
+    const recoveredQuery = await client.readQuery(newQueryId);
     expect(newQueryId).toEqual(newQueryId);
-    const updatedQueryId = await plusClient.updateQuery(newQueryId, {
+    const updatedQueryId = await client.updateQuery(newQueryId, {
       name: "New Name",
       query_sql: "select 10",
     });
@@ -27,17 +27,17 @@ describe("QueryAPI: Premium - CRUD Operations", () => {
 
   it.skip("unarchive, make public, make private, rearchive", async () => {
     const queryId = 3530410;
-    let query = await plusClient.readQuery(queryId);
+    let query = await client.readQuery(queryId);
 
-    await plusClient.unarchiveQuery(queryId);
-    await plusClient.makePublic(queryId);
-    query = await plusClient.readQuery(queryId);
+    await client.unarchiveQuery(queryId);
+    await client.makePublic(queryId);
+    query = await client.readQuery(queryId);
     expect(query.is_archived).toEqual(false);
     expect(query.is_private).toEqual(false);
 
-    await plusClient.archiveQuery(queryId);
-    await plusClient.makePrivate(queryId);
-    query = await plusClient.readQuery(queryId);
+    await client.archiveQuery(queryId);
+    await client.makePrivate(queryId);
+    query = await client.readQuery(queryId);
     expect(query.is_archived).toEqual(true);
     expect(query.is_private).toEqual(true);
   });

tests/e2e/table.spec.ts

@@ -1,5 +1,5 @@
 import log from "loglevel";
-import { PLUS_KEY, USER_NAME } from "./util";
+import { API_KEY, USER_NAME } from "./util";
 import * as fs from "fs/promises";
 import { TableAPI } from "../../src/api";
 import { ColumnType, ContentType } from "../../src";
@@ -12,7 +12,7 @@ describe("Table API", () => {
   const table_name = "dataset_e2e_test";
 
   beforeAll(() => {
-    tableClient = new TableAPI(PLUS_KEY);
+    tableClient = new TableAPI(API_KEY);
     namespace = USER_NAME;
   });
 

tests/e2e/util.ts

@@ -1,14 +1,10 @@
 import { DuneError } from "../../src";
 
-const { BASIC_API_KEY, PLUS_API_KEY, DUNE_USER_NAME, CUSTOM_SLUG } = process.env;
-if (BASIC_API_KEY === undefined) {
-  throw Error("Missing ENV var: BASIC_API_KEY");
+const { DUNE_API_KEY, DUNE_USER_NAME, CUSTOM_SLUG } = process.env;
+if (DUNE_API_KEY === undefined) {
+  throw Error("Missing ENV var: DUNE_API_KEY");
 }
-if (PLUS_API_KEY === undefined) {
-  throw Error("Missing ENV var: PLUS_API_KEY");
-}
-export const BASIC_KEY: string = BASIC_API_KEY!;
-export const PLUS_KEY: string = PLUS_API_KEY!;
+export const API_KEY: string = DUNE_API_KEY!;
 export const USER_NAME: string = DUNE_USER_NAME || "your_username";
 export const CUSTOM_API_SLUG: string = CUSTOM_SLUG || "test-custom-api";