mailgun.js 5.0.2 → 5.0.3

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

@@ -2,6 +2,4 @@
 
 /*! https://mths.be/base64 v1.0.0 by @mathias | MIT license */
 
-/*! https://mths.be/punycode v1.3.2 by @mathias */
-
-/*! mailgun.js v5.0.1 */
+/*! mailgun.js v5.0.2 */

package/examples/send-email.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-console */
 const fs = require('fs');
-const mailgun = require('../index');
+const mailgun = require('../lib/index');
 
 const mg = mailgun.client({ username: 'api', key: process.env.MAILGUN_API_KEY || '', timeout: 60000 });
 

package/lib/index.ts

@@ -2,7 +2,8 @@ import Client from './client';
 import { InputFormData } from './interfaces/IFormData';
 import Options from './interfaces/Options';
 
-class Mailgun {
+export default class Mailgun {
+  static get default(): typeof Mailgun { return this; }
   private formData: InputFormData
 
   constructor(FormData: InputFormData) {
@@ -13,5 +14,3 @@ class Mailgun {
     return new Client(options, this.formData);
   }
 }
-
-export = Mailgun;

package/lib/interfaces/DomainTags.ts

@@ -238,7 +238,6 @@ export interface DomainTagDevicesAggregation {
     device: DevicesTypes;
 }
 
-
 export interface IDomainTagsClient {
     list(domain: string): Promise<DomainTagsList>
     get(domain: string, tag: string): Promise<DomainTagsItem>

package/lib/interfaces/DomainTemplates.ts

@@ -206,7 +206,7 @@ export interface ListDomainTemplateVersionsResult {
 
 export interface IDomainTemplatesClient {
     list(domain: string, query?: DomainTemplatesQuery): Promise<ListDomainTemplatesResult>
-    get(domain: string, templateName: string, query: TemplateQuery): Promise<DomainTemplateItem>
+    get(domain: string, templateName: string, query?: TemplateQuery): Promise<DomainTemplateItem>
     create(domain: string, data: DomainTemplateData): Promise<DomainTemplateItem>
     update(
         domain: string,

package/lib/interfaces/Domains.ts

@@ -1,9 +1,9 @@
 /* eslint-disable camelcase */
 export interface DomainsQuery {
-    authority : string;
-    state: 'active' | 'unverified' | 'disabled';
-    limit: number;
-    skip: number;
+    authority? : string;
+    state?: 'active' | 'unverified' | 'disabled';
+    limit?: number;
+    skip?: number;
 }
 
 export interface DomainInfo {

package/lib/interfaces/IFormData.ts

@@ -1,4 +1,4 @@
-import NodeFormData from 'form-data';
+import * as NodeFormData from 'form-data';
 
 export interface IFormDataOptions {
   [key: string]: any;

package/lib/interfaces/Supressions.ts

@@ -1,3 +1,7 @@
+import {
+  Bounce, Complaint, Unsubscribe, WhiteList
+} from '../suppressions';
+
 /* eslint-disable camelcase */
 export interface BounceData {
   address: string;
@@ -24,35 +28,10 @@ export interface WhiteListData {
   createdAt: string | Date;
 }
 
-export interface IBounce {
-  type: string;
-  address: string;
-  code: number;
-  error: string;
-  created_at: Date;
-}
-export interface IComplaint {
-  type: string;
-  address: any;
-  created_at: Date;
-}
-export interface IUnsubscribe {
-  type: string;
-  address: string;
-  tags: any;
-  created_at: Date;
-}
-export interface IWhiteList {
-  type: string;
-  value: string;
-  reason: string;
-  createdAt: Date;
-}
-
 export interface ParsedPage {
   id: string;
-  page: string | undefined;
-  address: string | undefined;
+  page: string | null | undefined;
+  address: string | null | undefined;
   url: string
 }
 export interface ParsedPagesList {
@@ -63,7 +42,7 @@ export interface ParsedPagesList {
 }
 
 export interface SuppressionList {
-  items: IBounce[] | IComplaint[] | IUnsubscribe[] | IWhiteList[];
+  items: (Bounce | Complaint | Unsubscribe | WhiteList)[];
   pages: ParsedPagesList;
 }
 
@@ -84,3 +63,61 @@ export enum SuppressionModels {
 export interface PagesListAccumulator {
   [index: string]: ParsedPage;
 }
+
+export interface SuppressionListQuery {
+  limit?: number;
+}
+
+export interface SuppressionListResponse {
+  body: {
+    items: BounceData[] | ComplaintData[] | UnsubscribeData[] | WhiteListData[];
+    paging: PagesList;
+  }
+  status: number;
+}
+
+export interface SuppressionResponse {
+  body: BounceData | ComplaintData | UnsubscribeData | WhiteListData;
+  status: number;
+}
+
+export interface SuppressionDestroyResponse {
+  body: {
+    message: string;
+    value?: string;
+    address?: string;
+  }
+  status: number;
+}
+
+export interface SuppressionDestroyResult {
+  message: string;
+  value: string;
+  address: string;
+  status: number;
+}
+
+export interface SuppressionCreationData {
+  address: string;
+  code?: number;
+  error?: string;
+  domain?: string;
+  tag?: string;
+  created_at?: string ;
+}
+
+export interface SuppressionCreationResponse {
+  body:{
+    message:string;
+    type?: string;
+    value?: string;
+  }
+  status: number;
+}
+
+export interface SuppressionCreationResult {
+  message:string;
+  type: string;
+  value: string;
+  status: number;
+}

package/lib/request.ts

@@ -1,5 +1,5 @@
-import NodeFormData from 'form-data';
-import base64 from 'base-64';
+import * as NodeFormData from 'form-data';
+import * as base64 from 'base-64';
 import urljoin from 'url-join';
 import ky from 'ky-universal';
 import APIError from './error';

package/lib/suppressions.ts

@@ -1,38 +1,47 @@
 /* eslint-disable camelcase */
-import url from 'url';
 import urljoin from 'url-join';
 
 import Request from './request';
 import {
   BounceData,
   ComplaintData,
-  IBounce,
-  IComplaint,
-  IUnsubscribe,
-  IWhiteList,
   PagesList,
   PagesListAccumulator,
   ParsedPage,
   ParsedPagesList,
+  SuppressionCreationData,
+  SuppressionCreationResponse,
+  SuppressionCreationResult,
+  SuppressionDestroyResponse,
+  SuppressionDestroyResult,
   SuppressionList,
+  SuppressionListQuery,
+  SuppressionListResponse,
   SuppressionModels,
+  SuppressionResponse,
   UnsubscribeData,
-  WhiteListData
+  WhiteListData,
 } from './interfaces/Supressions';
+import APIError from './error';
+import APIErrorOptions from './interfaces/APIErrorOptions';
 
 const createOptions = {
   headers: { 'Content-Type': 'application/json' }
 };
-
-class Bounce implements IBounce {
+export class Suppression {
   type: string;
+  constructor(type: SuppressionModels) {
+    this.type = type;
+  }
+}
+export class Bounce extends Suppression {
   address: string;
   code: number;
   error: string;
   created_at: Date;
 
   constructor(data: BounceData) {
-    this.type = 'bounces';
+    super(SuppressionModels.BOUNCES);
     this.address = data.address;
     this.code = +data.code;
     this.error = data.error;
@@ -40,80 +49,68 @@ class Bounce implements IBounce {
   }
 }
 
-class Complaint implements IComplaint {
-  type: string;
-  address: any;
+export class Complaint extends Suppression {
+  address: string | undefined;
   created_at: Date;
 
   constructor(data: ComplaintData) {
-    this.type = 'complaints';
+    super(SuppressionModels.COMPLAINTS);
     this.address = data.address;
     this.created_at = new Date(data.created_at);
   }
 }
 
-class Unsubscribe implements IUnsubscribe {
-  type: string;
+export class Unsubscribe extends Suppression {
   address: string;
-  tags: any;
+  tags: string[];
   created_at: Date;
 
   constructor(data: UnsubscribeData) {
-    this.type = 'unsubscribes';
+    super(SuppressionModels.UNSUBSCRIBES);
     this.address = data.address;
     this.tags = data.tags;
     this.created_at = new Date(data.created_at);
   }
 }
 
-class WhiteList implements IWhiteList {
-  type: string;
+export class WhiteList extends Suppression {
   value: string;
   reason: string;
   createdAt: Date;
 
   constructor(data: WhiteListData) {
-    this.type = 'whitelists';
+    super(SuppressionModels.WHITELISTS);
     this.value = data.value;
     this.reason = data.reason;
     this.createdAt = new Date(data.createdAt);
   }
 }
 
-type TModel = typeof Bounce | typeof Complaint | typeof Unsubscribe | typeof WhiteList;
-
 export default class SuppressionClient {
-  request: any;
-  models: {
-    bounces: typeof Bounce;
-    complaints: typeof Complaint;
-    unsubscribes: typeof Unsubscribe;
-    whitelists: typeof WhiteList;
-  };
+  request: Request;
+  models: Map<string, any>;
 
   constructor(request: Request) {
     this.request = request;
-    this.models = {
-      bounces: Bounce,
-      complaints: Complaint,
-      unsubscribes: Unsubscribe,
-      whitelists: WhiteList,
-    };
+    this.models = new Map();
+    this.models.set('bounces', Bounce);
+    this.models.set('complaints', Complaint);
+    this.models.set('unsubscribes', Unsubscribe);
+    this.models.set('whitelists', WhiteList);
   }
 
   _parsePage(id: string, pageUrl: string) : ParsedPage {
-    const parsedUrl = url.parse(pageUrl, true);
-    const { query } = parsedUrl;
-
+    const parsedUrl = new URL(pageUrl);
+    const { searchParams } = parsedUrl;
     return {
       id,
-      page: query.page as string,
-      address: query.address as string,
+      page: searchParams.has('page') ? searchParams.get('page') : undefined,
+      address: searchParams.has('address') ? searchParams.get('address') : undefined,
       url: pageUrl
     };
   }
 
-  _parsePageLinks(response: { body: { paging: any } }): ParsedPagesList {
+  _parsePageLinks(response: SuppressionListResponse): ParsedPagesList {
     const pages = Object.entries(response.body.paging as PagesList);
     return pages.reduce(
       (acc: PagesListAccumulator, pair: [pageUrl: string, id: string]) => {
@@ -126,51 +123,99 @@ export default class SuppressionClient {
   }
 
   _parseList(
-    response: { body: { items: any, paging: any } }, Model: TModel
+    response: SuppressionListResponse,
+    Model: {
+      new(data: BounceData | ComplaintData | UnsubscribeData | WhiteListData):
+      Bounce | Complaint | Unsubscribe | WhiteList
+    }
   ): SuppressionList {
     const data = {} as SuppressionList;
-
-    data.items = response.body.items.map((d: any) => new Model(d));
+    data.items = response.body.items.map((item) => new Model(item));
 
     data.pages = this._parsePageLinks(response);
 
     return data;
   }
 
-  _parseItem(
-    response: { body: any },
-    Model: TModel
-  ): IBounce | IComplaint | IUnsubscribe | IWhiteList {
-    return new Model(response.body);
+  _parseItem<T extends Suppression>(
+    data : BounceData | ComplaintData | UnsubscribeData | WhiteListData,
+    Model: {
+      new(data: BounceData | ComplaintData | UnsubscribeData | WhiteListData):
+      T
+    }
+  ): T {
+    return new Model(data);
   }
 
-  private createWhiteList(domain: string, data: any) {
+  private createWhiteList(
+    domain: string,
+    data: SuppressionCreationData | SuppressionCreationData[]
+  ): Promise<SuppressionCreationResult> {
+    if (Array.isArray(data)) {
+      throw new APIError({
+        status: 400,
+        statusText: 'Data property should be an object',
+        body: {
+          message: 'Whitelist\'s creation process does not support multiple creations. Data property should be an object'
+        }
+      } as APIErrorOptions);
+    }
     return this.request
-      .postWithFD(urljoin('v3', domain, 'whitelists'), data, createOptions)
-      .then((response: { body: any }) => response.body);
+      .postWithFD(urljoin('v3', domain, 'whitelists'), data)
+      .then(this.prepareResponse);
+  }
+
+  private checkType(type: string) {
+    if (!this.models.has(type)) {
+      throw new APIError({
+        status: 400,
+        statusText: 'Unknown type value',
+        body: { message: 'Type may be only one of [bounces, complaints, unsubscribes, whitelists]' }
+      } as APIErrorOptions);
+    }
+  }
+
+  private prepareResponse(response: SuppressionCreationResponse): SuppressionCreationResult {
+    return {
+      message: response.body.message,
+      type: response.body.type || '',
+      value: response.body.value || '',
+      status: response.status
+    };
   }
 
-  list(domain: string, type: SuppressionModels, query: any) : Promise<SuppressionList> {
-    const model = (this.models)[type];
+  list(
+    domain: string,
+    type: string,
+    query?: SuppressionListQuery
+  ): Promise<SuppressionList> {
+    this.checkType(type);
 
+    const model = this.models.get(type);
     return this.request
       .get(urljoin('v3', domain, type), query)
-      .then((response: { body: { items: any, paging: any } }) => this._parseList(response, model));
+      .then((response: SuppressionListResponse) => this._parseList(response, model));
   }
 
   get(
     domain: string,
-    type: SuppressionModels,
+    type: string,
     address: string
-  ): Promise<IBounce | IComplaint | IUnsubscribe | IWhiteList> {
-    const model = (this.models)[type];
+  ): Promise<Bounce | Complaint | Unsubscribe | WhiteList> {
+    this.checkType(type);
 
+    const model = this.models.get(type);
     return this.request
       .get(urljoin('v3', domain, type, encodeURIComponent(address)))
-      .then((response: { body: any }) => this._parseItem(response, model));
+      .then((response: SuppressionResponse) => this._parseItem<typeof model>(response.body, model));
   }
 
-  create(domain: string, type: string, data: any) {
+  create(
+    domain: string,
+    type: string,
+    data: SuppressionCreationData | SuppressionCreationData[]
+  ): Promise<SuppressionCreationResult> {
+    this.checkType(type);
     // supports adding multiple suppressions by default
     let postData;
     if (type === 'whitelists') {
@@ -185,13 +230,23 @@ export default class SuppressionClient {
 
     return this.request
       .post(urljoin('v3', domain, type), JSON.stringify(postData), createOptions)
-      .then((response: { body: any }) => response.body);
+      .then(this.prepareResponse);
   }
 
-  destroy(domain: string, type: string, address: string) {
+  destroy(
+    domain: string,
+    type: string,
+    address: string
+  ): Promise<SuppressionDestroyResult> {
+    this.checkType(type);
     return this.request
       .delete(urljoin('v3', domain, type, encodeURIComponent(address)))
-      .then((response: { body: any }) => response.body);
+      .then((response: SuppressionDestroyResponse) => ({
+        message: response.body.message,
+        value: response.body.value || '',
+        address: response.body.address || '',
+        status: response.status
+      }));
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mailgun.js",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "main": "dist/mailgun.node.js",
   "browser": "dist/mailgun.web.js",
   "types": "dist/mailgun.js.d.ts",
@@ -38,8 +38,7 @@
     "bluebird": "^3.7.2",
     "ky": "^0.25.1",
     "ky-universal": "^0.8.2",
-    "url": "^0.11.0",
-    "url-join": "0.0.1",
+    "url-join": "^4.0.1",
     "web-streams-polyfill": "^3.0.1",
     "webpack-merge": "^5.4.0"
   },
@@ -51,7 +50,7 @@
     "@types/base-64": "^1.0.0",
     "@types/chai": "^4.2.14",
     "@types/mocha": "^8.2.0",
-    "@types/url-join": "^4.0.0",
+    "@types/url-join": "^4.0.1",
     "@typescript-eslint/eslint-plugin": "^4.26.0",
     "@typescript-eslint/parser": "^4.26.0",
     "babel-loader": "^8.1.0",

package/test/suppressions.test.ts

@@ -6,6 +6,7 @@ import Request from '../lib/request';
 import SuppressionClient from '../lib/suppressions';
 import RequestOptions from '../lib/interfaces/RequestOptions';
 import { InputFormData } from '../lib/interfaces/IFormData';
+import { WhiteListData } from '../lib/interfaces/Supressions';
 
 chai.should();
 
@@ -123,6 +124,38 @@ describe('SuppressionsClient', function () {
         });
     });
 
+    it('fetches WhiteLists', function () {
+      response.items = [{
+        type: 'whitelists',
+        value: 'brad@example.com',
+        reason: 'first reason',
+        createdAt: '2021-11-30T10:38:56.000Z'
+      }, {
+        type: 'whitelists',
+        value: 'roman@example.com',
+        reason: 'second reason',
+        createdAt: '2021-11-30T10:38:56.000Z'
+      }];
+
+      api.get('/v3/domain.com/whitelists').reply(200, response);
+
+      return client.list('domain.com', 'whitelists')
+        .then(function (complaints: { items: WhiteListData[] }) {
+          let c;
+          c = complaints.items[0];
+          c.type.should.eql('whitelists');
+          c.value.should.eql('brad@example.com');
+          c.reason.should.eql('first reason');
+          c.createdAt.should.eql(new Date('2021-11-30T10:38:56.000Z'));
+
+          c = complaints.items[1];
+          c.type.should.eql('whitelists');
+          c.value.should.eql('roman@example.com');
+          c.reason.should.eql('second reason');
+          c.createdAt.should.eql(new Date('2021-11-30T10:38:56.000Z'));
+        });
+    });
+
     it('parses page links', function () {
       api.get('/v3/domain.com/bounces').reply(200, response);
 
@@ -186,21 +219,72 @@ describe('SuppressionsClient', function () {
         });
     });
   });
-
   describe('create', function () {
-    it('creates suppression', function () {
-      api.post('/v3/domain.com/bounces').reply(200, {
-        message: 'Bounced address has been inserted',
-        address: 'myaddress'
+    describe('create bounce', function () {
+      it('creates suppression', function () {
+        api.post('/v3/domain.com/bounces').reply(200, {
+          message: '1 addresses have been added to the bounces table'
+        });
+
+        return client.create('domain.com', 'bounces', {
+          address: 'myaddress',
+          code: 550
+        }).then(function (data: { message: string }) {
+          data.message.should.eql('1 addresses have been added to the bounces table');
+        });
       });
+    });
 
-      return client.create('domain.com', 'bounces', {
-        address: 'myaddress',
-        code: 550
-      }).then(function (data: { address: string }) {
-        data.address.should.eql('myaddress');
+    describe('create multiple bounces', function () {
+      it('creates bounces', async function () {
+        const message = '2 addresses have been added to the bounces table';
+        api.post('/v3/domain.com/bounces').reply(200, {
+          message
+        });
+        return client.create('domain.com', 'bounces',
+          [{ address: 'myaddress' }, { address: 'myaddress1' }])
+          .then(function (data: { message: string }) {
+            data.message.should.eql(message);
+          });
+      });
+    });
+    describe('create whitelists', function () {
+      it('creates whitelist', async function () {
+        const message = '1 addresses have been added to the whitelists table';
+        api.post('/v3/domain.com/whitelists').reply(200, {
+          message
+        });
+        return client.create('domain.com', 'whitelists',
+          { address: 'myaddress' })
+          .then(function (data: { message: string }) {
+            data.message.should.eql(message);
+          });
       });
     });
+
+    describe('create multiple whitelists', function () {
+      it('throws in case multiple whitelists provided', async function () {
+        try {
+          await client.create('domain.com', 'whitelists',
+            [{ address: 'myaddress' }, { address: 'myaddress1' }]);
+        } catch (error: any) {
+          error.message.should.eql('Data property should be an object');
+          error.details.should.eql("Whitelist's creation process does not support multiple creations. Data property should be an object");
+          error.status.should.eql(400);
+        }
+      });
+    });
+
+    it('throws in case type is unknown', async function () {
+      try {
+        await client.create('domain.com', 'wrong type',
+          { address: 'myaddress' });
+      } catch (error: any) {
+        error.message.should.eql('Unknown type value');
+        error.details.should.eql('Type may be only one of [bounces, complaints, unsubscribes, whitelists]');
+        error.status.should.eql(400);
+      }
+    });
   });
 
   describe('destroy', function () {

package/webpack/webpack.common.config.js

@@ -16,7 +16,6 @@ const commonConfig = {
     path: path.join(SRC_DIR, outputDir),
     filename: 'mailgun.js',
     library: 'mailgun',
-    libraryTarget: 'umd',
     globalObject: 'this',
   },
   module: {