feat: Adds custom fetch support at db/col level

Author: thecodedrift

CHANGELOG.md

@@ -14,6 +14,16 @@ All notable changes to this project will be documented in this file. This projec
 
 ### Removed
 
+## [0.4.0]
+
+### Added
+
+- Custom fetch: For `db()` and `collection()`, there is now a chainable `fetch()` method, which returns a new DB or collection with its `fetch` implementation changed. This allows you to implement your own custom logic for retries, without the addition of pRetry
+
+### Removed
+
+- Removed pRetry dependency in favor of users overriding via their own fetch function
+
 ## [0.3.0]
 
 ### Breaking Changes
@@ -40,10 +50,6 @@ const createMongoClient = async () => {
 
 - Return type on `insertOne` is now of type `ObjectId` instead of `string`
 
-### Changed
-
-### Removed
-
 ## [0.2.2]
 
 ### Fixed
@@ -115,7 +121,8 @@ Older releases are available via github releases: https://github.com/taskless/mo
 
 <!-- Releases -->
 
-[unreleased]: https://github.com/taskless/mongo-data-api/compare/0.3.0...HEAD
+[unreleased]: https://github.com/taskless/mongo-data-api/compare/0.4.0...HEAD
+[0.4.0]: https://github.com/taskless/mongo-data-api/compare/0.3.0...0.4.0
 [0.3.0]: https://github.com/taskless/mongo-data-api/compare/0.2.2...0.3.0
 [0.2.2]: https://github.com/taskless/mongo-data-api/compare/0.2.1...0.2.2
 [0.2.1]: https://github.com/taskless/mongo-data-api/compare/0.2.0...0.2.1

README.md

@@ -15,6 +15,7 @@
   - [Create a Mongo Client](#create-a-mongo-client)
   - [Select a Database](#select-a-database)
   - [Select a Collection](#select-a-collection)
+  - [Changing `fetch()` on the Fly](#changing-fetch-on-the-fly)
   - [Collection Methods](#collection-methods)
     - [Return Type](#return-type)
     - [Methods](#methods)
@@ -148,6 +149,15 @@ const collection = db.collection<TSchema>(collectionName);
 - `collectionName` - `string` the name of the collection to connect to
 - `<TSchema>` - _generic_ A Type or Interface that describes the documents in this collection. Defaults to the generic MongoDB `Document` type
 
+## Changing `fetch()` on the Fly
+
+```ts
+const altDb = db.fetch(altFetch);
+const altCollection = db.collection<TSchema>(collectionName).fetch(altFetch);
+```
+
+- `altFetch` - An alternate `fetch` implementation that will be used for that point forward. Useful for adding or removing retry support on a per-call level, changing the authentication required, or other fetch middleware operations.
+
 ## Collection Methods
 
 The following [Data API resources](https://www.mongodb.com/docs/atlas/api/data-api-resources/) are supported
@@ -302,6 +312,7 @@ Requests via `fetch()` have their resposne codes checked against the [Data API E
 
 - **Why is `mongodb` in the dependencies?** [TypeScript requires it](https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html#dependencies), however, the mongodb dependency is types-only and will not be included in your built lambda when using `tsc`, `rollup`, `webpack`, etc. You can verify that mongo is not included by looking at the [CommonJS build](https://www.npmjs.com/package/@taskless/mongo-data-api?activeTab=code).
 - **Why is `node-fetch`'s `fetch` not of the correct type?** `node-fetch`'s `fetch` isn't a true `fetch` and wasn't typed as one. To work around this, you can either use [`cross-fetch`](https://github.com/lquixada/cross-fetch) which types the `fetch` API through a type assertion, or [perform the type assertion yourself](https://github.com/lquixada/cross-fetch/blob/main/index.d.ts): `fetch: _fetch as typeof fetch`. It's not ideal, but with proper `fetch` coming to node.js, it's a small inconvienence in the short term.
+- **How do I retry failed `fetch` calls?** `fetch-retry` ([github](https://github.com/jonbern/fetch-retry)) is an excellent library. You can also use a lower level retry tool like `p-retry` ([github](https://github.com/sindresorhus/p-retry)) if you want to manage more than just the `fetch()` operation itself.
 
 # License
 

package.json

@@ -51,7 +51,6 @@
   "dependencies": {
     "bson": "^6.2.0",
     "mongodb": "^6.2.0",
-    "p-retry": "^6.1.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

pnpm-lock.yaml

@@ -9,7 +9,6 @@ import type {
   WithoutId,
   Document,
 } from "mongodb";
-import pRetry from "p-retry";
 import type { AuthOptions } from "./authTypes.js";
 import { MongoDataAPIError } from "./errors.js";
 
@@ -67,6 +66,20 @@ export type MongoClientConstructorOptions = {
   headers?: OutgoingHttpHeaders | Headers;
 };
 
+type ConnectionOptions = {
+  dataSource: string;
+  endpoint: string;
+  headers: Record<string, string>;
+};
+
+type ConnectionOptionsWithDatabase = ConnectionOptions & {
+  database: string;
+};
+
+type ConnectionOptionsWithCollection = ConnectionOptionsWithDatabase & {
+  collection: string;
+};
+
 /**
  * Removes empty keys from an object at the top level. EJSON.stringify does not drop
  * undefined values in serialization, so we need to explicitly remove any keys with
@@ -88,61 +101,61 @@ const removeEmptyKeys = (object: Record<string, unknown>) => {
  * requests, converting mongo-style BSON to JSON and back again.
  */
 export class MongoClient {
-  dataSource: string;
-  endpoint: string;
-
-  fetch: typeof fetch;
-  headers: HeadersInit;
+  protected connection: ConnectionOptions;
+  protected ftch: typeof fetch;
 
   constructor({
     auth,
     dataSource,
     endpoint,
     fetch: customFetch,
-    headers,
+    headers: h,
   }: MongoClientConstructorOptions) {
-    this.dataSource = dataSource;
-    this.endpoint = endpoint instanceof URL ? endpoint.toString() : endpoint;
-
-    this.fetch = customFetch ?? globalThis.fetch;
-    this.headers = {};
+    this.ftch = customFetch ?? globalThis.fetch;
+    const headers: HeadersInit = {};
 
     // accept a node-style or whatwg headers object with .keys() and .get()
-    if (typeof headers?.keys === "function") {
-      for (const key of headers.keys()) {
-        this.headers[key] = (
-          typeof headers.get === "function" ? headers.get(key) : headers[key]
-        ) as string;
+    if (typeof h?.keys === "function") {
+      for (const key of h.keys()) {
+        headers[key] = (
+          typeof h.get === "function" ? h.get(key) : headers[key]
+        )!;
       }
     }
 
-    if (!this.fetch || typeof this.fetch !== "function") {
+    this.connection = {
+      dataSource,
+      endpoint: endpoint instanceof URL ? endpoint.toString() : endpoint,
+      headers,
+    };
+
+    if (!this.ftch || typeof this.ftch !== "function") {
       throw new Error(
         "No viable fetch() found. Please provide a fetch interface"
       );
     }
 
-    this.headers["Content-Type"] = "application/ejson";
-    this.headers.Accept = "application/ejson";
+    this.connection.headers["Content-Type"] = "application/ejson";
+    this.connection.headers.Accept = "application/ejson";
 
     if ("apiKey" in auth) {
-      this.headers.apiKey = auth.apiKey;
+      this.connection.headers.apiKey = auth.apiKey;
       return;
     }
 
     if ("jwtTokenString" in auth) {
-      this.headers.jwtTokenString = auth.jwtTokenString;
+      this.connection.headers.jwtTokenString = auth.jwtTokenString;
       return;
     }
 
     if ("email" in auth && "password" in auth) {
-      this.headers.email = auth.email;
-      this.headers.password = auth.password;
+      this.connection.headers.email = auth.email;
+      this.connection.headers.password = auth.password;
       return;
     }
 
     if ("bearerToken" in auth) {
-      this.headers.Authorization = `Bearer ${auth.bearerToken}`;
+      this.connection.headers.Authorization = `Bearer ${auth.bearerToken}`;
       return;
     }
 
@@ -151,7 +164,7 @@ export class MongoClient {
 
   /** Select a database from within the data source */
   db(name: string) {
-    return new Database(name, this);
+    return new Database(name, this.connection, this.ftch);
   }
 }
 
@@ -161,12 +174,19 @@ export class MongoClient {
  * queries.
  */
 export class Database {
-  name: string;
-  client: MongoClient;
-
-  constructor(name: string, client: MongoClient) {
-    this.name = name;
-    this.client = client;
+  protected connection: ConnectionOptionsWithDatabase;
+  protected ftch: typeof fetch;
+
+  constructor(
+    name: string,
+    connection: ConnectionOptions,
+    customFetch?: typeof fetch
+  ) {
+    this.ftch = customFetch ?? globalThis.fetch;
+    this.connection = {
+      ...connection,
+      database: name,
+    };
   }
 
   /**
@@ -176,7 +196,21 @@ export class Database {
    * @returns A Collection object of type `T`
    */
   collection<TSchema = Document>(name: string) {
-    return new Collection<TSchema>(name, this);
+    return new Collection<TSchema>(name, this.connection, this.ftch);
+  }
+
+  /**
+   * Change the fetch interface for this database. Returns a new Database object
+   * @param customFetch A fetch interface to use for subsequent calls
+   * @returns A new Database object with the custom fetch interface implemented
+   */
+  fetch(customFetch: typeof fetch) {
+    const db = new Database(
+      this.connection.database,
+      this.connection,
+      customFetch
+    );
+    return db;
   }
 }
 
@@ -185,14 +219,33 @@ export class Database {
  * methods in a fluent interface.
  */
 export class Collection<TSchema = Document> {
-  name: string;
-  database: Database;
-  client: MongoClient;
-
-  constructor(name: string, database: Database) {
-    this.name = name;
-    this.database = database;
-    this.client = database.client;
+  protected connection: ConnectionOptionsWithCollection;
+  protected ftch: typeof fetch;
+
+  constructor(
+    name: string,
+    database: ConnectionOptionsWithDatabase,
+    customFetch?: typeof fetch
+  ) {
+    this.ftch = customFetch ?? globalThis.fetch;
+    this.connection = {
+      ...database,
+      collection: name,
+    };
+  }
+
+  /**
+   * Change the fetch interface for this collection. Returns a new Collection object
+   * @param customFetch A fetch interface to use for subsequent calls
+   * @returns A new Collection object with the custom fetch interface implemented
+   */
+  fetch(customFetch: typeof fetch) {
+    const collection = new Collection(
+      this.connection.collection,
+      this.connection,
+      customFetch
+    );
+    return collection;
   }
 
   /**
@@ -433,29 +486,20 @@ export class Collection<TSchema = Document> {
     method: string,
     body: Record<string, unknown>
   ): Promise<DataAPIResponse<T>> {
-    const { endpoint, dataSource, headers } = this.client;
+    const { endpoint, dataSource, headers, collection, database } =
+      this.connection;
     const url = `${endpoint}/action/${method}`;
 
-    const response = await pRetry(
-      async () => {
-        const r = await this.client.fetch(url, {
-          method: "POST",
-          headers,
-          body: EJSON.stringify({
-            collection: this.name,
-            database: this.database.name,
-            dataSource,
-            ...removeEmptyKeys(body),
-          }),
-        });
-
-        return r;
-      },
-      {
-        minTimeout: 10,
-        maxTimeout: 1000,
-      }
-    );
+    const response = await this.ftch(url, {
+      method: "POST",
+      headers,
+      body: EJSON.stringify({
+        collection,
+        database,
+        dataSource,
+        ...removeEmptyKeys(body),
+      }),
+    });
 
     // interpret response code. Log error for anything outside of 2xx 3xx
     // https://www.mongodb.com/docs/atlas/api/data-api-resources/#error-codes

src/client.ts

@@ -41,6 +41,7 @@ const createMongoClient = (headers?: Headers) => {
     fetch,
     headers,
   });
+
   return c;
 };