@bentonow/bento-node-sdk 0.1.13 → 0.2.0

package/src/sdk/batch/index.ts

@@ -1,18 +1,23 @@
+import type { BentoClient } from '../client';
 import {
-  BatchImportEventsParameter,
-  BatchImportEventsResponse,
-  BatchImportSubscribersParameter,
-  BatchImportSubscribersResponse,
-} from './types';
-import { BentoClient } from '../client';
-import {
+  TooFewEmailsError,
   TooFewEventsError,
   TooFewSubscribersError,
+  TooManyEmailsError,
   TooManyEventsError,
   TooManySubscribersError,
 } from './errors';
+import type {
+  BatchSendTransactionalEmailsParameter,
+  BatchsendTransactionalEmailsResponse,
+  BatchImportEventsParameter,
+  BatchImportEventsResponse,
+  BatchImportSubscribersParameter,
+  BatchImportSubscribersResponse,
+} from './types';
 
-export class BentoBatch<S, E> {
+export class BentoBatch<S, E extends string> {
+  private readonly _maxEmailBatchSize = 100;
   private readonly _maxBatchSize = 1000;
   private readonly _url = '/batch';
 
@@ -39,30 +44,26 @@ export class BentoBatch<S, E> {
   public async importSubscribers(
     parameters: BatchImportSubscribersParameter<S>
   ): Promise<number> {
-    try {
-      if (parameters.subscribers.length === 0) {
-        throw new TooFewSubscribersError(
-          `You must send between 1 and 1,000 subscribers.`
-        );
-      }
-
-      if (parameters.subscribers.length > this._maxBatchSize) {
-        throw new TooManySubscribersError(
-          `You must send between 1 and 1,000 subscribers.`
-        );
-      }
-
-      const result = await this._client.post<BatchImportSubscribersResponse>(
-        `${this._url}/subscribers`,
-        {
-          subscribers: parameters.subscribers,
-        }
+    if (parameters.subscribers.length === 0) {
+      throw new TooFewSubscribersError(
+        `You must send between 1 and 1,000 subscribers.`
       );
+    }
 
-      return result.results;
-    } catch (error) {
-      throw error;
+    if (parameters.subscribers.length > this._maxBatchSize) {
+      throw new TooManySubscribersError(
+        `You must send between 1 and 1,000 subscribers.`
+      );
     }
+
+    const result = await this._client.post<BatchImportSubscribersResponse>(
+      `${this._url}/subscribers`,
+      {
+        subscribers: parameters.subscribers,
+      }
+    );
+
+    return result.results;
   }
 
   /**
@@ -79,29 +80,57 @@ export class BentoBatch<S, E> {
   public async importEvents(
     parameters: BatchImportEventsParameter<S, E>
   ): Promise<number> {
-    try {
-      if (parameters.events.length === 0) {
-        throw new TooFewEventsError(
-          `You must send between 1 and 1,000 events.`
-        );
-      }
+    if (parameters.events.length === 0) {
+      throw new TooFewEventsError(`You must send between 1 and 1,000 events.`);
+    }
 
-      if (parameters.events.length > this._maxBatchSize) {
-        throw new TooManyEventsError(
-          `You must send between 1 and 1,000 events.`
-        );
+    if (parameters.events.length > this._maxBatchSize) {
+      throw new TooManyEventsError(`You must send between 1 and 1,000 events.`);
+    }
+
+    const result = await this._client.post<BatchImportEventsResponse>(
+      `${this._url}/events`,
+      {
+        events: parameters.events,
       }
+    );
 
-      const result = await this._client.post<BatchImportEventsResponse>(
-        `${this._url}/events`,
+    return result.results;
+  }
+
+  /**
+   * Creates a batch job to send transactional emails from Bento's infrastructure. You can pass in
+   * between 1 and 100 emails to send.
+   *
+   * Each email must have a `to` address, a `from` address, a `subject`, an `html_body`
+   * and `transactional: true`.
+   * In addition you can add a `personalizations` object to provide
+   * liquid tsags that will be injected into the email.
+   *
+   * Returns the number of events that were imported.
+   *
+   * @param parameters
+   * @returns Promise\<number\>
+   */
+  public async sendTransactionalEmails(
+    parameters: BatchSendTransactionalEmailsParameter
+  ): Promise<number> {
+    if (parameters.emails.length === 0) {
+      throw new TooFewEmailsError(`You must send between 1 and 100 emails.`);
+    }
+
+    if (parameters.emails.length > this._maxEmailBatchSize) {
+      throw new TooManyEmailsError(`You must send between 1 and 100 emails.`);
+    }
+
+    const result =
+      await this._client.post<BatchsendTransactionalEmailsResponse>(
+        `${this._url}/emails`,
         {
-          events: parameters.events,
+          emails: parameters.emails,
         }
       );
 
-      return result.results;
-    } catch (error) {
-      throw error;
-    }
+    return result.results;
   }
 }

package/src/sdk/batch/types.ts

@@ -0,0 +1,44 @@
+import type { BentoEvent } from './events';
+
+/**
+ * Batch Method Parameter Types
+ */
+export type BatchImportSubscribersParameter<S> = {
+  subscribers: ({
+    email: string;
+  } & Partial<S>)[];
+};
+
+export type BatchImportEventsParameter<S, E extends string> = {
+  events: BentoEvent<S, E>[];
+};
+
+export type TransactionalEmail = {
+  to: string;
+  from: string;
+  subject: string;
+  html_body: string;
+  transactional: boolean;
+  personalizations?: {
+    [key: string]: string | number | boolean;
+  };
+};
+
+export type BatchSendTransactionalEmailsParameter = {
+  emails: TransactionalEmail[];
+};
+
+/**
+ * Batch Method Response Types
+ */
+export type BatchImportSubscribersResponse = {
+  results: number;
+};
+
+export type BatchImportEventsResponse = {
+  results: number;
+};
+
+export type BatchsendTransactionalEmailsResponse = {
+  results: number;
+};

package/src/sdk/client/errors.ts

@@ -1,2 +1,13 @@
-export class NotAuthorizedError extends Error {}
-export class RateLimitedError extends Error {}
+export class NotAuthorizedError extends Error {
+  constructor(message = 'Not authorized') {
+    super(message);
+    this.name = 'NotAuthorizedError';
+  }
+}
+
+export class RateLimitedError extends Error {
+  constructor(message = 'You are being rate limited') {
+    super(message);
+    this.name = 'RateLimitedError';
+  }
+}

package/src/sdk/client/index.ts

@@ -1,5 +1,5 @@
 import fetch from 'isomorphic-fetch';
-import { AnalyticsOptions, AuthenticationOptions } from '../interfaces';
+import type { AnalyticsOptions, AuthenticationOptions } from '../interfaces';
 import { NotAuthorizedError, RateLimitedError } from './errors';
 
 export class BentoClient {
@@ -23,7 +23,10 @@ export class BentoClient {
    * @param payload object
    * @returns Promise\<T\>
    * */
-  public get<T>(endpoint: string, payload: object = {}): Promise<T> {
+  public get<T>(
+    endpoint: string,
+    payload: Record<string, unknown> = {}
+  ): Promise<T> {
     return new Promise<T>((resolve, reject) => {
       const queryParameters = this._getQueryParameters(payload);
 
@@ -31,15 +34,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));
     });
   }
 
@@ -51,7 +54,10 @@ export class BentoClient {
    * @param payload object
    * @returns Promise\<T\>
    * */
-  public post<T>(endpoint: string, payload: object = {}): Promise<T> {
+  public post<T>(
+    endpoint: string,
+    payload: Record<string, unknown> = {}
+  ): Promise<T> {
     return new Promise<T>((resolve, reject) => {
       const body = this._getBody(payload);
 
@@ -63,15 +69,15 @@ 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));
     });
   }
 
@@ -99,7 +105,7 @@ export class BentoClient {
    * @param payload object
    * @returns string
    */
-  private _getBody(payload: object): string {
+  private _getBody(payload: Record<string, unknown>): string {
     return JSON.stringify({
       ...payload,
       site_uuid: this._siteUuid,
@@ -113,7 +119,7 @@ export class BentoClient {
    * @param payload object
    * @returns string
    */
-  private _getQueryParameters(payload: object): string {
+  private _getQueryParameters(payload: Record<string, unknown>): string {
     const body = {
       ...payload,
       site_uuid: this._siteUuid,
@@ -146,6 +152,10 @@ export class BentoClient {
    * @returns Error
    */
   private async _getErrorForResponse(response: Response): Promise<Error> {
+    if (this._logErrors) {
+      console.error(response);
+    }
+
     if (response.status === 401) return new NotAuthorizedError();
     if (response.status === 429) return new RateLimitedError();
 
@@ -164,10 +174,6 @@ export class BentoClient {
         break;
     }
 
-    if (this._logErrors) {
-      console.error(response);
-    }
-
     return new Error(`[${response.status}] - ${responseMessage}`);
   }
 }

package/src/sdk/commands/index.ts

@@ -1,8 +1,8 @@
-import { BentoClient } from '../client';
-import { DataResponse } from '../client/types';
-import { Subscriber } from '../subscribers/types';
+import type { BentoClient } from '../client';
+import type { DataResponse } from '../client/types';
+import type { Subscriber } from '../subscribers/types';
 import { CommandTypes } from './enums';
-import {
+import type {
   AddFieldParameters,
   AddTagParameters,
   ChangeEmailParameters,
@@ -33,23 +33,19 @@ export class BentoCommands<S> {
   public async addTag(
     parameters: AddTagParameters
   ): Promise<Subscriber<S> | null> {
-    try {
-      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;
-    } catch (error) {
-      throw error;
-    }
+    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;
   }
 
   /**
@@ -61,23 +57,19 @@ export class BentoCommands<S> {
   public async removeTag(
     parameters: RemoveTagParameters
   ): Promise<Subscriber<S> | null> {
-    try {
-      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;
-    } catch (error) {
-      throw error;
-    }
+    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;
   }
 
   /**
@@ -95,23 +87,19 @@ export class BentoCommands<S> {
   public async addField(
     parameters: AddFieldParameters<S>
   ): Promise<Subscriber<S> | null> {
-    try {
-      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;
-    } catch (error) {
-      throw error;
-    }
+    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;
   }
 
   /**
@@ -123,23 +111,19 @@ export class BentoCommands<S> {
   public async removeField(
     parameters: RemoveFieldParameters<S>
   ): Promise<Subscriber<S> | null> {
-    try {
-      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;
-    } catch (error) {
-      throw error;
-    }
+    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;
   }
 
   /**
@@ -155,22 +139,18 @@ export class BentoCommands<S> {
   public async subscribe(
     parameters: SubscribeParameters
   ): Promise<Subscriber<S> | null> {
-    try {
-      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;
-    } catch (error) {
-      throw error;
-    }
+    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;
   }
 
   /**
@@ -187,22 +167,18 @@ export class BentoCommands<S> {
   public async unsubscribe(
     parameters: UnsubscribeParameters
   ): Promise<Subscriber<S> | null> {
-    try {
-      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;
-    } catch (error) {
-      throw error;
-    }
+    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;
   }
 
   /**
@@ -214,22 +190,18 @@ export class BentoCommands<S> {
   public async changeEmail(
     parameters: ChangeEmailParameters
   ): Promise<Subscriber<S> | null> {
-    try {
-      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;
-    } catch (error) {
-      throw error;
-    }
+    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/commands/{types.d.ts → types.ts}

@@ -15,7 +15,7 @@ export type AddFieldParameters<S> = {
   email: string;
   field: {
     key: keyof S;
-    value: any;
+    value: unknown;
   };
 };