refactor: resend client options

src/broadcasts/broadcasts.spec.ts

@@ -256,7 +256,7 @@ describe('Broadcasts', () => {
       `);
     });
 
-    it('returns an error when fetch fails', async () => {
+    it('returns an error when fetch fails (with env base URL)', async () => {
       const originalEnv = process.env;
       process.env = {
         ...originalEnv,
@@ -283,6 +283,38 @@ describe('Broadcasts', () => {
       process.env = originalEnv;
     });
 
+    it('returns an error when fetch fails (with client options)', async () => {
+      const resendWithInvalidBase = new Resend(
+        're_zKa4RCko_Lhm9ost2YjNCctnPjbLw8Nop',
+        { baseUrl: 'http://invalidurl.noturl' },
+      );
+
+      const result = await resendWithInvalidBase.broadcasts.create({
+        from: 'example@resend.com',
+        segmentId: '0192f4f1-d5f9-7110-8eb5-370552515917',
+        subject: 'Hello World',
+        text: 'Hello world',
+      });
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          data: null,
+          error: {
+            message: 'Unable to fetch data. The request could not be resolved.',
+            name: 'application_error',
+            statusCode: null,
+          },
+        }),
+      );
+      expect(fetchMock).toHaveBeenCalledWith(
+        'http://invalidurl.noturl/broadcasts',
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.any(Headers),
+        }),
+      );
+    });
+
     it('returns an error when api responds with text payload', async () => {
       fetchMock.mockOnce('local_rate_limited', {
         status: 422,

src/emails/emails.spec.ts

@@ -367,7 +367,7 @@ describe('Emails', () => {
       `);
     });
 
-    it('returns an error when fetch fails', async () => {
+    it('returns an error when fetch fails (with env base URL)', async () => {
       const originalEnv = process.env;
       process.env = {
         ...originalEnv,
@@ -394,6 +394,34 @@ describe('Emails', () => {
       process.env = originalEnv;
     });
 
+    it('returns an error when fetch fails (with client options)', async () => {
+      const resendWithInvalidBase = new Resend(
+        're_zKa4RCko_Lhm9ost2YjNCctnPjbLw8Nop',
+        { baseUrl: 'http://invalidurl.noturl' },
+      );
+
+      const result = await resendWithInvalidBase.emails.send({
+        from: 'example@resend.com',
+        to: 'bu@resend.com',
+        subject: 'Hello World',
+        text: 'Hello world',
+      });
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          data: null,
+          error: {
+            message: 'Unable to fetch data. The request could not be resolved.',
+            name: 'application_error',
+            statusCode: null,
+          },
+        }),
+      );
+      expect(fetchMock.mock.calls[0][0]).toBe(
+        'http://invalidurl.noturl/emails',
+      );
+    });
+
     it('returns an error when api responds with text payload', async () => {
       fetchMock.mockOnce('local_rate_limited', {
         status: 422,

src/index.ts

@@ -11,7 +11,7 @@ export * from './emails/attachments/interfaces';
 export * from './emails/interfaces';
 export * from './emails/receiving/interfaces';
 export type { ErrorResponse, Response } from './interfaces';
-export { Resend } from './resend';
+export { Resend, type ResendClientOptions } from './resend';
 export * from './segments/interfaces';
 export * from './templates/interfaces';
 export * from './topics/interfaces';

src/resend.ts

@@ -17,17 +17,25 @@ import { Webhooks } from './webhooks/webhooks';
 
 const defaultBaseUrl = 'https://api.resend.com';
 const defaultUserAgent = `resend-node:${version}`;
-const baseUrl =
-  typeof process !== 'undefined' && process.env
-    ? process.env.RESEND_BASE_URL || defaultBaseUrl
-    : defaultBaseUrl;
-const userAgent =
-  typeof process !== 'undefined' && process.env
-    ? process.env.RESEND_USER_AGENT || defaultUserAgent
-    : defaultUserAgent;
+
+/** optional options when creating the client instead of env variables */
+export type ResendClientOptions = {
+  baseUrl?: string;
+  userAgent?: string;
+  /** custom fetch can be used for tests. */
+  fetch?: typeof fetch;
+};
+
+function getEnv(name: string): string | undefined {
+  if (typeof process === 'undefined' || !process.env) return undefined;
+  return process.env[name];
+}
 
 export class Resend {
   private readonly headers: Headers;
+  private readonly baseUrl: string;
+  private readonly fetchImpl: typeof fetch;
+  private readonly _key: string;
 
   readonly apiKeys = new ApiKeys(this);
   readonly segments = new Segments(this);
@@ -45,29 +53,35 @@ export class Resend {
   readonly templates = new Templates(this);
   readonly topics = new Topics(this);
 
-  constructor(readonly key?: string) {
-    if (!key) {
-      if (typeof process !== 'undefined' && process.env) {
-        this.key = process.env.RESEND_API_KEY;
-      }
-
-      if (!this.key) {
-        throw new Error(
-          'Missing API key. Pass it to the constructor `new Resend("re_123")`',
-        );
-      }
+  constructor(key?: string, options?: ResendClientOptions) {
+    const apiKey = key ?? getEnv('RESEND_API_KEY');
+    if (!apiKey) {
+      throw new Error(
+        'Missing API key. Pass it to the constructor `new Resend("re_123")` or set RESEND_API_KEY.',
+      );
     }
+    this._key = apiKey;
+
+    this.baseUrl =
+      options?.baseUrl ?? (getEnv('RESEND_BASE_URL') || defaultBaseUrl);
+    const userAgent =
+      options?.userAgent ?? (getEnv('RESEND_USER_AGENT') || defaultUserAgent);
+    this.fetchImpl = options?.fetch ?? fetch;
 
     this.headers = new Headers({
-      Authorization: `Bearer ${this.key}`,
+      Authorization: `Bearer ${apiKey}`,
       'User-Agent': userAgent,
       'Content-Type': 'application/json',
     });
   }
 
+  get key(): string {
+    return this._key;
+  }
+
   async fetchRequest<T>(path: string, options = {}): Promise<Response<T>> {
     try {
-      const response = await fetch(`${baseUrl}${path}`, options);
+      const response = await this.fetchImpl(`${this.baseUrl}${path}`, options);
 
       if (!response.ok) {
         try {