@bentonow/bento-node-sdk 1.0.4 → 1.0.5

package/src/sdk/client/index.ts

@@ -1,6 +1,15 @@
 import fetch from 'cross-fetch';
 import type { AnalyticsOptions, AuthenticationOptions } from '../interfaces';
-import { NotAuthorizedError, RateLimitedError, AuthorNotAuthorizedError } from './errors';
+import {
+  NotAuthorizedError,
+  RateLimitedError,
+  AuthorNotAuthorizedError,
+  RequestTimeoutError,
+} from './errors';
+
+interface RequestOptions {
+  timeout?: number | null;
+}
 
 function encodeBase64(str: string): string {
   if (typeof btoa === 'function') {
@@ -29,17 +38,20 @@ function encodeBase64(str: string): string {
     return output;
   }
 }
+
 export class BentoClient {
   private readonly _headers: HeadersInit = {};
   private readonly _baseUrl: string = 'https://app.bentonow.com/api/v1';
   private readonly _siteUuid: string = '';
   private readonly _logErrors: boolean = false;
+  private readonly _timeout: number = 30000; // 30 seconds default
 
   constructor(options: AnalyticsOptions) {
     this._baseUrl = options.clientOptions?.baseUrl || this._baseUrl;
     this._siteUuid = options.siteUuid;
     this._headers = this._extractHeaders(options.authentication, options.siteUuid);
     this._logErrors = options.logErrors || false;
+    this._timeout = options.clientOptions?.timeout ?? this._timeout;
   }
 
   /**
@@ -50,24 +62,26 @@ export class BentoClient {
    * @param payload object
    * @returns Promise\<T\>
    * */
-  public get<T>(endpoint: string, payload: Record<string, unknown> = {}): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const queryParameters = this._getQueryParameters(payload);
+  public async get<T>(
+    endpoint: string,
+    payload: Record<string, unknown> = {},
+    requestOptions: RequestOptions = {}
+  ): Promise<T> {
+    const queryParameters = this._getQueryParameters(payload);
+    const url = `${this._baseUrl}${endpoint}?${queryParameters}`;
 
-      fetch(`${this._baseUrl}${endpoint}?${queryParameters}`, {
+    const timeoutMs =
+      requestOptions.timeout === undefined ? this._timeout : requestOptions.timeout;
+    const response = await this._fetchWithTimeout(
+      url,
+      {
         method: 'GET',
         headers: this._headers,
-      })
-        .then(async (result) => {
-          if (this._isSuccessfulStatus(result.status)) {
-            return result.json();
-          }
-
-          throw await this._getErrorForResponse(result);
-        })
-        .then((data) => resolve(data))
-        .catch((error) => reject(error));
-    });
+      },
+      timeoutMs
+    );
+
+    return this._handleResponse<T>(response);
   }
 
   /**
@@ -78,28 +92,30 @@ export class BentoClient {
    * @param payload object
    * @returns Promise\<T\>
    * */
-  public post<T>(endpoint: string, payload: Record<string, unknown> = {}): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const body = this._getBody(payload);
+  public async post<T>(
+    endpoint: string,
+    payload: Record<string, unknown> = {},
+    requestOptions: RequestOptions = {}
+  ): Promise<T> {
+    const body = this._getBody(payload);
+    const url = `${this._baseUrl}${endpoint}`;
 
-      fetch(`${this._baseUrl}${endpoint}`, {
+    const timeoutMs =
+      requestOptions.timeout === undefined ? this._timeout : requestOptions.timeout;
+    const response = await this._fetchWithTimeout(
+      url,
+      {
         method: 'POST',
         headers: {
           ...this._headers,
           'Content-Type': 'application/json',
         },
         body,
-      })
-        .then(async (result) => {
-          if (this._isSuccessfulStatus(result.status)) {
-            return result.json();
-          }
-
-          throw await this._getErrorForResponse(result);
-        })
-        .then((data) => resolve(data))
-        .catch((error) => reject(error));
-    });
+      },
+      timeoutMs
+    );
+
+    return this._handleResponse<T>(response);
   }
 
   /**
@@ -110,28 +126,85 @@ export class BentoClient {
    * @param payload object
    * @returns Promise\<T\>
    * */
-  public patch<T>(endpoint: string, payload: Record<string, unknown> = {}): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const body = this._getBody(payload);
+  public async patch<T>(
+    endpoint: string,
+    payload: Record<string, unknown> = {},
+    requestOptions: RequestOptions = {}
+  ): Promise<T> {
+    const body = this._getBody(payload);
+    const url = `${this._baseUrl}${endpoint}`;
 
-      fetch(`${this._baseUrl}${endpoint}`, {
+    const timeoutMs =
+      requestOptions.timeout === undefined ? this._timeout : requestOptions.timeout;
+    const response = await this._fetchWithTimeout(
+      url,
+      {
         method: 'PATCH',
         headers: {
           ...this._headers,
           'Content-Type': 'application/json',
         },
         body,
-      })
-        .then(async (result) => {
-          if (this._isSuccessfulStatus(result.status)) {
-            return result.json();
-          }
-
-          throw await this._getErrorForResponse(result);
-        })
-        .then((data) => resolve(data))
-        .catch((error) => reject(error));
-    });
+      },
+      timeoutMs
+    );
+
+    return this._handleResponse<T>(response);
+  }
+
+  /**
+   * Performs a fetch request with a configurable timeout.
+   *
+   * @param url The URL to fetch
+   * @param options Fetch options
+   * @returns Promise<Response>
+   */
+  private async _fetchWithTimeout(
+    url: string,
+    options: RequestInit,
+    timeout: number | null
+  ): Promise<Response> {
+    if (timeout === null) {
+      return fetch(url, options);
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+      });
+      return response;
+    } catch (error: unknown) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new RequestTimeoutError(`Request timed out after ${timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  /**
+   * Handles the response from a fetch request, parsing JSON or throwing appropriate errors.
+   *
+   * @param response The fetch Response object
+   * @returns Promise<T> The parsed response data
+   */
+  private async _handleResponse<T>(response: Response): Promise<T> {
+    if (this._isSuccessfulStatus(response.status)) {
+      try {
+        const data = await response.json();
+        return data as T;
+      } catch {
+        // If JSON parsing fails on a successful response, throw a descriptive error
+        throw new Error(`[${response.status}] - Invalid JSON response from server`);
+      }
+    }
+
+    throw await this._getErrorForResponse(response);
   }
 
   /**
@@ -182,7 +255,7 @@ export class BentoClient {
 
     const queryParameters = new URLSearchParams();
     for (const [key, value] of Object.entries(body)) {
-      queryParameters.append(key, value);
+      queryParameters.append(key, String(value));
     }
 
     return queryParameters.toString();
@@ -216,7 +289,7 @@ export class BentoClient {
 
     const contentType = response.headers.get('Content-Type');
     let responseMessage = '';
-    let json: any = null;
+    let json: Record<string, unknown> | null = null;
 
     // Try to parse the response body based on content type
     try {
@@ -244,7 +317,7 @@ export class BentoClient {
 
     // Check for author not authorized error in JSON response
     if (json && json.error === 'Author not authorized to send on this account') {
-      return new AuthorNotAuthorizedError(json.error);
+      return new AuthorNotAuthorizedError(json.error as string);
     }
 
     // If we have JSON but no specific error match, use the JSON string

package/src/sdk/interfaces.ts

@@ -12,4 +12,8 @@ export interface AuthenticationOptions {
 
 export interface ClientOptions {
   baseUrl?: string;
+  /**
+   * Request timeout in milliseconds. Defaults to 30000 (30 seconds).
+   */
+  timeout?: number;
 }

package/src/sdk/sequences/index.ts

@@ -10,12 +10,12 @@ export class BentoSequences {
   /**
    * Returns all of the sequences for the site, including their email templates.
    *
-   * @returns Promise\<Sequence[] | null\>
+   * @returns Promise\<Sequence[]\>
    */
-  public async getSequences(): Promise<Sequence[] | null> {
+  public async getSequences(): Promise<Sequence[]> {
     const result = await this._client.get<DataResponse<Sequence[]>>(this._url);
 
-    if (Object.keys(result).length === 0 || !result.data) return null;
-    return result.data;
+    if (!result || Object.keys(result).length === 0) return [];
+    return result.data ?? [];
   }
 }

package/src/sdk/workflows/index.ts

@@ -10,12 +10,12 @@ export class BentoWorkflows {
   /**
    * Returns all of the workflows for the site, including their email templates.
    *
-   * @returns Promise\<Workflow[] | null\>
+   * @returns Promise\<Workflow[]\>
    */
-  public async getWorkflows(): Promise<Workflow[] | null> {
+  public async getWorkflows(): Promise<Workflow[]> {
     const result = await this._client.get<DataResponse<Workflow[]>>(this._url);
 
-    if (Object.keys(result).length === 0 || !result.data) return null;
-    return result.data;
+    if (!result || Object.keys(result).length === 0) return [];
+    return result.data ?? [];
   }
 }

package/src/versions/v1/index.ts

@@ -23,7 +23,7 @@ import type {
 } from './types';
 import { BentoBroadcasts } from '../../sdk/broadcasts';
 import { BentoStats } from '../../sdk/stats';
-import { Subscriber } from '../../sdk/subscribers/types';
+import type { Subscriber } from '../../sdk/subscribers/types';
 
 export class BentoAPIV1<S = { [key: string]: unknown }, E extends string = '$custom'> {
   private readonly _client: BentoClient;
@@ -255,9 +255,13 @@ export class BentoAPIV1<S = { [key: string]: unknown }, E extends string = '$cus
    * Upserts a subscriber in Bento. If the subscriber exists, their data will be updated.
    * If they don't exist, they will be created with the provided data.
    *
+   * This method still relies on the batch import queue (which can take 1-5 minutes to
+   * finish processing), but it automatically attempts to fetch and return the subscriber
+   * record after the import has been queued.
+   *
    * @example
    * ```typescript
-   * await analytics.V1.upsertSubscriber({
+   * const subscriber = await analytics.V1.upsertSubscriber({
    *   email: 'user@example.com',
    *   fields: {
    *     firstName: 'John',
@@ -269,7 +273,7 @@ export class BentoAPIV1<S = { [key: string]: unknown }, E extends string = '$cus
    * ```
    *
    * @param parameters Object containing subscriber data including email, fields, and tags
-   * @returns Promise<Subscriber<S>> The created or updated subscriber
+   * @returns Promise<Subscriber<S> | null> The created or updated subscriber
    */
   public async upsertSubscriber(
     parameters: Omit<AddSubscriberParameters<S>, 'date'> & {
@@ -278,16 +282,18 @@ export class BentoAPIV1<S = { [key: string]: unknown }, E extends string = '$cus
     }
   ): Promise<Subscriber<S> | null> {
     await this.Batch.importSubscribers({
-      subscribers: [{
-        email: parameters.email,
-        ...parameters.fields,
-        ...(parameters.tags && { tags: parameters.tags }),
-        ...(parameters.remove_tags && { remove_tags: parameters.remove_tags })
-      } as { email: string } & Partial<S>]
+      subscribers: [
+        {
+          email: parameters.email,
+          ...parameters.fields,
+          ...(parameters.tags && { tags: parameters.tags }),
+          ...(parameters.remove_tags && { remove_tags: parameters.remove_tags }),
+        } as { email: string } & Partial<S>,
+      ],
     });
 
     return this.Subscribers.getSubscribers({
-      email: parameters.email
+      email: parameters.email,
     });
   }
 }