mailgun.js 4.0.1 → 4.1.3

package/dist/mailgun.web.js.LICENSE.txt

@@ -4,4 +4,4 @@
 
 /*! https://mths.be/punycode v1.3.2 by @mathias */
 
-/*! mailgun.js v4.0.0 */
+/*! mailgun.js v4.1.2 */

package/lib/client.ts

@@ -18,6 +18,7 @@ import MailListsMembers from './mailListMembers';
 import { InputFormData } from './interfaces/IFormData';
 import DomainCredentialsClient from './domainsCredentials';
 import MultipleValidationClient from './multipleValidation';
+import DomainTemplatesClient from './domainsTemplates';
 
 export default class Client {
   private request;
@@ -53,9 +54,10 @@ export default class Client {
     this.request = new Request(config, formData);
     const mailListsMembers = new MailListsMembers(this.request);
     const domainCredentialsClient = new DomainCredentialsClient(this.request);
+    const domainTemplatesClient = new DomainTemplatesClient(this.request);
     const multipleValidationClient = new MultipleValidationClient(this.request);
 
-    this.domains = new DomainClient(this.request, domainCredentialsClient);
+    this.domains = new DomainClient(this.request, domainCredentialsClient, domainTemplatesClient);
     this.webhooks = new WebhookClient(this.request);
     this.events = new EventClient(this.request);
     this.stats = new StatsClient(this.request);

package/lib/domains.ts

@@ -37,7 +37,10 @@ import {
   UpdateDomainTrackingResponse,
   UpdatedOpenTracking
 } from './interfaces/DomainTracking';
+import { IDomainCredentials } from './interfaces/DomainCredentials';
+import { IDomainTemplatesClient } from './interfaces/DomainTemplates';
 import DomainCredentialsClient from './domainsCredentials';
+import DomainTemplatesClient from './domainsTemplates';
 
 export class Domain {
   name: string;
@@ -72,11 +75,17 @@ export class Domain {
 
 export default class DomainClient {
   request: Request;
-  public domainCredentials: DomainCredentialsClient;
-
-  constructor(request: Request, domainCredentialsClient: DomainCredentialsClient) {
+  public domainCredentials: IDomainCredentials;
+  public domainTemplates: IDomainTemplatesClient
+
+  constructor(
+    request: Request,
+    domainCredentialsClient: DomainCredentialsClient,
+    domainTemplatesClient: DomainTemplatesClient
+  ) {
     this.request = request;
     this.domainCredentials = domainCredentialsClient;
+    this.domainTemplates = domainTemplatesClient;
   }
 
   private _parseMessage(response: DestroyedDomainResponse) : MessageResponse {

package/lib/domainsTemplates.ts

@@ -0,0 +1,234 @@
+import urljoin from 'url-join';
+import APIResponse from './interfaces/ApiResponse';
+import Request from './request';
+
+import {
+  CreateDomainTemplateAPIResponse,
+  CreateDomainTemplateVersionAPIResponse,
+  CreateDomainTemplateVersionResult,
+  DomainTemplate, DomainTemplateData,
+  DomainTemplatesQuery,
+  DomainTemplateUpdateData,
+  DomainTemplateUpdateVersionData,
+  DomainTemplateVersionData,
+  GetDomainTemplateAPIResponse,
+  IDomainTemplatesClient,
+  ListDomainTemplatesAPIResponse,
+  ListDomainTemplatesResult,
+  ListDomainTemplateVersionsAPIResponse,
+  ListDomainTemplateVersionsResult,
+  MutateDomainTemplateVersionAPIResponse,
+  MutateDomainTemplateVersionResult,
+  NotificationAPIResponse,
+  NotificationResult,
+  ShortTemplateVersion,
+  TemplateVersion,
+  UpdateOrDeleteDomainTemplateAPIResponse,
+  UpdateOrDeleteDomainTemplateResult
+} from './interfaces/DomainTemplates';
+
+export class DomainTemplateItem implements DomainTemplate {
+  name : string;
+  description : string;
+  createdAt : Date | '';
+  createdBy : string;
+  id : string;
+  version?: TemplateVersion;
+  versions?: ShortTemplateVersion[];
+
+  constructor(domainTemplateFromAPI: DomainTemplate) {
+    this.name = domainTemplateFromAPI.name;
+    this.description = domainTemplateFromAPI.description;
+    this.createdAt = domainTemplateFromAPI.createdAt ? new Date(domainTemplateFromAPI.createdAt) : '';
+    this.createdBy = domainTemplateFromAPI.createdBy;
+    this.id = domainTemplateFromAPI.id;
+
+    if (domainTemplateFromAPI.version) {
+      this.version = domainTemplateFromAPI.version;
+      if (domainTemplateFromAPI.version.createdAt) {
+        this.version.createdAt = new Date(domainTemplateFromAPI.version.createdAt);
+      }
+    }
+
+    if (domainTemplateFromAPI.versions && domainTemplateFromAPI.versions.length) {
+      this.versions = domainTemplateFromAPI.versions.map((version) => {
+        const result = { ...version };
+        result.createdAt = new Date(version.createdAt);
+        return result;
+      });
+    }
+  }
+}
+
+export default class DomainTemplatesClient implements IDomainTemplatesClient {
+  baseRoute: string;
+  request: Request;
+
+  constructor(request: Request) {
+    this.request = request;
+    this.baseRoute = '/v3/';
+  }
+
+  private parseCreationResponse(data: CreateDomainTemplateAPIResponse): DomainTemplateItem {
+    return new DomainTemplateItem(data.body.template);
+  }
+
+  private parseCreationVersionResponse(
+    data: CreateDomainTemplateVersionAPIResponse
+  ): CreateDomainTemplateVersionResult {
+    const result: CreateDomainTemplateVersionResult = {} as CreateDomainTemplateVersionResult;
+    result.status = data.status;
+    result.message = data.body.message;
+    if (data.body && data.body.template) {
+      result.template = new DomainTemplateItem(data.body.template);
+    }
+    return result;
+  }
+
+  private parseMutationResponse(
+    data: UpdateOrDeleteDomainTemplateAPIResponse
+  ): UpdateOrDeleteDomainTemplateResult {
+    const result: UpdateOrDeleteDomainTemplateResult = {} as UpdateOrDeleteDomainTemplateResult;
+    result.status = data.status;
+    result.message = data.body.message;
+    if (data.body && data.body.template) {
+      result.templateName = data.body.template.name;
+    }
+    return result;
+  }
+
+  private parseNotificationResponse(data: NotificationAPIResponse): NotificationResult {
+    const result: NotificationResult = {} as NotificationResult;
+    result.status = data.status;
+    result.message = data.body.message;
+    return result;
+  }
+
+  private parseMutateTemplateVersionResponse(
+    data: MutateDomainTemplateVersionAPIResponse
+  ): MutateDomainTemplateVersionResult {
+    const result: MutateDomainTemplateVersionResult = {} as MutateDomainTemplateVersionResult;
+    result.status = data.status;
+    result.message = data.body.message;
+    if (data.body.template) {
+      result.templateName = data.body.template.name;
+      result.templateVersion = { tag: data.body.template.version.tag };
+    }
+    return result;
+  }
+
+  private parseList(response: ListDomainTemplatesAPIResponse): ListDomainTemplatesResult {
+    const data = {} as ListDomainTemplatesResult;
+
+    data.items = response.body.items.map((d: DomainTemplate) => new DomainTemplateItem(d));
+
+    data.pages = response.body.paging;
+
+    return data;
+  }
+
+  private parseListTemplateVersions(
+    response: ListDomainTemplateVersionsAPIResponse
+  ): ListDomainTemplateVersionsResult {
+    const data = {} as ListDomainTemplateVersionsResult;
+
+    data.template = new DomainTemplateItem(response.body.template);
+
+    data.pages = response.body.paging;
+
+    return data;
+  }
+
+  list(domain: string, query?: DomainTemplatesQuery): Promise<ListDomainTemplatesResult> {
+    return this.request.get(urljoin(this.baseRoute, domain, '/templates'), query)
+      .then(
+        (res: APIResponse) => this.parseList(res)
+      );
+  }
+
+  get(domain: string, templateName: string): Promise<DomainTemplateItem> {
+    return this.request.get(urljoin(this.baseRoute, domain, '/templates/', templateName))
+      .then(
+        (res: GetDomainTemplateAPIResponse) => new DomainTemplateItem(res.body.template)
+      );
+  }
+
+  create(
+    domain: string,
+    data: DomainTemplateData
+  ): Promise<DomainTemplateItem> {
+    return this.request.postWithFD(urljoin(this.baseRoute, domain, '/templates'), data)
+      .then((res: CreateDomainTemplateAPIResponse) => this.parseCreationResponse(res));
+  }
+
+  update(
+    domain: string,
+    templateName: string,
+    data: DomainTemplateUpdateData
+  ): Promise<UpdateOrDeleteDomainTemplateResult> {
+    return this.request.putWithFD(urljoin(this.baseRoute, domain, '/templates/', templateName), data)
+      .then((res: UpdateOrDeleteDomainTemplateAPIResponse) => this.parseMutationResponse(res));
+  }
+
+  destroy(domain: string, templateName: string): Promise<UpdateOrDeleteDomainTemplateResult> {
+    return this.request.delete(urljoin(this.baseRoute, domain, '/templates/', templateName))
+      .then((res: UpdateOrDeleteDomainTemplateAPIResponse) => this.parseMutationResponse(res));
+  }
+
+  destroyAll(domain: string): Promise<NotificationResult> {
+    return this.request.delete(urljoin(this.baseRoute, domain, '/templates'))
+      .then((res: NotificationAPIResponse) => this.parseNotificationResponse(res));
+  }
+
+  createVersion(
+    domain: string,
+    templateName: string,
+    data: DomainTemplateVersionData
+  ): Promise<CreateDomainTemplateVersionResult> {
+    return this.request.postWithFD(urljoin(this.baseRoute, domain, '/templates/', templateName, '/versions'), data)
+      .then(
+        (res: CreateDomainTemplateVersionAPIResponse) => this.parseCreationVersionResponse(res)
+      );
+  }
+
+  getVersion(domain: string, templateName: string, tag: string): Promise<DomainTemplateItem> {
+    return this.request.get(urljoin(this.baseRoute, domain, '/templates/', templateName, '/versions/', tag))
+      .then(
+        (res: GetDomainTemplateAPIResponse) => new DomainTemplateItem(res.body.template)
+      );
+  }
+
+  updateVersion(
+    domain: string,
+    templateName: string,
+    tag: string,
+    data: DomainTemplateUpdateVersionData
+  ): Promise<MutateDomainTemplateVersionResult> {
+    return this.request.putWithFD(urljoin(this.baseRoute, domain, '/templates/', templateName, '/versions/', tag), data)
+      .then(
+        // eslint-disable-next-line max-len
+        (res: MutateDomainTemplateVersionAPIResponse) => this.parseMutateTemplateVersionResponse(res)
+      );
+  }
+
+  destroyVersion(
+    domain: string,
+    templateName: string,
+    tag: string
+  ): Promise<MutateDomainTemplateVersionResult> {
+    return this.request.delete(urljoin(this.baseRoute, domain, '/templates/', templateName, '/versions/', tag))
+      // eslint-disable-next-line max-len
+      .then((res: MutateDomainTemplateVersionAPIResponse) => this.parseMutateTemplateVersionResponse(res));
+  }
+
+  listVersions(
+    domain: string,
+    templateName: string,
+    query?: DomainTemplatesQuery
+  ): Promise<ListDomainTemplateVersionsResult> {
+    return this.request.get(urljoin(this.baseRoute, domain, '/templates', templateName, '/versions'), query)
+      .then(
+        (res: ListDomainTemplateVersionsAPIResponse) => this.parseListTemplateVersions(res)
+      );
+  }
+}

package/lib/interfaces/DomainTemplates.ts

@@ -0,0 +1,234 @@
+import { DomainTemplateItem } from '../domainsTemplates';
+
+export enum YesNo {
+    YES = 'yes',
+    NO = 'no'
+}
+
+export enum Pages {
+    FIRST = 'first',
+    LAST = 'last',
+    NEXT = 'next',
+    PREV = 'prev'
+}
+/* eslint-disable camelcase */
+export interface DomainTemplateData {
+    name: string;
+    description: string;
+    template: string;
+    tag?: string;
+    engine?: string;
+    comment?: string;
+}
+
+export interface DomainTemplateVersionData {
+    template: string;
+    tag: string;
+    engine?: string;
+    comment?: string;
+    active?: YesNo;
+}
+
+export interface DomainTemplateUpdateData {
+    description: string;
+}
+
+export interface DomainTemplateUpdateVersionData {
+    template?: string;
+    comment?: string;
+    active?: YesNo;
+}
+
+export interface DomainTemplatesQuery {
+    page: Pages;
+    limit: number;
+    p: string;
+}
+
+export interface ShortTemplateVersion {
+    tag: string;
+    engine: string;
+    mjml: string;
+    createdAt: string | Date;
+    comment: string;
+    active: boolean;
+    id: string;
+}
+
+export interface TemplateVersion extends ShortTemplateVersion{
+    template: string;
+}
+export interface DomainTemplate {
+    name: string;
+    description: string;
+    createdAt: string | Date;
+    createdBy: string;
+    id: string;
+    version?: TemplateVersion;
+    versions?: ShortTemplateVersion[];
+}
+
+export interface CreateDomainTemplateAPIResponse {
+    status: number;
+    body: {
+        message: string;
+        template: DomainTemplate;
+    };
+}
+
+export interface ListDomainTemplatesAPIResponse {
+    status: number;
+    body: {
+        items: DomainTemplate[];
+        paging: {
+            first: string;
+            last: string;
+            next: string;
+            previous: string;
+        };
+    };
+}
+
+export interface ListDomainTemplatesResult {
+        items: DomainTemplate[];
+        pages: {
+            first: string;
+            last: string;
+            next: string;
+            previous: string;
+        };
+}
+
+export interface GetDomainTemplateAPIResponse {
+    status: number;
+    body: {
+        template: DomainTemplate;
+    };
+}
+
+export interface UpdateOrDeleteDomainTemplateAPIResponse {
+    status: number;
+    body: {
+        message: string;
+        template: {
+            name: string
+        }
+    };
+}
+
+export interface UpdateOrDeleteDomainTemplateResult {
+    status: number;
+    message: string;
+    templateName?: string;
+}
+
+export interface NotificationAPIResponse {
+    status: number;
+    body: {
+        message: string;
+    };
+}
+
+export interface NotificationResult {
+    status: number;
+    message: string;
+}
+
+export interface CreateDomainTemplateVersionAPIResponse {
+    status: number;
+    body: {
+        message: string;
+        template: DomainTemplate;
+    };
+}
+
+export interface CreateDomainTemplateVersionResult {
+    status: number;
+    message: string;
+    template: DomainTemplate;
+}
+
+export interface MutateDomainTemplateVersionAPIResponse {
+    status: number;
+    body: {
+        message: string;
+        template: {
+            name: string;
+            version: {
+                tag: string;
+            }
+        };
+    };
+}
+
+export interface MutateDomainTemplateVersionResult {
+    status: number;
+    message: string;
+    templateName: string;
+    templateVersion: {
+        tag: string;
+    }
+}
+
+export interface ListDomainTemplateVersionsAPIResponse {
+    status: number;
+    body: {
+        template: {
+            name: string;
+            description: string;
+            createdAt: string;
+            createdBy: string;
+            id: string;
+            versions: ShortTemplateVersion[]
+        }
+        paging: {
+            first: string;
+            last: string;
+            next: string;
+            previous: string;
+        };
+    };
+}
+
+export interface ListDomainTemplateVersionsResult {
+    template: DomainTemplateItem;
+    pages: {
+        first: string;
+        last: string;
+        next: string;
+        previous: string;
+    };
+}
+
+export interface IDomainTemplatesClient {
+    list(domain: string, query?: DomainTemplatesQuery): Promise<ListDomainTemplatesResult>
+    get(domain: string, templateName: string): Promise<DomainTemplateItem>
+    create(domain: string, data: DomainTemplateData): Promise<DomainTemplateItem>
+    update(
+        domain: string,
+        templateName: string,
+        data: DomainTemplateUpdateData
+    ): Promise<UpdateOrDeleteDomainTemplateResult>
+    destroy(domain: string, templateName: string): Promise<UpdateOrDeleteDomainTemplateResult>
+    destroyAll(domain: string): Promise<NotificationResult>
+    createVersion(
+        domain: string,
+        templateName: string,
+        data: DomainTemplateVersionData
+    ) : Promise<CreateDomainTemplateVersionResult>
+    getVersion(domain: string, templateName: string, tag: string): Promise<DomainTemplateItem>
+    updateVersion(
+        domain: string,
+        templateName: string,
+        tag: string,
+        data: DomainTemplateUpdateVersionData
+    ): Promise<MutateDomainTemplateVersionResult>
+    destroyVersion(
+        domain: string,
+        templateName: string,
+        tag: string): Promise<MutateDomainTemplateVersionResult>
+    listVersions(
+        domain: string,
+        templateName: string,
+        query?: DomainTemplatesQuery): Promise<ListDomainTemplateVersionsResult>
+}

package/lib/interfaces/StatsOptions.ts

@@ -1,15 +1,23 @@
- interface StatsOptions {
+export interface Stat {
+  time: string | Date,
+  delivered: {
+    smtp: number,
+    http: number,
+    total: number
+  }
+}
+
+export interface StatsOptions {
   start: string | Date;
   end: string | Date;
   resolution: string;
-  stats: {
-    time: string | Date,
-    delivered: {
-      smtp: number,
-      http: number,
-      total: number
-    }
-  }[];
+  stats: Stat[];
 }
 
-export default StatsOptions;
+export interface StatsQuery {
+  event: string | string[];
+  start: string | Date;
+  end: string | Date;
+  resolution: 'hour'| 'day' | 'month';
+  duration: string;
+}

package/lib/interfaces/Supressions.ts

@@ -16,3 +16,10 @@ export interface UnsubscribeData {
   tags: any;
   created_at: string | Date;
 }
+
+export interface WhiteListData {
+  type: string;
+  value: string;
+  reason: string;
+  createdAt: string | Date;
+}

package/lib/ip-pools.ts

@@ -16,12 +16,12 @@ export default class IpPoolsClient {
   }
 
   create(data: { name: string, description?: string, ips?: string[] }) {
-    return this.request.post('/v1/ip_pools', data)
+    return this.request.postWithFD('/v1/ip_pools', data)
       .then((response: { body: { message: string, pool_id: string } }) => response?.body);
   }
 
   update(poolId: string, data: IpPoolUpdateData) : Promise<any> {
-    return this.request.patch(`/v1/ip_pools/${poolId}`, data)
+    return this.request.patchWithFD(`/v1/ip_pools/${poolId}`, data)
       .then((response: { body: any }) => response?.body);
   }
 

package/lib/request.ts

@@ -165,6 +165,17 @@ class Request {
     return this.command('put', url, formData, params);
   }
 
+  patchWithFD(url: string, data: any): Promise<APIResponse> {
+    if (!data) {
+      throw new Error('Please provide data object');
+    }
+    const params: any = {
+      headers: { 'Content-Type': null }
+    };
+    const formData = this.createFormData(data);
+    return this.command('patch', url, formData, params);
+  }
+
   createFormData(data: any): NodeFormData | FormData {
     const formData: NodeFormData | FormData = Object.keys(data)
       .filter(function (key) { return data[key]; })

package/lib/stats.ts

@@ -1,18 +1,18 @@
 import urljoin from 'url-join';
 import Request from './request';
-import StatsOptions from './interfaces/StatsOptions';
+import { StatsQuery, StatsOptions, Stat } from './interfaces/StatsOptions';
 
 class Stats {
   start: Date;
   end: Date;
   resolution: string;
-  stats: any;
+  stats: Stat[];
 
   constructor(data: StatsOptions) {
     this.start = new Date(data.start);
     this.end = new Date(data.end);
     this.resolution = data.resolution;
-    this.stats = data.stats.map(function (stat: { time: string | Date }) {
+    this.stats = data.stats.map(function (stat: Stat) {
       const res = { ...stat };
       res.time = new Date(stat.time);
       return res;
@@ -27,17 +27,36 @@ export default class StatsClient {
     this.request = request;
   }
 
-  _parseStats(response: { body: StatsOptions }) {
+  private prepareSearchParams(query: StatsQuery): Array<Array<string>> {
+    let searchParams = [];
+    if (typeof query === 'object' && Object.keys(query).length) {
+      searchParams = Object.entries(query).reduce((arrayWithPairs, currentPair) => {
+        const [key, value] = currentPair;
+        if (Array.isArray(value) && value.length) {
+          const repeatedProperty = value.map((item) => [key, item]);
+          return [...arrayWithPairs, ...repeatedProperty];
+        }
+        arrayWithPairs.push([key, value]);
+        return arrayWithPairs;
+      }, []);
+    }
+
+    return searchParams;
+  }
+
+  _parseStats(response: { body: StatsOptions }): Stats {
     return new Stats(response.body);
   }
 
-  getDomain(domain: string, query: any) {
-    return this.request.get(urljoin('/v3', domain, 'stats/total'), query)
+  getDomain(domain: string, query?: StatsQuery): Promise<Stats> {
+    const searchParams = this.prepareSearchParams(query);
+    return this.request.get(urljoin('/v3', domain, 'stats/total'), searchParams)
       .then(this._parseStats);
   }
 
-  getAccount(query: any) {
-    return this.request.get('/v3/stats/total', query)
+  getAccount(query?: StatsQuery): Promise<Stats> {
+    const searchParams = this.prepareSearchParams(query);
+    return this.request.get('/v3/stats/total', searchParams)
       .then(this._parseStats);
   }
 }