@bentonow/bento-node-sdk 0.2.1 → 1.0.5

package/src/sdk/client/errors.ts

@@ -11,3 +11,17 @@ export class RateLimitedError extends Error {
     this.name = 'RateLimitedError';
   }
 }
+
+export class AuthorNotAuthorizedError extends Error {
+  constructor(message = 'Author not authorized to send on this account') {
+    super(message);
+    this.name = 'AuthorNotAuthorizedError';
+  }
+}
+
+export class RequestTimeoutError extends Error {
+  constructor(message = 'Request timed out') {
+    super(message);
+    this.name = 'RequestTimeoutError';
+  }
+}

package/src/sdk/client/index.ts

@@ -1,18 +1,57 @@
 import fetch from 'cross-fetch';
 import type { AnalyticsOptions, AuthenticationOptions } from '../interfaces';
-import { NotAuthorizedError, RateLimitedError } from './errors';
+import {
+  NotAuthorizedError,
+  RateLimitedError,
+  AuthorNotAuthorizedError,
+  RequestTimeoutError,
+} from './errors';
+
+interface RequestOptions {
+  timeout?: number | null;
+}
+
+function encodeBase64(str: string): string {
+  if (typeof btoa === 'function') {
+    return btoa(str);
+  } else if (typeof Buffer !== 'undefined') {
+    return Buffer.from(str).toString('base64');
+  } else {
+    // Fallback implementation
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+    let output = '';
+    for (
+      let block = 0, charCode, i = 0, map = chars;
+      str.charAt(i | 0) || ((map = '='), i % 1);
+      output += map.charAt(63 & (block >> (8 - (i % 1) * 8)))
+    ) {
+      charCode = str.charCodeAt((i += 3 / 4));
+
+      if (charCode > 0xff) {
+        throw new Error(
+          "'btoa' failed: The string to be encoded contains characters outside of the Latin1 range."
+        );
+      }
+
+      block = (block << 8) | charCode;
+    }
+    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);
+    this._headers = this._extractHeaders(options.authentication, options.siteUuid);
     this._logErrors = options.logErrors || false;
+    this._timeout = options.clientOptions?.timeout ?? this._timeout;
   }
 
   /**
@@ -23,27 +62,26 @@ export class BentoClient {
    * @param payload object
    * @returns Promise\<T\>
    * */
-  public get<T>(
+  public async get<T>(
     endpoint: string,
-    payload: Record<string, unknown> = {}
+    payload: Record<string, unknown> = {},
+    requestOptions: RequestOptions = {}
   ): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const queryParameters = this._getQueryParameters(payload);
+    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);
   }
 
   /**
@@ -54,47 +92,137 @@ export class BentoClient {
    * @param payload object
    * @returns Promise\<T\>
    * */
-  public post<T>(
+  public async post<T>(
     endpoint: string,
-    payload: Record<string, unknown> = {}
+    payload: Record<string, unknown> = {},
+    requestOptions: RequestOptions = {}
   ): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const body = this._getBody(payload);
+    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);
+  }
+
+  /**
+   * Wraps a PATCH request to the Bento API and automatically adds the required
+   * headers.
+   *
+   * @param endpoint string
+   * @param payload object
+   * @returns Promise\<T\>
+   * */
+  public async patch<T>(
+    endpoint: string,
+    payload: Record<string, unknown> = {},
+    requestOptions: RequestOptions = {}
+  ): Promise<T> {
+    const body = this._getBody(payload);
+    const url = `${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,
+      },
+      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);
+    }
   }
 
   /**
-   * Extracts the `publishableKey` and `secretKey` from the `authentication` options and
-   * adds the `Authorization` header.
+   * 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);
+  }
+
+  /**
+   * Extracts the `publishableKey` and `secretKey` from the `authentication` options,
+   * adds the `Authorization` header, and includes a `User-Agent` header with the site UUID.
    *
    * @param authentication AuthenticationOptions
+   * @param siteUuid string The site UUID to be included in the User-Agent header
    * @returns HeadersInit
    */
-  private _extractHeaders(authentication: AuthenticationOptions): HeadersInit {
-    const authenticationKey = Buffer.from(
+  private _extractHeaders(authentication: AuthenticationOptions, siteUuid: string): HeadersInit {
+    const authenticationKey = encodeBase64(
       `${authentication.publishableKey}:${authentication.secretKey}`
-    ).toString('base64');
+    );
 
     return {
       Authorization: `Basic ${authenticationKey}`,
+      'User-Agent': `bento-node-${siteUuid}`,
     };
   }
 
@@ -127,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();
@@ -161,17 +289,45 @@ export class BentoClient {
 
     const contentType = response.headers.get('Content-Type');
     let responseMessage = '';
+    let json: Record<string, unknown> | null = null;
 
-    switch (contentType?.toLocaleLowerCase()) {
-      case 'text/plain':
-        responseMessage = await response.text();
-        break;
-      case 'application/json':
-        responseMessage = JSON.stringify(await response.json());
-        break;
-      default:
+    // Try to parse the response body based on content type
+    try {
+      if (contentType?.toLowerCase().includes('application/json')) {
+        // For JSON content type, try to parse as JSON
+        try {
+          json = await response.json();
+        } catch {
+          responseMessage = 'Unable to parse JSON response';
+        }
+      } else if (contentType?.toLowerCase().includes('text/plain')) {
+        // For text/plain content type, read as text
+        try {
+          responseMessage = await response.text();
+        } catch {
+          responseMessage = 'Unable to read text response';
+        }
+      } else {
+        // For unknown content types, use default message
         responseMessage = 'Unknown response from the Bento API.';
-        break;
+      }
+    } catch {
+      responseMessage = 'Unable to read response body';
+    }
+
+    // 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 as string);
+    }
+
+    // If we have JSON but no specific error match, use the JSON string
+    if (json) {
+      responseMessage = JSON.stringify(json);
+    }
+
+    // If we still don't have a message, use a default
+    if (!responseMessage) {
+      responseMessage = 'Unknown response from the Bento API.';
     }
 
     return new Error(`[${response.status}] - ${responseMessage}`);

package/src/sdk/commands/index.ts

@@ -30,19 +30,14 @@ export class BentoCommands<S> {
    * @param parameters \{ email: string, tagName: string \}
    * @returns Promise\<Subscriber | null\>
    */
-  public async addTag(
-    parameters: AddTagParameters
-  ): Promise<Subscriber<S> | null> {
-    const result = await this._client.post<DataResponse<Subscriber<S>>>(
-      this._url,
-      {
-        command: {
-          command: CommandTypes.ADD_TAG,
-          email: parameters.email,
-          query: parameters.tagName,
-        },
-      }
-    );
+  public async addTag(parameters: AddTagParameters): Promise<Subscriber<S> | null> {
+    const result = await this._client.post<DataResponse<Subscriber<S>>>(this._url, {
+      command: {
+        command: CommandTypes.ADD_TAG,
+        email: parameters.email,
+        query: parameters.tagName,
+      },
+    });
 
     if (Object.keys(result).length === 0 || !result.data) return null;
     return result.data;
@@ -54,19 +49,14 @@ export class BentoCommands<S> {
    * @param parameters \{ email: string, tagName: string \}
    * @returns Promise\<Subscriber | null\>
    */
-  public async removeTag(
-    parameters: RemoveTagParameters
-  ): Promise<Subscriber<S> | null> {
-    const result = await this._client.post<DataResponse<Subscriber<S>>>(
-      this._url,
-      {
-        command: {
-          command: CommandTypes.REMOVE_TAG,
-          email: parameters.email,
-          query: parameters.tagName,
-        },
-      }
-    );
+  public async removeTag(parameters: RemoveTagParameters): Promise<Subscriber<S> | null> {
+    const result = await this._client.post<DataResponse<Subscriber<S>>>(this._url, {
+      command: {
+        command: CommandTypes.REMOVE_TAG,
+        email: parameters.email,
+        query: parameters.tagName,
+      },
+    });
 
     if (Object.keys(result).length === 0 || !result.data) return null;
     return result.data;
@@ -84,19 +74,14 @@ export class BentoCommands<S> {
    * @param parameters \{ email: string, field: \{ key: string; value: string; \} \}
    * @returns Promise\<Subscriber | null\>
    */
-  public async addField(
-    parameters: AddFieldParameters<S>
-  ): Promise<Subscriber<S> | null> {
-    const result = await this._client.post<DataResponse<Subscriber<S>>>(
-      this._url,
-      {
-        command: {
-          command: CommandTypes.ADD_FIELD,
-          email: parameters.email,
-          query: parameters.field,
-        },
-      }
-    );
+  public async addField(parameters: AddFieldParameters<S>): Promise<Subscriber<S> | null> {
+    const result = await this._client.post<DataResponse<Subscriber<S>>>(this._url, {
+      command: {
+        command: CommandTypes.ADD_FIELD,
+        email: parameters.email,
+        query: parameters.field,
+      },
+    });
 
     if (Object.keys(result).length === 0 || !result.data) return null;
     return result.data;
@@ -108,19 +93,14 @@ export class BentoCommands<S> {
    * @param parameters \{ email: string, fieldName: string \}
    * @returns Promise\<Subscriber | null\>
    */
-  public async removeField(
-    parameters: RemoveFieldParameters<S>
-  ): Promise<Subscriber<S> | null> {
-    const result = await this._client.post<DataResponse<Subscriber<S>>>(
-      this._url,
-      {
-        command: {
-          command: CommandTypes.REMOVE_FIELD,
-          email: parameters.email,
-          query: parameters.fieldName,
-        },
-      }
-    );
+  public async removeField(parameters: RemoveFieldParameters<S>): Promise<Subscriber<S> | null> {
+    const result = await this._client.post<DataResponse<Subscriber<S>>>(this._url, {
+      command: {
+        command: CommandTypes.REMOVE_FIELD,
+        email: parameters.email,
+        query: parameters.fieldName,
+      },
+    });
 
     if (Object.keys(result).length === 0 || !result.data) return null;
     return result.data;
@@ -136,18 +116,13 @@ export class BentoCommands<S> {
    * @param parameters \{ email: string \}
    * @returns Promise\<Subscriber | null\>
    */
-  public async subscribe(
-    parameters: SubscribeParameters
-  ): Promise<Subscriber<S> | null> {
-    const result = await this._client.post<DataResponse<Subscriber<S>>>(
-      this._url,
-      {
-        command: {
-          command: CommandTypes.SUBSCRIBE,
-          email: parameters.email,
-        },
-      }
-    );
+  public async subscribe(parameters: SubscribeParameters): Promise<Subscriber<S> | null> {
+    const result = await this._client.post<DataResponse<Subscriber<S>>>(this._url, {
+      command: {
+        command: CommandTypes.SUBSCRIBE,
+        email: parameters.email,
+      },
+    });
 
     if (Object.keys(result).length === 0 || !result.data) return null;
     return result.data;
@@ -164,18 +139,13 @@ export class BentoCommands<S> {
    * @param parameters \{ email: string \}
    * @returns Promise\<Subscriber | null\>
    */
-  public async unsubscribe(
-    parameters: UnsubscribeParameters
-  ): Promise<Subscriber<S> | null> {
-    const result = await this._client.post<DataResponse<Subscriber<S>>>(
-      this._url,
-      {
-        command: {
-          command: CommandTypes.UNSUBSCRIBE,
-          email: parameters.email,
-        },
-      }
-    );
+  public async unsubscribe(parameters: UnsubscribeParameters): Promise<Subscriber<S> | null> {
+    const result = await this._client.post<DataResponse<Subscriber<S>>>(this._url, {
+      command: {
+        command: CommandTypes.UNSUBSCRIBE,
+        email: parameters.email,
+      },
+    });
 
     if (Object.keys(result).length === 0 || !result.data) return null;
     return result.data;
@@ -187,19 +157,14 @@ export class BentoCommands<S> {
    * @param parameters \{ oldEmail: string, newEmail: string \}
    * @returns Promise\<Subscriber | null\>
    */
-  public async changeEmail(
-    parameters: ChangeEmailParameters
-  ): Promise<Subscriber<S> | null> {
-    const result = await this._client.post<DataResponse<Subscriber<S>>>(
-      this._url,
-      {
-        command: {
-          command: CommandTypes.CHANGE_EMAIL,
-          email: parameters.oldEmail,
-          query: parameters.newEmail,
-        },
-      }
-    );
+  public async changeEmail(parameters: ChangeEmailParameters): Promise<Subscriber<S> | null> {
+    const result = await this._client.post<DataResponse<Subscriber<S>>>(this._url, {
+      command: {
+        command: CommandTypes.CHANGE_EMAIL,
+        email: parameters.oldEmail,
+        query: parameters.newEmail,
+      },
+    });
 
     if (Object.keys(result).length === 0 || !result.data) return null;
     return result.data;

package/src/sdk/email-templates/index.ts

@@ -0,0 +1,39 @@
+import type { BentoClient } from '../client';
+import type { DataResponse } from '../client/types';
+import type { EmailTemplate, GetEmailTemplateParameters, UpdateEmailTemplateParameters } from './types';
+
+export class BentoEmailTemplates {
+  private readonly _url = '/fetch/emails/templates';
+
+  constructor(private readonly _client: BentoClient) {}
+
+  /**
+   * Returns a single email template by ID.
+   *
+   * @param parameters GetEmailTemplateParameters
+   * @returns Promise\<EmailTemplate | null\>
+   */
+  public async getEmailTemplate(parameters: GetEmailTemplateParameters): Promise<EmailTemplate | null> {
+    const result = await this._client.get<DataResponse<EmailTemplate>>(`${this._url}/${parameters.id}`);
+
+    if (Object.keys(result).length === 0 || !result.data) return null;
+    return result.data;
+  }
+
+  /**
+   * Updates an email template's subject and/or HTML content.
+   *
+   * @param parameters UpdateEmailTemplateParameters
+   * @returns Promise\<EmailTemplate | null\>
+   */
+  public async updateEmailTemplate(parameters: UpdateEmailTemplateParameters): Promise<EmailTemplate | null> {
+    const { id, ...updateFields } = parameters;
+
+    const result = await this._client.patch<DataResponse<EmailTemplate>>(`${this._url}/${id}`, {
+      email_template: updateFields,
+    });
+
+    if (Object.keys(result).length === 0 || !result.data) return null;
+    return result.data;
+  }
+}

package/src/sdk/email-templates/types.ts

@@ -0,0 +1,27 @@
+import type { BaseEntity } from '../types';
+
+/**
+ * Email Template Method Parameter Types
+ */
+export type GetEmailTemplateParameters = {
+  id: number;
+};
+
+export type UpdateEmailTemplateParameters = {
+  id: number;
+  subject?: string;
+  html?: string;
+};
+
+/**
+ * Core Email Template Types
+ */
+export type EmailTemplateAttributes = {
+  name: string;
+  subject: string;
+  html: string;
+  created_at: string;
+  stats: Record<string, unknown> | null;
+};
+
+export type EmailTemplate = BaseEntity<EmailTemplateAttributes>;

package/src/sdk/enums.ts

@@ -6,4 +6,7 @@ export enum EntityType {
   TAGS = 'tags',
   VISITORS = 'visitors',
   VISITORS_FIELDS = 'visitors-fields',
+  SEQUENCES = 'sequences',
+  WORKFLOWS = 'workflows',
+  EMAIL_TEMPLATES = 'email_templates',
 }