Kg collection default timeout (#41)

* collection-level timeout

* restructured timeout tests

Author: toptobes

src/api/clients/data-api-http-client.ts

@@ -28,6 +28,7 @@ import { DataAPIResponseError, DataAPITimeoutError, ObjectId, UUID } from '@/src
 import { TimeoutManager, TimeoutOptions } from '@/src/api/timeout-managers';
 import { CommandFailedEvent, CommandStartedEvent, CommandSucceededEvent } from '@/src/data-api/events';
 import { CollectionNotFoundError, DataAPIHttpError, mkRespErrorFromResponse } from '@/src/data-api/errors';
+import { CollectionSpawnOptions } from '@/src/data-api/types/collections/spawn-collection';
 
 /**
  * @internal
@@ -55,18 +56,21 @@ interface DataAPIHttpClientOptions extends HTTPClientOptions {
 export class DataAPIHttpClient extends HttpClient {
   public collection?: string;
   public namespace?: string;
+  public maxTimeMS: number;
   readonly #props: DataAPIHttpClientOptions;
 
   constructor(props: DataAPIHttpClientOptions, embeddingApiKey?: string) {
     super(props, mkHeaders(embeddingApiKey));
     this.namespace = props.namespace;
     this.#props = props;
+    this.maxTimeMS = this.fetchCtx.maxTimeMS ?? DEFAULT_TIMEOUT;
   }
 
-  public forCollection(namespace: string, collection: string, embeddingApiKey: string | undefined): DataAPIHttpClient {
-    const clone = new DataAPIHttpClient(this.#props, embeddingApiKey);
+  public forCollection(namespace: string, collection: string, opts: CollectionSpawnOptions | undefined): DataAPIHttpClient {
+    const clone = new DataAPIHttpClient(this.#props, opts?.embeddingApiKey);
     clone.collection = collection;
     clone.namespace = namespace;
+    clone.maxTimeMS = opts?.defaultMaxTimeMS ?? this.maxTimeMS;
     return clone;
   }
 
@@ -133,8 +137,8 @@ export class DataAPIHttpClient extends HttpClient {
       }
 
       const respData = {
-        status: data?.status,
         data: data?.data,
+        status: data?.status,
         errors: data?.errors,
       }
 
@@ -152,7 +156,7 @@ export class DataAPIHttpClient extends HttpClient {
   }
 
   private _mkTimeoutManager(timeout: number | undefined) {
-    timeout ??= this.fetchCtx.maxTimeMS ?? DEFAULT_TIMEOUT;
+    timeout ??= this.maxTimeMS;
     return new TimeoutManager(timeout, () => new DataAPITimeoutError(timeout));
   }
 }

src/data-api/collection.ts

@@ -131,7 +131,7 @@ export class Collection<Schema extends SomeDoc = SomeDoc> {
     });
 
     Object.defineProperty(this, '_httpClient', {
-      value: httpClient.forCollection(this.namespace, this.collectionName, opts?.embeddingApiKey),
+      value: httpClient.forCollection(this.namespace, this.collectionName, opts),
       enumerable: false,
     });
 

src/data-api/types/collections/spawn-collection.ts

@@ -14,6 +14,22 @@
 
 import { WithNamespace } from '@/src/data-api';
 
+/**
+ * Options for spawning a new collection.
+ */
 export interface CollectionSpawnOptions extends WithNamespace {
-  embeddingApiKey?: string;
+  /**
+   * The API key for the embedding service to use
+   */
+  embeddingApiKey?: string,
+  /**
+   * The default `maxTimeMS` for all operations on the collection. Will override the maxTimeMS set in the DataAPIClient
+   * options; it can be overridden on a per-operation basis.
+   *
+   * This does *not* mean the request will be cancelled after this time, but rather that the client will wait
+   * for this time before considering the request to have timed out.
+   *
+   * The request may or may not still be running on the server after this time.
+   */
+  defaultMaxTimeMS?: number,
 }

tests/integration/api/data-api-http-client.test.ts

@@ -17,6 +17,7 @@ import { Collection, DataAPIResponseError, DataAPITimeoutError, Db } from '@/src
 import { DEFAULT_COLLECTION_NAME, initTestObjects, OTHER_NAMESPACE } from '@/tests/fixtures';
 import { DataAPIHttpClient } from '@/src/api';
 import assert from 'assert';
+import { DataAPIHttpError } from '@/src/data-api/errors';
 
 describe('integration.api.data-api-http-client', () => {
   let httpClient: DataAPIHttpClient;
@@ -72,32 +73,5 @@ describe('integration.api.data-api-http-client', () => {
         assert.strictEqual(e.errorDescriptors[0].message, 'Authentication failed; is your token valid?');
       }
     });
-
-    it('should timeout properly', async () => {
-      await assert.rejects(async () => {
-        await httpClient.executeCommand({
-          findCollections: {},
-        }, {
-          namespace: OTHER_NAMESPACE,
-          maxTimeMS: 1,
-        });
-      }, DataAPITimeoutError);
-    });
-
-    // it('should throw DataAPIHttpError on non-2XX responses', async function () {
-    //   try {
-    //     const [client] = await initTestObjects(this, false);
-    //     const httpClient = client.db('https://f1183f15-dc85-4fbf-8aae-f1ca97338bbb-us-east-1.apps.astra.datastax.com', { token: 'invalid-token' })['_httpClient'];
-    //     await httpClient.executeCommand({
-    //       findCollections: {},
-    //     }, {});
-    //   } catch (e) {
-    //     console.log(e);
-    //     assert.ok(e instanceof DataAPIHttpError);
-    //     assert.strictEqual(e.status, 502);
-    //     assert.ok(typeof e.body === 'string');
-    //     assert.strictEqual(e.raw.httpVersion, 1);
-    //   }
-    // });
   });
 });

tests/integration/api/devops-http-client.test.ts

@@ -40,32 +40,6 @@ describe('integration.client.data-api-client', () => {
     });
   });
 
-  describe('timeout', () => {
-    it('times out on base timeout', async () => {
-      const client = new DataAPIClient(process.env.APPLICATION_TOKEN!, { httpOptions: { maxTimeMS: 1 } });
-      const db = client.db(process.env.ASTRA_URI!);
-      const collection = db.collection(DEFAULT_COLLECTION_NAME);
-
-      try {
-        await collection.insertOne({ name: 'Nightwish' });
-        assert.fail('should have thrown an error');
-      } catch (e) {
-        assert.ok(e instanceof DataAPITimeoutError);
-        assert.strictEqual(e.timeout, 1);
-      }
-    });
-
-    it('overrides base timeout', async () => {
-      const client = new DataAPIClient(process.env.APPLICATION_TOKEN!, { httpOptions: { maxTimeMS: 1 } });
-      const db = client.db(process.env.ASTRA_URI!);
-      const collection = db.collection(DEFAULT_COLLECTION_NAME);
-
-      await assert.doesNotReject(async () => {
-        await collection.insertOne({ name: 'Nightwish' }, { maxTimeMS: 10000 });
-      });
-    });
-  });
-
   describe('close', () => {
     it('should not allow operations after closing the client', async () => {
       const client = new DataAPIClient(process.env.APPLICATION_TOKEN!);

tests/integration/client/data-api-client.test.ts

@@ -0,0 +1,101 @@
+// Copyright DataStax, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// noinspection DuplicatedCode
+
+import { DEFAULT_COLLECTION_NAME, initTestObjects } from '@/tests/fixtures';
+import { Collection, DataAPITimeoutError, Db } from '@/src/data-api';
+import assert from 'assert';
+import { HttpMethods } from '@/src/api';
+import { DevOpsAPITimeoutError } from '@/src/devops';
+import { DataAPIClient } from '@/src/client';
+import process from 'process';
+
+describe('integration.misc.timeouts', () => {
+  let db: Db;
+  let collection: Collection;
+
+  before(async function () {
+    [, db, collection] = await initTestObjects(this);
+  });
+
+  describe('in data-api', () => {
+    it('should timeout @ the http-client level', async () => {
+      const httpClient = collection['_httpClient'];
+
+      await assert.rejects(async () => {
+        await httpClient.executeCommand({ findCollections: {} }, { maxTimeMS: 5 });
+      }, DataAPITimeoutError);
+    });
+
+    it('should timeout based on DataAPIClient maxTimeMS', async () => {
+      const collection = new DataAPIClient(process.env.APPLICATION_TOKEN!, { httpOptions: { maxTimeMS: 1 } })
+        .db(process.env.ASTRA_URI!)
+        .collection(DEFAULT_COLLECTION_NAME);
+
+      await assert.rejects(async () => {
+        await collection.insertOne({ name: 'Nightwish' });
+      }, DataAPITimeoutError);
+    });
+
+    it('should timeout based on collection maxTimeMS', async () => {
+      const collection = new DataAPIClient(process.env.APPLICATION_TOKEN!, { httpOptions: { maxTimeMS: 30000 } })
+        .db(process.env.ASTRA_URI!)
+        .collection(DEFAULT_COLLECTION_NAME, { defaultMaxTimeMS: 1 });
+
+      await assert.rejects(async () => {
+        await collection.insertOne({ name: 'Nightwish' });
+      }, DataAPITimeoutError);
+    });
+
+    it('should timeout based on operation maxTimeMS', async () => {
+      const collection = new DataAPIClient(process.env.APPLICATION_TOKEN!, { httpOptions: { maxTimeMS: 30000 } })
+        .db(process.env.ASTRA_URI!)
+        .collection(DEFAULT_COLLECTION_NAME, { defaultMaxTimeMS: 30000 });
+
+      await assert.rejects(async () => {
+        await collection.insertOne({ name: 'Nightwish' }, { maxTimeMS: 1 });
+      }, DataAPITimeoutError);
+    });
+  });
+
+  describe('in devops', () => {
+    it('should timeout @ the http-client level', async () => {
+      const httpClient = db.admin()['_httpClient'];
+
+      await assert.rejects(async () => {
+        await httpClient.request({ method: HttpMethods.Get, path: '/databases' }, { maxTimeMS: 5 });
+      }, DevOpsAPITimeoutError);
+    });
+
+    it('should timeout based on DataAPIClient maxTimeMS', async () => {
+      const admin = new DataAPIClient(process.env.APPLICATION_TOKEN!, { httpOptions: { maxTimeMS: 1 } })
+        .db(process.env.ASTRA_URI!)
+        .admin();
+
+      await assert.rejects(async () => {
+        await admin.listNamespaces();
+      }, DevOpsAPITimeoutError);
+    });
+
+    it('should timeout based on operation maxTimeMS', async () => {
+      const admin = new DataAPIClient(process.env.APPLICATION_TOKEN!, { httpOptions: { maxTimeMS: 30000 } })
+        .db(process.env.ASTRA_URI!)
+        .admin();
+
+      await assert.rejects(async () => {
+        await admin.listNamespaces({ maxTimeMS: 1 });
+      }, DevOpsAPITimeoutError);
+    });
+  });
+});