feat: add dual build system with dynamic fetch wrapper

- Add fetchWrapper system with separate CJS/ESM implementations
- Add setupFetchWrapper.js script for build-time wrapper selection
- Update TypeScript configs to support dual module builds
- Modify apiClient to use new fetch wrapper system
- Update tests for new fetch handling approach

This improves compatibility between CommonJS and ES modules by using
dynamic imports for node-fetch in CJS builds while maintaining
native fetch support in ESM builds.

Author: AaronDDM

package.json

@@ -26,8 +26,8 @@
     "generate-model-index": "node scripts/generateModelIndex.js",
     "prebuild": "npm run export-version && npm run generate-model-index",
     "build": "rm -rf lib && npm run build-esm && npm run build-cjs && npm run generate-lib-package-json",
-    "build-esm": "tsc -p tsconfig.esm.json",
-    "build-cjs": "tsc -p tsconfig.cjs.json",
+    "build-esm": "node scripts/setupFetchWrapper.js esm && tsc -p tsconfig.esm.json",
+    "build-cjs": "node scripts/setupFetchWrapper.js cjs && tsc -p tsconfig.cjs.json",
     "prepare": "npm run build",
     "build:docs": "typedoc --out docs",
     "version": "npm run export-version && git add src/version.ts"

scripts/setupFetchWrapper.js

@@ -0,0 +1,29 @@
+/**
+ * Script to copy the appropriate fetchWrapper implementation based on build type
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const buildType = process.argv[2]; // 'esm' or 'cjs'
+
+if (!buildType || !['esm', 'cjs'].includes(buildType)) {
+  console.error('Usage: node setupFetchWrapper.js <esm|cjs>');
+  process.exit(1);
+}
+
+const srcDir = path.join(__dirname, '..', 'src', 'utils');
+const sourceFile = path.join(srcDir, `fetchWrapper-${buildType}.ts`);
+const targetFile = path.join(srcDir, 'fetchWrapper.ts');
+
+// Ensure source file exists
+if (!fs.existsSync(sourceFile)) {
+  console.error(`Source file ${sourceFile} does not exist`);
+  process.exit(1);
+}
+
+// Copy the appropriate implementation
+fs.copyFileSync(sourceFile, targetFile);
+/* eslint-disable no-console */
+console.log(`✅ Copied fetchWrapper-${buildType}.ts to fetchWrapper.ts`);
+/* eslint-enable no-console */

src/apiClient.ts

@@ -1,4 +1,3 @@
-import fetch, { Request, Response } from 'node-fetch';
 import { Readable as _Readable } from 'node:stream';
 import { NylasConfig, OverridableNylasConfig } from './config.js';
 import {
@@ -11,6 +10,8 @@ import { SDK_VERSION } from './version.js';
 import { FormData } from 'formdata-node';
 import { FormDataEncoder as _FormDataEncoder } from 'form-data-encoder';
 import { snakeCase } from 'change-case';
+import { getFetch, getRequest } from './utils/fetchWrapper.js';
+import type { Request, Response } from './utils/fetchWrapper.js';
 
 /**
  * The header key for the debugging flow ID
@@ -155,7 +156,7 @@ export default class APIClient {
   }
 
   private async sendRequest(options: RequestOptionsParams): Promise<Response> {
-    const req = this.newRequest(options);
+    const req = await this.newRequest(options);
     const controller: AbortController = new AbortController();
 
     // Handle timeout
@@ -177,6 +178,7 @@ export default class APIClient {
     }, timeoutDuration);
 
     try {
+      const fetch = await getFetch();
       const response = await fetch(req, {
         signal: controller.signal as AbortSignal,
       });
@@ -271,9 +273,10 @@ export default class APIClient {
     return requestOptions;
   }
 
-  newRequest(options: RequestOptionsParams): Request {
+  async newRequest(options: RequestOptionsParams): Promise<Request> {
     const newOptions = this.requestOptions(options);
-    return new Request(newOptions.url, {
+    const RequestConstructor = await getRequest();
+    return new RequestConstructor(newOptions.url, {
       method: newOptions.method,
       headers: newOptions.headers,
       body: newOptions.body,

src/utils/fetchWrapper-cjs.ts

@@ -0,0 +1,73 @@
+/**
+ * Fetch wrapper for CJS builds - uses dynamic imports for node-fetch compatibility
+ */
+
+// Types for the dynamic import result
+interface NodeFetchModule {
+  default: any; // fetch function
+  Request: any; // Request constructor
+  Response: any; // Response constructor
+}
+
+// Cache for the dynamically imported module
+let nodeFetchModule: NodeFetchModule | null = null;
+
+/**
+ * Get fetch function - uses dynamic import for CJS
+ */
+export async function getFetch(): Promise<any> {
+  // In test environment, use global fetch (mocked by jest-fetch-mock)
+  if (typeof global !== 'undefined' && global.fetch) {
+    return global.fetch;
+  }
+
+  if (!nodeFetchModule) {
+    // Use Function constructor to prevent TypeScript from converting to require()
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    nodeFetchModule = (await dynamicImport('node-fetch')) as NodeFetchModule;
+  }
+
+  return nodeFetchModule.default;
+}
+
+/**
+ * Get Request constructor - uses dynamic import for CJS
+ */
+export async function getRequest(): Promise<any> {
+  // In test environment, use global Request or a mock
+  if (typeof global !== 'undefined' && global.Request) {
+    return global.Request;
+  }
+
+  if (!nodeFetchModule) {
+    // Use Function constructor to prevent TypeScript from converting to require()
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    nodeFetchModule = (await dynamicImport('node-fetch')) as NodeFetchModule;
+  }
+
+  return nodeFetchModule.Request;
+}
+
+/**
+ * Get Response constructor - uses dynamic import for CJS
+ */
+export async function getResponse(): Promise<any> {
+  // In test environment, use global Response or a mock
+  if (typeof global !== 'undefined' && global.Response) {
+    return global.Response;
+  }
+
+  if (!nodeFetchModule) {
+    // Use Function constructor to prevent TypeScript from converting to require()
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    nodeFetchModule = (await dynamicImport('node-fetch')) as NodeFetchModule;
+  }
+
+  return nodeFetchModule.Response;
+}
+
+// Export types as any for CJS compatibility
+export type RequestInit = any;
+export type HeadersInit = any;
+export type Request = any;
+export type Response = any;

src/utils/fetchWrapper-esm.ts

@@ -0,0 +1,30 @@
+/**
+ * Fetch wrapper for ESM builds - uses static imports for optimal performance
+ */
+
+import fetch, { Request, Response } from 'node-fetch';
+import type { RequestInit, HeadersInit } from 'node-fetch';
+
+/**
+ * Get fetch function - uses static import for ESM
+ */
+export async function getFetch(): Promise<typeof fetch> {
+  return fetch;
+}
+
+/**
+ * Get Request constructor - uses static import for ESM
+ */
+export async function getRequest(): Promise<typeof Request> {
+  return Request;
+}
+
+/**
+ * Get Response constructor - uses static import for ESM
+ */
+export async function getResponse(): Promise<typeof Response> {
+  return Response;
+}
+
+// Export types directly
+export type { RequestInit, HeadersInit, Request, Response };

src/utils/fetchWrapper.ts

@@ -0,0 +1,73 @@
+/**
+ * Fetch wrapper for CJS builds - uses dynamic imports for node-fetch compatibility
+ */
+
+// Types for the dynamic import result
+interface NodeFetchModule {
+  default: any; // fetch function
+  Request: any; // Request constructor
+  Response: any; // Response constructor
+}
+
+// Cache for the dynamically imported module
+let nodeFetchModule: NodeFetchModule | null = null;
+
+/**
+ * Get fetch function - uses dynamic import for CJS
+ */
+export async function getFetch(): Promise<any> {
+  // In test environment, use global fetch (mocked by jest-fetch-mock)
+  if (typeof global !== 'undefined' && global.fetch) {
+    return global.fetch;
+  }
+
+  if (!nodeFetchModule) {
+    // Use Function constructor to prevent TypeScript from converting to require()
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    nodeFetchModule = (await dynamicImport('node-fetch')) as NodeFetchModule;
+  }
+
+  return nodeFetchModule.default;
+}
+
+/**
+ * Get Request constructor - uses dynamic import for CJS
+ */
+export async function getRequest(): Promise<any> {
+  // In test environment, use global Request or a mock
+  if (typeof global !== 'undefined' && global.Request) {
+    return global.Request;
+  }
+
+  if (!nodeFetchModule) {
+    // Use Function constructor to prevent TypeScript from converting to require()
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    nodeFetchModule = (await dynamicImport('node-fetch')) as NodeFetchModule;
+  }
+
+  return nodeFetchModule.Request;
+}
+
+/**
+ * Get Response constructor - uses dynamic import for CJS
+ */
+export async function getResponse(): Promise<any> {
+  // In test environment, use global Response or a mock
+  if (typeof global !== 'undefined' && global.Response) {
+    return global.Response;
+  }
+
+  if (!nodeFetchModule) {
+    // Use Function constructor to prevent TypeScript from converting to require()
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    nodeFetchModule = (await dynamicImport('node-fetch')) as NodeFetchModule;
+  }
+
+  return nodeFetchModule.Response;
+}
+
+// Export types as any for CJS compatibility
+export type RequestInit = any;
+export type HeadersInit = any;
+export type Request = any;
+export type Response = any;

src/version.ts

@@ -1,2 +1,2 @@
 // This file is generated by scripts/exportVersion.js
-export const SDK_VERSION = '17.13.1';
+export const SDK_VERSION = '17.13.1-canary.4';

tests/apiClient.spec.ts

@@ -162,7 +162,7 @@ describe('APIClient', () => {
     });
 
     describe('newRequest', () => {
-      it('should set all the fields properly', () => {
+      it('should set all the fields properly', async () => {
         client.headers = {
           'global-header': 'global-value',
         };
@@ -178,7 +178,7 @@ describe('APIClient', () => {
             headers: { override: 'bar' },
           },
         };
-        const newRequest = client.newRequest(options);
+        const newRequest = await client.newRequest(options);
 
         expect(newRequest.method).toBe('POST');
         expect(newRequest.headers.raw()).toEqual({

tsconfig.cjs.json

@@ -7,4 +7,5 @@
     "allowSyntheticDefaultImports": true,
     "moduleResolution": "node"
   },
+  "exclude": ["src/utils/fetchWrapper-esm.ts"]
 }

tsconfig.esm.json

@@ -2,6 +2,7 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "module": "es2020",
-    "outDir": "lib/esm",
+    "outDir": "lib/esm"
   },
+  "exclude": ["src/utils/fetchWrapper-cjs.ts"]
 }