mailgun.js 3.7.1 → 4.0.1

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/interfaces/lists.ts

@@ -9,7 +9,7 @@ export interface CreateUpdateList {
     address: string;
     name?: string;
     description?: string;
-    access_level?: 'read-only' | 'members'| 'everyone';
+    access_level?: 'readonly' | 'members'| 'everyone';
     reply_preference?: 'list' | 'sender';
 }
 

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

@@ -50,7 +50,7 @@ class Request {
   private url: string;
   private timeout: number;
   private headers: any;
-  private formData: InputFormData;
+  private FormDataConstructor: InputFormData;
 
   constructor(options: RequestOptions, formData: InputFormData) {
     this.username = options.username;
@@ -58,7 +58,7 @@ class Request {
     this.url = options.url as string;
     this.timeout = options.timeout;
     this.headers = options.headers || {};
-    this.formData = formData;
+    this.FormDataConstructor = formData;
   }
 
   async request(method: string, url: string, inputOptions?: any): Promise<APIResponse> {
@@ -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 }
     };
@@ -158,49 +166,82 @@ class Request {
   }
 
   createFormData(data: any): NodeFormData | FormData {
+    const formData: NodeFormData | FormData = Object.keys(data)
+      .filter(function (key) { return data[key]; })
+      .reduce((formDataAcc: NodeFormData | FormData, key) => {
+        const fileKeys = ['attachment', 'inline', 'file'];
+        if (fileKeys.includes(key)) {
+          this.addFilesToFD(key, data[key], formDataAcc);
+          return formDataAcc;
+        }
+
+        if (key === 'message') { // mime message
+          this.addMimeDataToFD(key, data[key], formDataAcc);
+          return formDataAcc;
+        }
+
+        this.addCommonPropertyToFD(key, data[key], formDataAcc);
+        return formDataAcc;
+      }, new this.FormDataConstructor());
+    return formData;
+  }
+
+  private addMimeDataToFD(
+    key: string,
+    data: Buffer | Blob,
+    formDataInstance: NodeFormData | FormData
+  ): void {
+    if (isNodeFormData(formDataInstance)) {
+      if (Buffer.isBuffer(data)) {
+        formDataInstance.append(key, data, { filename: 'MimeMessage' });
+      }
+    } else {
+      formDataInstance.append(key, data as Blob, 'MimeMessage');
+    }
+  }
+
+  private addFilesToFD(
+    propertyName: string,
+    value: any,
+    formDataInstance: NodeFormData | FormData
+  ): void {
     const appendFileToFD = (
       key: string,
       obj: any,
-      formDataInstance: NodeFormData | FormData
+      formData: NodeFormData | FormData
     ): void => {
       const isStreamData = isStream(obj);
       const objData = isStreamData ? obj : obj.data;
+      // getAttachmentOptions should be called with obj parameter to prevent loosing filename
       const options = getAttachmentOptions(obj);
-      if (isNodeFormData(formDataInstance)) {
-        formDataInstance.append(key, objData, options);
+      if (isNodeFormData(formData)) {
+        formData.append(key, objData, options);
         return;
       }
-      formDataInstance.append(key, objData, options.filename);
+      formData.append(key, objData, options.filename);
     };
 
-    const formData: NodeFormData | FormData = Object.keys(data)
-      .filter(function (key) { return data[key]; })
-      .reduce((formDataAcc: NodeFormData | FormData, key) => {
-        if (key === 'attachment' || key === 'inline') {
-          const obj = data[key];
-
-          if (Array.isArray(obj)) {
-            obj.forEach(function (item) {
-              appendFileToFD(key, item, formDataAcc);
-            });
-          } else {
-            appendFileToFD(key, obj, formDataAcc);
-          }
-
-          return formDataAcc;
-        }
+    if (Array.isArray(value)) {
+      value.forEach(function (item) {
+        appendFileToFD(propertyName, item, formDataInstance);
+      });
+    } else {
+      appendFileToFD(propertyName, value, formDataInstance);
+    }
+  }
 
-        if (Array.isArray(data[key])) {
-          data[key].forEach(function (item: any) {
-            formDataAcc.append(key, item);
-          });
-        } else if (data[key] != null) {
-          formDataAcc.append(key, data[key]);
-        }
-        return formDataAcc;
-      // eslint-disable-next-line new-cap
-      }, new this.formData());
-    return formData;
+  private addCommonPropertyToFD(
+    key: string,
+    value: any,
+    formDataAcc: NodeFormData | FormData
+  ): void {
+    if (Array.isArray(value)) {
+      value.forEach(function (item: any) {
+        formDataAcc.append(key, item);
+      });
+    } else if (value != null) {
+      formDataAcc.append(key, value);
+    }
   }
 
   put(url: string, data: any, options?: any): Promise<APIResponse> {

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.1",
+  "version": "4.0.1",
   "main": "dist/mailgun.node.js",
   "browser": "dist/mailgun.web.js",
   "types": "dist/index.d.ts",
@@ -12,12 +12,12 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git://github.com/mailgun/mailgun-js.git"
+    "url": "git://github.com/mailgun/mailgun.js.git"
   },
   "bugs": {
-    "url": "https://github.com/mailgun/mailgun-js/issues"
+    "url": "https://github.com/mailgun/mailgun.js/issues"
   },
-  "homepage": "https://github.com/mailgun/mailgun-js#readme",
+  "homepage": "https://github.com/mailgun/mailgun.js#readme",
   "scripts": {
     "build": "webpack --config ./webpack/webpack.dev.config.js --progress --color",
     "build:release": "webpack --config ./webpack/webpack.release.config.js --progress --color",
@@ -102,8 +102,8 @@
         "section": "Other changes"
       }
     ],
-    "commitUrlFormat": "https://github.com/mailgun/mailgun-js/commits/{{hash}}",
-    "compareUrlFormat": "https://github.com/mailgun/mailgun-js/compare/{{previousTag}}...{{currentTag}}",
+    "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"

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