mailgun.js 3.7.3 → 4.0.0

package/lib/interfaces/MultipleValidation.ts

@@ -0,0 +1,62 @@
+/* eslint-disable camelcase */
+export interface MultipleValidationJob {
+    created_at: number;
+    download_url: {
+        csv: string;
+        json: string;
+    };
+    id: string;
+    quantity: number;
+    records_processed: number;
+    status: string;
+    summary: {
+        result: {
+            catch_all: number;
+            deliverable: number;
+            do_not_send: number;
+            undeliverable: number;
+            unknown: number;
+        };
+        risk: {
+            high: number;
+            low: number;
+            medium: number;
+            unknown: number;
+        }
+    }
+}
+
+export interface CreatedMultipleValidationJob {
+    id: string;
+    message: string;
+}
+
+export interface PagesList {
+    prev: string;
+    first: string;
+    last: string;
+    next: string;
+}
+
+export interface MultipleValidationJobsListResult {
+    jobs: MultipleValidationJob[];
+    paging: PagesList;
+    total: number;
+}
+
+export interface MultipleValidationJobsListResponse {
+    status: 200;
+    body: MultipleValidationJobsListResult
+}
+
+export interface CanceledMultipleValidationJob {
+     body: string;
+     status: number;
+}
+
+export interface IMultipleValidationClient {
+    list() : Promise<MultipleValidationJobsListResult>
+    get(listId: string) : Promise<MultipleValidationJob>
+    create(listId: string, file: any) : Promise<CreatedMultipleValidationJob>
+    destroy(listId: string) : Promise<CanceledMultipleValidationJob>
+}

package/lib/interfaces/Validate.ts

@@ -0,0 +1,15 @@
+/* eslint-disable camelcase */
+
+export interface ValidationResult {
+    address: string;
+    is_disposable_address: boolean;
+    is_role_address: boolean;
+    reason: string[];
+    result: string;
+    risk: string;
+}
+
+export interface ValidationResponse {
+    status: number;
+    body: ValidationResult;
+}

package/lib/interfaces/Webhooks.ts

@@ -9,7 +9,7 @@ export interface WebhookResponseBody {
 }
 
 export interface WebhookResponse {
-    status: string;
+    status: number;
     body: WebhookResponseBody;
 }
 
@@ -23,3 +23,8 @@ export interface WebhooksQuery {
     limit?: number;
     skip?: number;
 }
+
+export interface ValidationResponse {
+    code: number;
+    message: string;
+}

package/lib/multipleValidation.ts

@@ -0,0 +1,37 @@
+import {
+  CanceledMultipleValidationJob,
+  CreatedMultipleValidationJob,
+  IMultipleValidationClient,
+  MultipleValidationJob,
+  MultipleValidationJobsListResult
+}
+  from './interfaces/MultipleValidation';
+import Request from './request';
+
+export default class MultipleValidationClient implements IMultipleValidationClient {
+  request: Request;
+
+  constructor(request: Request) {
+    this.request = request;
+  }
+
+  list(): Promise<MultipleValidationJobsListResult> {
+    return this.request.get('/v4/address/validate/bulk')
+      .then((response) => response.body as MultipleValidationJobsListResult);
+  }
+
+  get(listId: string): Promise<MultipleValidationJob> {
+    return this.request.get(`/v4/address/validate/bulk/${listId}`)
+      .then((response) => response.body);
+  }
+
+  create(listId: string, file: any): Promise<CreatedMultipleValidationJob> {
+    return this.request.postWithFD(`/v4/address/validate/bulk/${listId}`, file)
+      .then((response) => response.body);
+  }
+
+  destroy(listId: string): Promise<CanceledMultipleValidationJob> {
+    return this.request.delete(`/v4/address/validate/bulk/${listId}`)
+      .then((response) => response);
+  }
+}

package/lib/request.ts

@@ -107,10 +107,12 @@ class Request {
       } as APIErrorOptions);
     }
 
-    return {
+    const res = {
       body: await response?.json(),
       status: response?.status
     };
+
+    return res;
   }
 
   query(method: string, url: string, query: any, options?: any) : Promise<APIResponse> {
@@ -142,6 +144,9 @@ class Request {
   }
 
   postWithFD(url: string, data: any): Promise<APIResponse> {
+    if (!data) {
+      throw new Error('Please provide data object');
+    }
     const params: any = {
       headers: { 'Content-Type': null }
     };
@@ -150,6 +155,9 @@ class Request {
   }
 
   putWithFD(url: string, data: any): Promise<APIResponse> {
+    if (!data) {
+      throw new Error('Please provide data object');
+    }
     const params: any = {
       headers: { 'Content-Type': null }
     };
@@ -176,7 +184,7 @@ class Request {
     const formData: NodeFormData | FormData = Object.keys(data)
       .filter(function (key) { return data[key]; })
       .reduce((formDataAcc: NodeFormData | FormData, key) => {
-        if (key === 'attachment' || key === 'inline') {
+        if (key === 'attachment' || key === 'inline' || key === 'file') {
           const obj = data[key];
 
           if (Array.isArray(obj)) {

package/lib/validate.ts

@@ -1,14 +1,20 @@
+import APIResponse from './interfaces/ApiResponse';
+import { IMultipleValidationClient } from './interfaces/MultipleValidation';
+import { ValidationResult, ValidationResponse } from './interfaces/Validate';
 import Request from './request';
 
 export default class ValidateClient {
+  public multipleValidation;
   request: Request;
 
-  constructor(request: Request) {
+  constructor(request: Request, multipleValidationClient: IMultipleValidationClient) {
     this.request = request;
+    this.multipleValidation = multipleValidationClient;
   }
 
-  get(address: string) {
-    return this.request.get('/v3/address/validate', { address })
-      .then((response) => response.body);
+  get(address: string): Promise<ValidationResult> {
+    return this.request.get('/v4/address/validate', { address })
+      .then((response : APIResponse) => response)
+      .then((res : ValidationResponse) => res.body as ValidationResult);
   }
 }

package/lib/webhooks.ts

@@ -1,5 +1,11 @@
 import urljoin from 'url-join';
-import { WebhookList, WebhookResponse, WebhooksQuery } from './interfaces/Webhooks';
+
+import {
+  ValidationResponse,
+  WebhookList,
+  WebhookResponse,
+  WebhooksQuery
+} from './interfaces/Webhooks';
 import Request from './request';
 
 class Webhook {
@@ -13,7 +19,7 @@ class Webhook {
 }
 
 export default class WebhookClient {
-  request: any;
+  request: Request;
 
   constructor(request: Request) {
     this.request = request;
@@ -36,36 +42,39 @@ export default class WebhookClient {
 
   _parseWebhookTest(response: { body: { code: number, message: string } })
   : {code: number, message:string} {
-    return { code: response.body.code, message: response.body.message };
+    return { code: response.body.code, message: response.body.message } as ValidationResponse;
   }
 
   list(domain: string, query: WebhooksQuery): Promise<WebhookList> {
-    return this.request.get(urljoin('/v2/domains', domain, 'webhooks'), query)
+    return this.request.get(urljoin('/v3/domains', domain, 'webhooks'), query)
       .then(this._parseWebhookList);
   }
 
   get(domain: string, id: string): Promise<Webhook> {
-    return this.request.get(urljoin('/v2/domains', domain, 'webhooks', id))
+    return this.request.get(urljoin('/v3/domains', domain, 'webhooks', id))
       .then(this._parseWebhookWithID(id));
   }
 
-  create(domain: string, id: string, url: string, test = false): Promise<Webhook> {
+  create(domain: string,
+    id: string,
+    url: string,
+    test = false): Promise<Webhook | ValidationResponse> {
     if (test) {
-      return this.request.putWithFD(urljoin('/v2/domains', domain, 'webhooks', id, 'test'), { url })
+      return this.request.putWithFD(urljoin('/v3/domains', domain, 'webhooks', id, 'test'), { url })
         .then(this._parseWebhookTest);
     }
 
-    return this.request.postWithFD(urljoin('/v2/domains', domain, 'webhooks'), { id, url })
+    return this.request.postWithFD(urljoin('/v3/domains', domain, 'webhooks'), { id, url })
       .then(this._parseWebhookWithID(id));
   }
 
   update(domain: string, id: string, url: string): Promise<Webhook> {
-    return this.request.putWithFD(urljoin('/v2/domains', domain, 'webhooks', id), { url })
+    return this.request.putWithFD(urljoin('/v3/domains', domain, 'webhooks', id), { url })
       .then(this._parseWebhookWithID(id));
   }
 
   destroy(domain: string, id: string) : Promise<Webhook> {
-    return this.request.delete(urljoin('/v2/domains', domain, 'webhooks', id))
+    return this.request.delete(urljoin('/v3/domains', domain, 'webhooks', id))
       .then(this._parseWebhookWithID(id));
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mailgun.js",
-  "version": "3.7.3",
+  "version": "4.0.0",
   "main": "dist/mailgun.node.js",
   "browser": "dist/mailgun.web.js",
   "types": "dist/index.d.ts",
@@ -105,8 +105,7 @@
     "commitUrlFormat": "https://github.com/mailgun/mailgun.js/commits/{{hash}}",
     "compareUrlFormat": "https://github.com/mailgun/mailgun.js/compare/{{previousTag}}...{{currentTag}}",
     "scripts": {
-      "prerelease": "npm test && webpack --config ./webpack/webpack.release.config.js --progress --color && git add -A dist",
-      "posttag": "git push && git push --tags && rm -rf build"
+      "prerelease": "npm test && webpack --config ./webpack/webpack.release.config.js --progress --color && git add -A dist"
     }
   }
 }

package/test/client.test.ts

@@ -11,8 +11,12 @@ import SuppressionsClient from '../lib/suppressions';
 import MessagesClient from '../lib/messages';
 import RoutesClient from '../lib/routes';
 import ValidateClient from '../lib/validate';
-import ParseClient from '../lib/parse';
+
 import { InputFormData } from '../lib/interfaces/IFormData';
+import StatsClient from '../lib/stats';
+import ListsClient from '../lib/lists';
+import IpPoolsClient from '../lib/ip-pools';
+import IpsClient from '../lib/ips';
 
 describe('Client', function () {
   let client: any;
@@ -62,6 +66,10 @@ describe('Client', function () {
     client.suppressions.should.be.instanceOf(SuppressionsClient);
   });
 
+  it('creates stats client', function () {
+    client.stats.should.be.instanceOf(StatsClient);
+  });
+
   it('creates messages client', function () {
     client.messages.should.be.instanceOf(MessagesClient);
   });
@@ -70,11 +78,19 @@ describe('Client', function () {
     client.routes.should.be.instanceOf(RoutesClient);
   });
 
-  it('creates address validate client', function () {
-    client.validate.should.be.instanceOf(ValidateClient);
+  it('creates ips client', function () {
+    client.ips.should.be.instanceOf(IpsClient);
   });
 
-  it('creates address parse client', function () {
-    client.parse.should.be.instanceOf(ParseClient);
+  it('creates ip_pools client', function () {
+    client.ip_pools.should.be.instanceOf(IpPoolsClient);
+  });
+
+  it('creates lists client', function () {
+    client.lists.should.be.instanceOf(ListsClient);
+  });
+
+  it('creates address validate client', function () {
+    client.validate.should.be.instanceOf(ValidateClient);
   });
 });

package/test/data/emailsValidation1.csv

@@ -0,0 +1,3 @@
+email
+1testEmailAdressForCheck@test.com
+2testEmailAdressForCheck@test.com

package/test/domains.test.ts

@@ -3,17 +3,27 @@ import formData from 'form-data';
 import nock from 'nock';
 import { expect } from 'chai';
 import Request from '../lib/request';
-import DomainClient from '../lib/domains';
+import DomainClient, { Domain } from '../lib/domains';
 import RequestOptions from '../lib/interfaces/RequestOptions';
 import { InputFormData } from '../lib/interfaces/IFormData';
+import DomainCredentialsClient from '../lib/domainsCredentials';
+import {
+  ConnectionSettings,
+  MessageResponse,
+  UpdatedConnectionSettings,
+  UpdatedDKIMAuthority,
+  UpdatedDKIMSelectorResponse, UpdatedWebPrefixResponse
+} from '../lib/interfaces/Domains';
 
 // TODO: fix types
 describe('DomainClient', function () {
-  let client: any;
-  let api: any;
+  let client: DomainClient;
+  let api: nock.Scope;
 
   beforeEach(function () {
-    client = new DomainClient(new Request({ url: 'https://api.mailgun.net' } as RequestOptions, formData as InputFormData));
+    const reqObject = new Request({ url: 'https://api.mailgun.net' } as RequestOptions, formData as InputFormData);
+    const domainCredentialsClient = new DomainCredentialsClient(reqObject);
+    client = new DomainClient(reqObject, domainCredentialsClient);
     api = nock('https://api.mailgun.net');
   });
 
@@ -36,11 +46,11 @@ describe('DomainClient', function () {
         require_tls: true
       }];
 
-      api.get('/v2/domains').reply(200, {
+      api.get('/v3/domains').reply(200, {
         items: domains
       });
 
-      return client.list().then(function (dm: any[]) {
+      return client.list().then(function (dm: Domain[]) {
         dm[0].should.eql({
           created_at: 'Sun, 19 Oct 2014 18:49:36 GMT',
           name: 'testing.example.com',
@@ -74,13 +84,13 @@ describe('DomainClient', function () {
         require_tls: true
       };
 
-      api.get('/v2/domains/testing.example.com').reply(200, {
+      api.get('/v3/domains/testing.example.com').reply(200, {
         domain: domainData,
         receiving_dns_records: [],
         sending_dns_records: []
       });
 
-      return client.get('testing.example.com').then(function (domain: any) {
+      return client.get('testing.example.com').then(function (domain: Domain) {
         domain.should.eql({
           created_at: 'Sun, 19 Oct 2014 18:49:36 GMT',
           name: 'testing.example.com',
@@ -114,13 +124,17 @@ describe('DomainClient', function () {
         require_tls: true
       };
 
-      api.post('/v2/domains').reply(200, {
+      api.post('/v3/domains').reply(200, {
         domain: domainData,
         receiving_dns_records: [],
         sending_dns_records: []
       });
 
-      return client.create({ name: 'another.example.com' }).then(function (domain: any) {
+      return client.create({
+        name: 'another.example.com',
+        smtp_password: 'smtp_password',
+        web_scheme: 'https'
+      }).then(function (domain: Domain) {
         domain.should.eql({
           created_at: 'Sun, 19 Oct 2014 18:49:36 GMT',
           name: 'another.example.com',
@@ -141,11 +155,11 @@ describe('DomainClient', function () {
 
   describe('destroy', function () {
     it('deletes a domain', function () {
-      api.delete('/v2/domains/test.example.com').reply(200, {
+      api.delete('/v3/domains/test.example.com').reply(200, {
         message: 'domain deleted'
       });
 
-      return client.destroy('test.example.com').then(function (data: any) {
+      return client.destroy('test.example.com').then(function (data: MessageResponse) {
         data.should.eql({
           message: 'domain deleted'
         });
@@ -153,9 +167,46 @@ describe('DomainClient', function () {
     });
   });
 
+  describe('getConnection', function () {
+    it('returns connection settings for the defined domain', function () {
+      api.get('/v3/domains/test.example.com/connection').reply(200, {
+        connection: { require_tls: false, skip_verification: false }
+      });
+
+      return client.getConnection('test.example.com').then(function (data: ConnectionSettings) {
+        data.should.eql({ require_tls: false, skip_verification: false });
+      });
+    });
+  });
+
+  describe('updateConnection', function () {
+    it('Updates the connection settings for the defined domain.', function () {
+      api.put('/v3/domains/test.example.com/connection').reply(200, {
+        connection: {
+          message: 'Domain connection settings have been updated, may take 10 minutes to fully propagate',
+          require_tls: false,
+          skip_verification: false
+        }
+      });
+
+      return client.updateConnection('test.example.com', {
+        require_tls: true,
+        skip_verification: true
+      }).then(function (data: UpdatedConnectionSettings) {
+        data.should.eql({
+          connection: {
+            message: 'Domain connection settings have been updated, may take 10 minutes to fully propagate',
+            require_tls: false,
+            skip_verification: false
+          }
+        });
+      });
+    });
+  });
+
   describe('getTracking', function () {
     it('fetches all tracking settings', function () {
-      api.get('/v2/domains/domain.com/tracking').reply(200, {
+      api.get('/v3/domains/domain.com/tracking').reply(200, {
         tracking: {
           open: { active: true },
           click: { active: true },
@@ -172,7 +223,7 @@ describe('DomainClient', function () {
   describe('updateTracking', function () {
     it('updates tracking settings', async function () {
       const open = { active: true };
-      api.put('/v2/domains/domain.com/tracking/open').reply(200, {
+      api.put('/v3/domains/domain.com/tracking/open').reply(200, {
         message: 'Tracking settings have been updated',
         open
       });
@@ -191,11 +242,63 @@ describe('DomainClient', function () {
   describe('getIps', () => {
     it('should return list of dedicated ips', () => {
       const items = ['192.161.0.1', '192.168.0.2'];
-      api.get('/v2/domains/domain.com/ips').reply(200, { items });
+      api.get('/v3/domains/domain.com/ips').reply(200, { items });
 
       return client.getIps('domain.com').then((response: string[]) => {
         response.should.eql(items);
       });
     });
   });
+
+  describe('updateDKIMAuthority', () => {
+    it('changes the DKIM authority for a domain.', () => {
+      const expectedRes = {
+        changed: true,
+        message: 'Domain DKIM authority has been changed',
+        sending_dns_records: [
+          {
+            cached: ['a'],
+            name: 'test.example.com',
+            record_type: 'record_type',
+            valid: 'valid',
+            value: 'value'
+          }
+        ]
+      };
+
+      api.put('/v3/domains/test.example.com/dkim_authority?self=true').reply(200, expectedRes);
+
+      return client.updateDKIMAuthority('test.example.com', { self: 'true' }).then((response: UpdatedDKIMAuthority) => {
+        response.should.eql(expectedRes);
+      });
+    });
+  });
+
+  describe('updateDKIMSelector', () => {
+    it('updates the DKIM selector for a domains', () => {
+      api.put('/v3/domains/test.example.com/dkim_selector?dkim_selector=dkim_selector_value').reply(200, { message: 'Domain DKIM selector updated' });
+
+      return client.updateDKIMSelector('test.example.com', { dkimSelector: 'dkim_selector_value' }).then((response: UpdatedDKIMSelectorResponse) => {
+        response.should.eql(
+          {
+            body: { message: 'Domain DKIM selector updated' }, status: 200
+          }
+        );
+      });
+    });
+  });
+
+  describe('updateWebPrefix', () => {
+    it('Update the CNAME used for tracking opens and clicks', () => {
+      api.put('/v3/domains/test.example.com/web_prefix?web_prefix=webprefixvalue').reply(200, { message: 'Domain web prefix updated' });
+
+      return client.updateWebPrefix('test.example.com', { webPrefix: 'webprefixvalue' }).then((response: UpdatedWebPrefixResponse) => {
+        response.should.eql(
+          {
+            body: { message: 'Domain web prefix updated' }, status: 200
+          }
+        );
+      });
+    });
+  });
 });

package/test/domainsCredentials.test.ts

@@ -0,0 +1,97 @@
+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 DomainCredentialsClient from '../lib/domainsCredentials';
+import { DomainCredentialsList, DomainCredentialsResult } from '../lib/interfaces/DomainCredentials';
+
+// TODO: fix types
+describe('DomainsCredentialsClient', function () {
+  let client: DomainCredentialsClient;
+  let api: nock.Scope;
+
+  beforeEach(function () {
+    const reqObject = new Request({ url: 'https://api.mailgun.net' } as RequestOptions, formData as InputFormData);
+    client = new DomainCredentialsClient(reqObject);
+    api = nock('https://api.mailgun.net');
+  });
+
+  afterEach(function () {
+    api.done();
+  });
+
+  describe('list', function () {
+    it('fetches all domain credentials', function () {
+      api.get('/v3/domains/testDomain/credentials').reply(200, {
+        items: [{
+          created_at: 'Mon, 11 Oct 2021 17:30:06 -0000',
+          login: 'testLogin@testing.example.com',
+          mailbox: 'test@testing.example.com',
+          size_bytes: null
+        }],
+        total_count: 1
+      });
+
+      return client.list('testDomain').then(function (credentialsList: DomainCredentialsList) {
+        credentialsList.should.be.an('object').to.have.property('items');
+        credentialsList.items.should.be.an('array').to.have.property('length').to.be.equal(1);
+        credentialsList.items[0].should.eql({
+          created_at: 'Mon, 11 Oct 2021 17:30:06 -0000',
+          login: 'testLogin@testing.example.com',
+          mailbox: 'test@testing.example.com',
+          size_bytes: null
+        });
+      });
+    });
+  });
+
+  describe('create', function () {
+    it('creates domain credentials', function () {
+      const domainCredentialsData = {
+        login: 'testLogin',
+        password: 'testPassword'
+      };
+
+      api.post('/v3/domains/testDomain/credentials').reply(200, {
+        message: 'Created 1 credentials pair(s)'
+      });
+
+      return client.create('testDomain', domainCredentialsData).then(function (res: DomainCredentialsResult) {
+        res.should.eql({ message: 'Created 1 credentials pair(s)', status: 200 });
+      });
+    });
+  });
+
+  describe('update', function () {
+    it('updates domain credentials', function () {
+      api.put('/v3/domains/testDomain/credentials/testLogin').reply(200, {
+        message: 'Password changed'
+      });
+
+      return client.update('testDomain', 'testLogin', {
+        password: 'testPassword1'
+      }).then(function (res: DomainCredentialsResult) {
+        res.should.eql({ message: 'Password changed', status: 200 });
+      });
+    });
+  });
+
+  describe('destroy', function () {
+    it('deletes a domain credentials', function () {
+      api.delete('/v3/domains/testDomain/credentials/testLogin').reply(200, {
+        message: 'domain deleted',
+        spec: 'testDomain'
+      });
+
+      return client.destroy('testDomain', 'testLogin').then(function (data: DomainCredentialsResult) {
+        data.should.eql({
+          message: 'domain deleted',
+          spec: 'testDomain',
+          status: 200
+        });
+      });
+    });
+  });
+});