mailgun.js 4.0.1 → 4.1.3

package/lib/suppressions.ts

@@ -3,7 +3,12 @@ import url from 'url';
 import urljoin from 'url-join';
 
 import Request from './request';
-import { BounceData, ComplaintData, UnsubscribeData } from './interfaces/Supressions';
+import {
+  BounceData,
+  ComplaintData,
+  UnsubscribeData,
+  WhiteListData
+} from './interfaces/Supressions';
 
 const createOptions = {
   headers: { 'Content-Type': 'application/json' }
@@ -51,7 +56,21 @@ class Unsubscribe {
   }
 }
 
-type TModel = typeof Bounce | typeof Complaint | typeof Unsubscribe;
+class WhiteList {
+  type: string;
+  value: string;
+  reason: string;
+  createdAt: Date;
+
+  constructor(data: WhiteListData) {
+    this.type = '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;
@@ -59,6 +78,7 @@ export default class SuppressionClient {
     bounces: typeof Bounce;
     complaints: typeof Complaint;
     unsubscribes: typeof Unsubscribe;
+    whitelists: typeof WhiteList;
   };
 
   constructor(request: Request) {
@@ -66,7 +86,8 @@ export default class SuppressionClient {
     this.models = {
       bounces: Bounce,
       complaints: Complaint,
-      unsubscribes: Unsubscribe
+      unsubscribes: Unsubscribe,
+      whitelists: WhiteList,
     };
   }
 
@@ -106,6 +127,12 @@ export default class SuppressionClient {
     return new Model(response.body);
   }
 
+  private createWhiteList(domain: string, data: any) {
+    return this.request
+      .postWithFD(urljoin('v3', domain, 'whitelists'), data, createOptions)
+      .then((response: { body: any }) => response.body);
+  }
+
   list(domain: string, type: string, query: any) {
     const model = (this.models as any)[type];
 
@@ -125,14 +152,18 @@ export default class SuppressionClient {
   create(domain: string, type: string, data: any) {
     // supports adding multiple suppressions by default
     let postData;
+    if (type === 'whitelists') {
+      return this.createWhiteList(domain, data);
+    }
+
     if (!Array.isArray(data)) {
       postData = [data];
     } else {
-      postData = { ...data };
+      postData = [...data];
     }
 
     return this.request
-      .post(urljoin('v3', domain, type), postData, createOptions)
+      .post(urljoin('v3', domain, type), JSON.stringify(postData), createOptions)
       .then((response: { body: any }) => response.body);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mailgun.js",
-  "version": "4.0.1",
+  "version": "4.1.3",
   "main": "dist/mailgun.node.js",
   "browser": "dist/mailgun.web.js",
   "types": "dist/index.d.ts",
@@ -23,7 +23,7 @@
     "build:release": "webpack --config ./webpack/webpack.release.config.js --progress --color",
     "start": "webpack --watch --config ./webpack/webpack.dev.config.js --progress --color",
     "release": "standard-version -a",
-    "test": "multi='dot=- xunit=./results.xml' mocha -t 10000 -R mocha-multi -r ts-node/register test/*.test.ts",
+    "test": "multi='dot=- xunit=./results.xml' nyc mocha -t 10000 -R mocha-multi -r ts-node/register test/*.test.ts",
     "test-watch": "mocha -r ts-node/register -w -R dot test/*.test.ts",
     "docs": "typedoc --tsconfig ./tsconfig.json",
     "lint": "eslint . && eslint . --ext .ts",
@@ -63,6 +63,7 @@
     "mocha": "^9.1.3",
     "mocha-multi": "^1.1.3",
     "nock": "^13.0.4",
+    "nyc": "^15.1.0",
     "path-browserify": "^1.0.1",
     "standard-version": "^9.3.1",
     "terser-webpack-plugin": "^5.2.0",

package/test/domains.test.ts

@@ -14,6 +14,7 @@ import {
   UpdatedDKIMAuthority,
   UpdatedDKIMSelectorResponse, UpdatedWebPrefixResponse
 } from '../lib/interfaces/Domains';
+import DomainTemplatesClient from '../lib/domainsTemplates';
 
 // TODO: fix types
 describe('DomainClient', function () {
@@ -23,7 +24,8 @@ describe('DomainClient', function () {
   beforeEach(function () {
     const reqObject = new Request({ url: 'https://api.mailgun.net' } as RequestOptions, formData as InputFormData);
     const domainCredentialsClient = new DomainCredentialsClient(reqObject);
-    client = new DomainClient(reqObject, domainCredentialsClient);
+    const domainTemplatesClient = new DomainTemplatesClient(reqObject);
+    client = new DomainClient(reqObject, domainCredentialsClient, domainTemplatesClient);
     api = nock('https://api.mailgun.net');
   });
 

package/test/domainsTemplates.test.ts

@@ -0,0 +1,392 @@
+import formData from 'form-data';
+
+import nock from 'nock';
+import Request from '../lib/request';
+import RequestOptions from '../lib/interfaces/RequestOptions';
+import { InputFormData } from '../lib/interfaces/IFormData';
+import { DomainCredentialsList, DomainCredentialsResult } from '../lib/interfaces/DomainCredentials';
+import DomainTemplatesClient from '../lib/domainsTemplates';
+import { DomainTemplateUpdateVersionData, DomainTemplateVersionData } from '../lib/interfaces/DomainTemplates';
+
+// TODO: fix types
+describe('DomainsTemplatesClient', function () {
+  let client: DomainTemplatesClient;
+  let api: nock.Scope;
+
+  beforeEach(function () {
+    const reqObject = new Request({ url: 'https://api.mailgun.net' } as RequestOptions, formData as InputFormData);
+    client = new DomainTemplatesClient(reqObject);
+    api = nock('https://api.mailgun.net');
+  });
+
+  afterEach(function () {
+    api.done();
+  });
+
+  describe('list', function () {
+    it('fetches all templates for domain', async () => {
+      api.get('/v3/testDomain/templates').reply(200, {
+        items: [
+          {
+            name: 'test_template',
+            description: 'test_template description',
+            createdAt: 'Mon, 20 Dec 2021 14:47:51 UTC',
+            createdBy: '',
+            id: 'someId'
+          }
+        ],
+        paging: {
+          first: 'first page url',
+          last: 'last page url',
+          next: 'next page url',
+          previous: 'previous page url',
+        }
+      });
+
+      const templatesList = await client.list('testDomain');
+      templatesList.should.be.an('object').to.have.property('items');
+      templatesList.items.should.be.an('array').to.have.property('length').to.be.equal(1);
+      templatesList.items[0].should.eql({
+        name: 'test_template',
+        description: 'test_template description',
+        createdAt: new Date('Mon, 20 Dec 2021 14:47:51 UTC'),
+        createdBy: '',
+        id: 'someId'
+      });
+    });
+  });
+
+  describe('get', function () {
+    it('fetches all templates for domain', async () => {
+      api.get('/v3/testDomain/templates/testTemplateName').reply(200, {
+        template: {
+          name: 'test_template',
+          description: 'test_template description',
+          createdAt: 'Mon, 20 Dec 2021 14:47:51 UTC',
+          createdBy: '',
+          id: 'someId'
+        }
+      });
+
+      const template = await client.get('testDomain', 'testTemplateName');
+      template.should.be.an('object');
+      template.should.eql({
+        name: 'test_template',
+        description: 'test_template description',
+        createdAt: new Date('Mon, 20 Dec 2021 14:47:51 UTC'),
+        createdBy: '',
+        id: 'someId'
+      });
+    });
+  });
+
+  describe('create', function () {
+    it('creates domain template', async () => {
+      const templateData = {
+        name: 'test_template1',
+        description: 'test_template1 description',
+        template: '%recipient.title%',
+        tag: 'v1',
+        comment: 'dummy comment'
+      };
+
+      api.post('/v3/testDomain/templates').reply(200, {
+        message: 'template has been stored',
+        template: {
+          name: 'test_template1',
+          description: 'test_template description 1',
+          createdAt: 'Wed, 22 Dec 2021 08:59:29 UTC',
+          createdBy: '',
+          id: 'someId',
+          version: {
+            tag: 'v1',
+            template: '%recipient.title%',
+            engine: 'handlebars',
+            mjml: '',
+            createdAt: 'Wed, 22 Dec 2021 08:59:29 UTC',
+            comment: 'dummy comment',
+            active: true,
+            id: 'someId2'
+          }
+        }
+      });
+
+      const template = await client.create('testDomain', templateData);
+      template.should.be.an('object');
+      template.should.eql({
+        name: 'test_template1',
+        description: 'test_template description 1',
+        createdAt: new Date('Wed, 22 Dec 2021 08:59:29 UTC'),
+        createdBy: '',
+        id: 'someId',
+        version: {
+          tag: 'v1',
+          template: '%recipient.title%',
+          engine: 'handlebars',
+          mjml: '',
+          createdAt: new Date('Wed, 22 Dec 2021 08:59:29 UTC'),
+          comment: 'dummy comment',
+          active: true,
+          id: 'someId2'
+        }
+      });
+    });
+  });
+
+  describe('update', function () {
+    it('updates domain template', async () => {
+      api.put('/v3/testDomain/templates/testTemplateName').reply(200, {
+        message: 'template has been updated',
+        template: { name: 'test_template1' }
+      });
+
+      const updatedTemplate = await client.update('testDomain', 'testTemplateName', {
+        description: 'updated test_template description'
+      });
+      updatedTemplate.should.be.an('object');
+      updatedTemplate.should.eql({
+        status: 200,
+        message: 'template has been updated',
+        templateName: 'test_template1'
+      });
+    });
+  });
+
+  describe('destroy', function () {
+    it('deletes domain template', async () => {
+      api.delete('/v3/testDomain/templates/testTemplateName').reply(200, {
+        message: 'template has been deleted',
+        template: { name: 'test_template1' }
+      });
+
+      const deletedTemplate = await client.destroy('testDomain', 'testTemplateName');
+      deletedTemplate.should.eql({
+        status: 200,
+        message: 'template has been deleted',
+        templateName: 'test_template1'
+      });
+    });
+  });
+
+  describe('destroyAll', function () {
+    it('deletes all domain templates', async () => {
+      api.delete('/v3/testDomain/templates').reply(200, { message: 'templates have been deleted' });
+
+      const deletedTemplate = await client.destroyAll('testDomain');
+      deletedTemplate.should.eql({ status: 200, message: 'templates have been deleted' });
+    });
+  });
+
+  describe('createVersion', function () {
+    it('creates new version of domain template', async () => {
+      const templateVersionData = {
+        template: '%recipient.title%',
+        tag: 'v3',
+        comment: 'comment',
+        active: 'yes'
+      } as DomainTemplateVersionData;
+
+      api.post('/v3/testDomain/templates/testTemplateName/versions').reply(200, {
+        message: 'new version of the template has been stored',
+        template: {
+          name: 'test_template1',
+          description: 'test_template description 1',
+          createdAt: 'Wed, 22 Dec 2021 08:59:29 UTC',
+          createdBy: '',
+          id: 'someId',
+          version: {
+            tag: 'v1',
+            template: '%recipient.title%',
+            engine: 'handlebars',
+            mjml: '',
+            createdAt: 'Wed, 22 Dec 2021 08:59:29 UTC',
+            comment: 'comment',
+            active: true,
+            id: 'someId2'
+          }
+        }
+      });
+
+      const templateVersion = await client.createVersion('testDomain', 'testTemplateName', templateVersionData);
+      templateVersion.should.be.an('object');
+      templateVersion.should.eql({
+        status: 200,
+        message: 'new version of the template has been stored',
+        template: {
+          name: 'test_template1',
+          description: 'test_template description 1',
+          createdAt: new Date('Wed, 22 Dec 2021 08:59:29 UTC'),
+          createdBy: '',
+          id: 'someId',
+          version: {
+            tag: 'v1',
+            template: '%recipient.title%',
+            engine: 'handlebars',
+            mjml: '',
+            createdAt: new Date('Wed, 22 Dec 2021 08:59:29 UTC'),
+            comment: 'comment',
+            active: true,
+            id: 'someId2'
+          }
+        }
+      });
+    });
+  });
+
+  describe('getVersion', function () {
+    it('fetches version of domain template', async () => {
+      api.get('/v3/testDomain/templates/testTemplateName/versions/v1').reply(200, {
+        template: {
+          name: 'test_template',
+          description: 'test_template description',
+          createdAt: 'Wed, 22 Dec 2021 09:13:27 UTC',
+          createdBy: '',
+          id: 'someId',
+          version: {
+            tag: 'v1',
+            template: '%recipient.title%',
+            engine: 'handlebars',
+            mjml: '',
+            createdAt: 'Wed, 22 Dec 2021 09:13:27 UTC',
+            comment: 'dummy comment',
+            active: false,
+            id: 'someId2'
+          }
+        }
+      });
+
+      const template = await client.getVersion('testDomain', 'testTemplateName', 'v1');
+      template.should.be.an('object');
+      template.should.eql({
+        name: 'test_template',
+        description: 'test_template description',
+        createdAt: new Date('2021-12-22T09:13:27.000Z'),
+        createdBy: '',
+        id: 'someId',
+        version: {
+          tag: 'v1',
+          template: '%recipient.title%',
+          engine: 'handlebars',
+          mjml: '',
+          createdAt: new Date('2021-12-22T09:13:27.000Z'),
+          comment: 'dummy comment',
+          active: false,
+          id: 'someId2',
+        }
+      });
+    });
+  });
+
+  describe('updateVersion', function () {
+    it('updates version of domain template', async () => {
+      api.put('/v3/testDomain/templates/testTemplateName/versions/v2').reply(200, {
+        message: 'version has been updated',
+        template: { name: 'test_template', version: { tag: 'v2' } }
+      });
+
+      const updatedTemplate = await client.updateVersion('testDomain', 'testTemplateName', 'v2', {
+        template: '%recipient.title%',
+        comment: 'updated comment 2',
+        active: 'yes'
+      } as DomainTemplateUpdateVersionData);
+      updatedTemplate.should.be.an('object');
+      updatedTemplate.should.eql({
+        status: 200,
+        message: 'version has been updated',
+        templateName: 'test_template',
+        templateVersion: { tag: 'v2' }
+      });
+    });
+  });
+
+  describe('destroyVersion', function () {
+    it('deletes version of domain template', async () => {
+      api.delete('/v3/testDomain/templates/testTemplateName/versions/v1').reply(200, {
+        message: 'version has been deleted',
+        template: { name: 'test_template', version: { tag: 'v1' } }
+      });
+
+      const deletedTemplate = await client.destroyVersion('testDomain', 'testTemplateName', 'v1');
+      deletedTemplate.should.eql({
+        status: 200,
+        message: 'version has been deleted',
+        templateName: 'test_template',
+        templateVersion: { tag: 'v1' }
+      });
+    });
+  });
+
+  describe('listVersions', function () {
+    it('gets list of version for domain template', async () => {
+      api.get('/v3/testDomain/templates/testTemplateName/versions').reply(200, {
+        paging: {
+          first: 'first page url',
+          last: 'last page url',
+          next: 'next page url',
+          previous: 'previous page url',
+        },
+        template: {
+          name: 'test_template',
+          description: 'test_template description',
+          createdAt: 'Wed, 22 Dec 2021 09:13:27 UTC',
+          createdBy: '',
+          id: 'someId',
+          versions: [{
+            tag: 'v2',
+            engine: 'handlebars',
+            mjml: '',
+            createdAt: 'Wed, 22 Dec 2021 09:51:07 UTC',
+            comment: 'updated comment 2',
+            active: true,
+            id: 'someId1'
+          },
+          {
+            tag: 'v5',
+            engine: 'handlebars',
+            mjml: '',
+            createdAt: 'Mon, 20 Dec 2021 16:36:55 UTC',
+            comment: 'updated comment',
+            active: false,
+            id: 'someId2'
+          }]
+        }
+      });
+
+      const templatesList = await client.listVersions('testDomain', 'testTemplateName');
+      templatesList.should.be.an('object');
+      templatesList.should.eql({
+        pages: {
+          first: 'first page url',
+          last: 'last page url',
+          next: 'next page url',
+          previous: 'previous page url',
+        },
+        template: {
+          name: 'test_template',
+          description: 'test_template description',
+          createdAt: new Date('Wed, 22 Dec 2021 09:13:27 UTC'),
+          createdBy: '',
+          id: 'someId',
+          versions: [{
+            tag: 'v2',
+            engine: 'handlebars',
+            mjml: '',
+            createdAt: new Date('Wed, 22 Dec 2021 09:51:07 UTC'),
+            comment: 'updated comment 2',
+            active: true,
+            id: 'someId1'
+          },
+          {
+            tag: 'v5',
+            engine: 'handlebars',
+            mjml: '',
+            createdAt: new Date('Mon, 20 Dec 2021 16:36:55 UTC'),
+            comment: 'updated comment',
+            active: false,
+            id: 'someId2'
+          }]
+        }
+      });
+    });
+  });
+});

package/test/stats.test.ts

@@ -4,7 +4,7 @@ import nock from 'nock';
 import Request from '../lib/request';
 import StatsClient from '../lib/stats';
 import RequestOptions from '../lib/interfaces/RequestOptions';
-import StatsOptions from '../lib/interfaces/StatsOptions';
+import { StatsOptions } from '../lib/interfaces/StatsOptions';
 import { InputFormData } from '../lib/interfaces/IFormData';
 
 describe('StatsClient', function () {