@bentonow/bento-node-sdk 0.2.1 → 1.0.4

package/src/sdk/client/index.ts

@@ -1,7 +1,34 @@
 import fetch from 'cross-fetch';
 import type { AnalyticsOptions, AuthenticationOptions } from '../interfaces';
-import { NotAuthorizedError, RateLimitedError } from './errors';
+import { NotAuthorizedError, RateLimitedError, AuthorNotAuthorizedError } from './errors';
 
+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';
@@ -11,7 +38,7 @@ export class BentoClient {
   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;
   }
 
@@ -23,10 +50,7 @@ export class BentoClient {
    * @param payload object
    * @returns Promise\<T\>
    * */
-  public get<T>(
-    endpoint: string,
-    payload: Record<string, unknown> = {}
-  ): Promise<T> {
+  public get<T>(endpoint: string, payload: Record<string, unknown> = {}): Promise<T> {
     return new Promise<T>((resolve, reject) => {
       const queryParameters = this._getQueryParameters(payload);
 
@@ -34,15 +58,15 @@ export class BentoClient {
         method: 'GET',
         headers: this._headers,
       })
-        .then(async result => {
+        .then(async (result) => {
           if (this._isSuccessfulStatus(result.status)) {
             return result.json();
           }
 
           throw await this._getErrorForResponse(result);
         })
-        .then(data => resolve(data))
-        .catch(error => reject(error));
+        .then((data) => resolve(data))
+        .catch((error) => reject(error));
     });
   }
 
@@ -54,10 +78,7 @@ export class BentoClient {
    * @param payload object
    * @returns Promise\<T\>
    * */
-  public post<T>(
-    endpoint: string,
-    payload: Record<string, unknown> = {}
-  ): Promise<T> {
+  public post<T>(endpoint: string, payload: Record<string, unknown> = {}): Promise<T> {
     return new Promise<T>((resolve, reject) => {
       const body = this._getBody(payload);
 
@@ -69,32 +90,66 @@ export class BentoClient {
         },
         body,
       })
-        .then(async result => {
+        .then(async (result) => {
           if (this._isSuccessfulStatus(result.status)) {
             return result.json();
           }
 
           throw await this._getErrorForResponse(result);
         })
-        .then(data => resolve(data))
-        .catch(error => reject(error));
+        .then((data) => resolve(data))
+        .catch((error) => reject(error));
     });
   }
 
   /**
-   * Extracts the `publishableKey` and `secretKey` from the `authentication` options and
-   * adds the `Authorization` header.
+   * Wraps a PATCH request to the Bento API and automatically adds the required
+   * headers.
+   *
+   * @param endpoint string
+   * @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);
+
+      fetch(`${this._baseUrl}${endpoint}`, {
+        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));
+    });
+  }
+
+  /**
+   * 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}`,
     };
   }
 
@@ -161,17 +216,45 @@ export class BentoClient {
 
     const contentType = response.headers.get('Content-Type');
     let responseMessage = '';
+    let json: any = 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);
+    }
+
+    // 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',
 }

package/src/sdk/experimental/index.ts

@@ -1,8 +1,9 @@
 import type { BentoClient } from '../client';
 import type { LocationData } from '../types';
 import type {
+  BlacklistCheckInput,
   BlacklistParameters,
-  BlacklistResponse,
+  BlacklistResponse, BlacklistResult, ContentModerationResult,
   GeolocateParameters,
   GeolocateResponse,
   GuessGenderParameters,
@@ -29,18 +30,13 @@ export class BentoExperimental {
    * @param parameters
    * @returns Promise\<boolean\>
    */
-  public async validateEmail(
-    parameters: ValidateEmailParameters
-  ): Promise<boolean> {
-    const result = await this._client.post<ValidateEmailResponse>(
-      `${this._url}/validation`,
-      {
-        email: parameters.email,
-        ip: parameters.ip,
-        name: parameters.name,
-        user_agent: parameters.userAgent,
-      }
-    );
+  public async validateEmail(parameters: ValidateEmailParameters): Promise<boolean> {
+    const result = await this._client.post<ValidateEmailResponse>(`${this._url}/validation`, {
+      email: parameters.email,
+      ip: parameters.ip,
+      name: parameters.name,
+      user_agent: parameters.userAgent,
+    });
 
     return result.valid;
   }
@@ -58,13 +54,8 @@ export class BentoExperimental {
    * @param parameters
    * @returns Promise\<GuessGenderResponse\>
    */
-  public async guessGender(
-    parameters: GuessGenderParameters
-  ): Promise<GuessGenderResponse> {
-    const result = await this._client.post<GuessGenderResponse>(
-      `${this._url}/gender`,
-      parameters
-    );
+  public async guessGender(parameters: GuessGenderParameters): Promise<GuessGenderResponse> {
+    const result = await this._client.post<GuessGenderResponse>(`${this._url}/gender`, parameters);
 
     return result;
   }
@@ -78,9 +69,7 @@ export class BentoExperimental {
    * @param parameters
    * @returns Promise\<GeolocateResponse\>
    */
-  public async geolocate(
-    parameters: GeolocateParameters
-  ): Promise<LocationData | null> {
+  public async geolocate(parameters: GeolocateParameters): Promise<LocationData | null> {
     const result = await this._client.get<GeolocateResponse>(
       `${this._url}/geolocation`,
       parameters
@@ -100,9 +89,7 @@ export class BentoExperimental {
    * @param parameters
    * @returns Promise\<BlacklistResponse\>
    */
-  public async checkBlacklist(
-    parameters: BlacklistParameters
-  ): Promise<BlacklistResponse> {
+  public async checkBlacklist(parameters: BlacklistParameters): Promise<BlacklistResponse> {
     const result = await this._client.get<BlacklistResponse>(
       `${this._url}/blacklist.json`,
       parameters
@@ -110,4 +97,35 @@ export class BentoExperimental {
 
     return result;
   }
+
+  /**
+   * Checks if a domain or IP is blacklisted
+   * @param input Domain or IP to check
+   * @returns Promise<BlacklistResult>
+   */
+  public async getBlacklistStatus(input: BlacklistCheckInput): Promise<BlacklistResult> {
+    return this._client.get<BlacklistResult>(`${this._url}/blacklist`, input);
+  }
+
+  /**
+   * Performs content moderation on provided text
+   * @param content Text content to moderate
+   * @returns Promise<ContentModerationResult>
+   */
+  public async getContentModeration(content: string): Promise<ContentModerationResult> {
+    return this._client.post<ContentModerationResult>(`${this._url}/moderation`, {
+      content
+    });
+  }
+
+  /**
+   * Gets geolocation data for an IP address
+   * @param ipAddress IP address to geolocate
+   * @returns Promise<LocationData>
+   */
+  public async geoLocateIP(ipAddress: string): Promise<LocationData> {
+    return this._client.get<LocationData>(`${this._url}/geolocation`, {
+      ip: ipAddress
+    });
+  }
 }

package/src/sdk/experimental/types.ts

@@ -28,6 +28,13 @@ export type BlacklistParameters =
       ip: string;
     };
 
+export type BlacklistCheckInput = {
+  domain?: string;
+  ipAddress?: string;
+};
+
+
+
 /**
  * Experimental Method Response Types
  */
@@ -47,3 +54,31 @@ export type BlacklistResponse = {
   query: string;
   results: { [key: string]: boolean };
 };
+
+export type BlacklistResult = {
+  description: string;
+  query: string;
+  results: Record<string, boolean>;
+};
+
+export type ContentModerationResult = {
+  flagged: boolean;
+  categories: {
+    hate: boolean;
+    'hate/threatening': boolean;
+    'self-harm': boolean;
+    sexual: boolean;
+    'sexual/minors': boolean;
+    violence: boolean;
+    'violence/graphic': boolean;
+  };
+  category_scores: {
+    hate: number;
+    'hate/threatening': number;
+    'self-harm': number;
+    sexual: number;
+    'sexual/minors': number;
+    violence: number;
+    'violence/graphic': number;
+  };
+};

package/src/sdk/fields/index.ts

@@ -34,9 +34,7 @@ export class BentoFields {
    * @param parameters \{ key: string \}
    * @returns Promise<Field[]>
    */
-  public async createField(
-    parameters: CreateFieldParameters
-  ): Promise<Field[] | null> {
+  public async createField(parameters: CreateFieldParameters): Promise<Field[] | null> {
     const result = await this._client.post<DataResponse<Field[]>>(this._url, {
       field: parameters,
     });

package/src/sdk/forms/index.ts

@@ -13,15 +13,10 @@ export class BentoForms {
    * @param formIdentifier string
    * @returns Promise\<FormResponse[] | null\>
    */
-  public async getResponses(
-    formIdentifier: string
-  ): Promise<FormResponse[] | null> {
-    const result = await this._client.get<DataResponse<FormResponse[]>>(
-      this._url,
-      {
-        id: formIdentifier,
-      }
-    );
+  public async getResponses(formIdentifier: string): Promise<FormResponse[] | null> {
+    const result = await this._client.get<DataResponse<FormResponse[]>>(this._url, {
+      id: formIdentifier,
+    });
 
     if (Object.keys(result).length === 0 || !result.data) return null;
     return result.data;

package/src/sdk/forms/types.ts

@@ -1,10 +1,4 @@
-import type {
-  BaseEntity,
-  BrowserData,
-  IdentityData,
-  LocationData,
-  PageData,
-} from '../types';
+import type { BaseEntity, BrowserData, IdentityData, LocationData, PageData } from '../types';
 
 /**
  * Core Form Types