mailgun.js 3.7.1 → 4.0.1

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

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

package/lib/client.ts

@@ -11,12 +11,13 @@ import WebhookClient from './webhooks';
 import MessagesClient from './messages';
 import RoutesClient from './routes';
 import ValidateClient from './validate';
-import ParseClient from './parse';
 import IpsClient from './ips';
 import IpPoolsClient from './ip-pools';
 import ListsClient from './lists';
 import MailListsMembers from './mailListMembers';
 import { InputFormData } from './interfaces/IFormData';
+import DomainCredentialsClient from './domainsCredentials';
+import MultipleValidationClient from './multipleValidation';
 
 export default class Client {
   private request;
@@ -28,9 +29,7 @@ export default class Client {
   public suppressions;
   public messages;
   public routes;
-  public public_request;
   public validate;
-  public parse;
   public ips;
   public ip_pools;
   public lists;
@@ -53,8 +52,10 @@ export default class Client {
     /** @internal */
     this.request = new Request(config, formData);
     const mailListsMembers = new MailListsMembers(this.request);
+    const domainCredentialsClient = new DomainCredentialsClient(this.request);
+    const multipleValidationClient = new MultipleValidationClient(this.request);
 
-    this.domains = new DomainClient(this.request);
+    this.domains = new DomainClient(this.request, domainCredentialsClient);
     this.webhooks = new WebhookClient(this.request);
     this.events = new EventClient(this.request);
     this.stats = new StatsClient(this.request);
@@ -64,13 +65,6 @@ export default class Client {
     this.ips = new IpsClient(this.request);
     this.ip_pools = new IpPoolsClient(this.request);
     this.lists = new ListsClient(this.request, mailListsMembers);
-
-    if (config.public_key) {
-      config.key = config.public_key;
-
-      this.public_request = new Request(config, formData);
-      this.validate = new ValidateClient(this.public_request);
-      this.parse = new ParseClient(this.public_request);
-    }
+    this.validate = new ValidateClient(this.request, multipleValidationClient);
   }
 }

package/lib/domains.ts

@@ -2,13 +2,25 @@
 import urljoin from 'url-join';
 import {
   DomainResponseData,
-  DestroyedDomain,
   DestroyedDomainResponse,
   DomainsQuery,
   DomainInfo,
   DomainListResponseData,
   DomainShortData,
-  DNSRecord
+  DNSRecord,
+  ConnectionSettingsResponse,
+  ConnectionSettings,
+  UpdatedConnectionSettings,
+  UpdatedConnectionSettingsRes,
+  DKIMAuthorityInfo,
+  UpdatedDKIMAuthority,
+  UpdatedDKIMAuthorityResponse,
+  DKIMSelectorInfo,
+  UpdatedDKIMSelectorResponse,
+  WebPrefixInfo,
+  UpdatedWebPrefixResponse,
+  ReplacementForPool,
+  MessageResponse,
 } from './interfaces/Domains';
 
 import APIResponse from './interfaces/ApiResponse';
@@ -25,8 +37,9 @@ import {
   UpdateDomainTrackingResponse,
   UpdatedOpenTracking
 } from './interfaces/DomainTracking';
+import DomainCredentialsClient from './domainsCredentials';
 
-class Domain {
+export class Domain {
   name: string;
   require_tls: boolean;
   skip_verification: boolean;
@@ -59,22 +72,24 @@ class Domain {
 
 export default class DomainClient {
   request: Request;
+  public domainCredentials: DomainCredentialsClient;
 
-  constructor(request: Request) {
+  constructor(request: Request, domainCredentialsClient: DomainCredentialsClient) {
     this.request = request;
+    this.domainCredentials = domainCredentialsClient;
   }
 
-  _parseMessage(response: DestroyedDomainResponse) : DestroyedDomain {
+  private _parseMessage(response: DestroyedDomainResponse) : MessageResponse {
     return response.body;
   }
 
-  _parseDomainList(response: DomainListResponseData): Domain[] {
+  private _parseDomainList(response: DomainListResponseData): Domain[] {
     return response.body.items.map(function (item) {
       return new Domain(item);
     });
   }
 
-  _parseDomain(response: DomainResponseData): Domain {
+  private _parseDomain(response: DomainResponseData): Domain {
     return new Domain(
       response.body.domain,
       response.body.receiving_dns_records,
@@ -82,38 +97,55 @@ export default class DomainClient {
     );
   }
 
-  _parseTrackingSettings(response: DomainTrackingResponse) : DomainTrackingData {
+  private _parseTrackingSettings(response: DomainTrackingResponse) : DomainTrackingData {
     return response.body.tracking;
   }
 
-  _parseTrackingUpdate(response: UpdateDomainTrackingResponse) :UpdatedOpenTracking {
+  private _parseTrackingUpdate(response: UpdateDomainTrackingResponse) :UpdatedOpenTracking {
     return response.body;
   }
 
-  list(query: DomainsQuery): Promise<Domain[]> {
-    return this.request.get('/v2/domains', query)
+  list(query?: DomainsQuery): Promise<Domain[]> {
+    return this.request.get('/v3/domains', query)
       .then((res : APIResponse) => this._parseDomainList(res as DomainListResponseData));
   }
 
   get(domain: string) : Promise<Domain> {
-    return this.request.get(`/v2/domains/${domain}`)
+    return this.request.get(`/v3/domains/${domain}`)
       .then((res : APIResponse) => this._parseDomain(res as DomainResponseData));
   }
 
   create(data: DomainInfo) : Promise<Domain> {
-    return this.request.postWithFD('/v2/domains', data)
+    const postObj = { ...data };
+    if ('force_dkim_authority' in postObj && typeof postObj.force_dkim_authority === 'boolean') {
+      postObj.force_dkim_authority = postObj.toString() === 'true' ? 'true' : 'false';
+    }
+
+    return this.request.postWithFD('/v3/domains', postObj)
       .then((res : APIResponse) => this._parseDomain(res as DomainResponseData));
   }
 
-  destroy(domain: string): Promise<DestroyedDomain> {
-    return this.request.delete(`/v2/domains/${domain}`)
+  destroy(domain: string): Promise<MessageResponse> {
+    return this.request.delete(`/v3/domains/${domain}`)
       .then((res : APIResponse) => this._parseMessage(res as DestroyedDomainResponse));
   }
 
+  getConnection(domain: string): Promise<ConnectionSettings> {
+    return this.request.get(`/v3/domains/${domain}/connection`)
+      .then((res : APIResponse) => res as ConnectionSettingsResponse)
+      .then((res:ConnectionSettingsResponse) => res.body.connection as ConnectionSettings);
+  }
+
+  updateConnection(domain: string, data: ConnectionSettings): Promise<UpdatedConnectionSettings> {
+    return this.request.put(`/v3/domains/${domain}/connection`, data)
+      .then((res : APIResponse) => res as UpdatedConnectionSettingsRes)
+      .then((res:UpdatedConnectionSettingsRes) => res.body as UpdatedConnectionSettings);
+  }
+
   // Tracking
 
   getTracking(domain: string) : Promise<DomainTrackingData> {
-    return this.request.get(urljoin('/v2/domains', domain, 'tracking'))
+    return this.request.get(urljoin('/v3/domains', domain, 'tracking'))
       .then(this._parseTrackingSettings);
   }
 
@@ -122,33 +154,57 @@ export default class DomainClient {
     type: string,
     data: OpenTrackingInfo | ClickTrackingInfo | UnsubscribeTrackingInfo
   ): Promise<UpdatedOpenTracking> {
-    if (!('html_footer' in data) && !('text_footer' in data) && typeof data?.active === 'boolean') {
-      throw new APIError({ status: 400, statusText: '', body: { message: 'Value "active" must contain string value.' } } as APIErrorOptions);
+    if (typeof data?.active === 'boolean') {
+      throw new APIError({ status: 400, statusText: '', body: { message: 'Property "active" must contain string value.' } } as APIErrorOptions);
     }
-    return this.request.putWithFD(urljoin('/v2/domains', domain, 'tracking', type), data)
-      .then(this._parseTrackingUpdate);
+    return this.request.putWithFD(urljoin('/v3/domains', domain, 'tracking', type), data)
+      .then((res : APIResponse) => this._parseTrackingUpdate(res as UpdateDomainTrackingResponse));
   }
 
   // IPs
 
   getIps(domain: string): Promise<string[]> {
-    return this.request.get(urljoin('/v2/domains', domain, 'ips'))
+    return this.request.get(urljoin('/v3/domains', domain, 'ips'))
       .then((response: APIResponse) => response?.body?.items);
   }
 
   assignIp(domain: string, ip: string): Promise<APIResponse> {
-    return this.request.postWithFD(urljoin('/v2/domains', domain, 'ips'), { ip });
+    return this.request.postWithFD(urljoin('/v3/domains', domain, 'ips'), { ip });
   }
 
   deleteIp(domain: string, ip: string): Promise<APIResponse> {
-    return this.request.delete(urljoin('/v2/domains', domain, 'ips', ip));
+    return this.request.delete(urljoin('/v3/domains', domain, 'ips', ip));
   }
 
   linkIpPool(domain: string, pool_id: string): Promise<APIResponse> {
-    return this.request.postWithFD(urljoin('/v2/domains', domain, 'ips'), { pool_id });
+    return this.request.postWithFD(urljoin('/v3/domains', domain, 'ips'), { pool_id });
+  }
+
+  unlinkIpPoll(domain: string, replacement: ReplacementForPool): Promise<APIResponse> {
+    let searchParams = '';
+    if (replacement.pool_id && replacement.ip) {
+      throw new APIError({ status: 400, statusText: '', body: { message: 'Please specify either pool_id or ip (not both)' } } as APIErrorOptions);
+    } else if (replacement.pool_id) {
+      searchParams = `?pool_id=${replacement.pool_id}`;
+    } else if (replacement.ip) {
+      searchParams = `?ip=${replacement.ip}`;
+    }
+    return this.request.delete(urljoin('/v3/domains', domain, 'ips', 'ip_pool', searchParams));
+  }
+
+  updateDKIMAuthority(domain: string, data: DKIMAuthorityInfo): Promise<UpdatedDKIMAuthority> {
+    return this.request.put(`/v3/domains/${domain}/dkim_authority`, {}, { query: `self=${data.self}` })
+      .then((res : APIResponse) => res)
+      .then((res : UpdatedDKIMAuthorityResponse) => res.body as UpdatedDKIMAuthority);
+  }
+
+  updateDKIMSelector(domain: string, data: DKIMSelectorInfo): Promise<UpdatedDKIMSelectorResponse> {
+    return this.request.put(`/v3/domains/${domain}/dkim_selector`, {}, { query: `dkim_selector=${data.dkimSelector}` })
+      .then((res : APIResponse) => res as UpdatedDKIMSelectorResponse);
   }
 
-  unlinkIpPoll(domain: string, pool_id: string, ip: string): Promise<APIResponse> {
-    return this.request.delete(urljoin('/v2/domains', domain, 'ips', 'ip_pool'), { pool_id, ip });
+  updateWebPrefix(domain: string, data: WebPrefixInfo): Promise<UpdatedWebPrefixResponse> {
+    return this.request.put(`/v3/domains/${domain}/web_prefix`, {}, { query: `web_prefix=${data.webPrefix}` })
+      .then((res : APIResponse) => res as UpdatedWebPrefixResponse);
   }
 }

package/lib/domainsCredentials.ts

@@ -0,0 +1,88 @@
+import urljoin from 'url-join';
+import APIResponse from './interfaces/ApiResponse';
+import Request from './request';
+
+import {
+  CreatedUpdatedDomainCredentialsResponse,
+  DeletedDomainCredentialsResponse,
+  DomainCredentials,
+  DomainCredentialsList,
+  DomainCredentialsQuery,
+  DomainCredentialsResponseData,
+  DomainCredentialsResult,
+  IDomainCredentials,
+  UpdateDomainCredentialsData
+} from './interfaces/DomainCredentials';
+
+export default class DomainCredentialsClient implements IDomainCredentials {
+  baseRoute: string;
+  request: Request;
+
+  constructor(request: Request) {
+    this.request = request;
+    this.baseRoute = '/v3/domains/';
+  }
+
+  private _parseDomainCredentialsList(
+    response: DomainCredentialsResponseData
+  ): DomainCredentialsList {
+    return {
+      items: response.body.items,
+      totalCount: response.body.total_count
+    };
+  }
+
+  private _parseMessageResponse(
+    response: CreatedUpdatedDomainCredentialsResponse
+  ): DomainCredentialsResult {
+    const result = {
+      status: response.status,
+      message: response.body.message
+    } as DomainCredentialsResult;
+    return result;
+  }
+
+  private _parseDeletedResponse(
+    response:DeletedDomainCredentialsResponse
+  ): DomainCredentialsResult {
+    const result = {
+      status: response.status,
+      message: response.body.message,
+      spec: response.body.spec
+    } as DomainCredentialsResult;
+
+    return result;
+  }
+
+  list(domain: string, query?: DomainCredentialsQuery): Promise<DomainCredentialsList> {
+    return this.request.get(urljoin(this.baseRoute, domain, '/credentials'), query)
+      .then(
+        (res: APIResponse) => this._parseDomainCredentialsList(res as DomainCredentialsResponseData)
+      );
+  }
+
+  create(
+    domain: string,
+    data: DomainCredentials
+  ): Promise<DomainCredentialsResult> {
+    return this.request.postWithFD(`${this.baseRoute}${domain}/credentials`, data)
+      .then((res: APIResponse) => this._parseMessageResponse(res));
+  }
+
+  update(
+    domain: string,
+    credentialsLogin: string,
+    data: UpdateDomainCredentialsData
+  ): Promise<DomainCredentialsResult> {
+    return this.request.putWithFD(`${this.baseRoute}${domain}/credentials/${credentialsLogin}`, data)
+      .then((res: APIResponse) => this._parseMessageResponse(res));
+  }
+
+  destroy(
+    domain: string,
+    credentialsLogin: string
+  ): Promise<DomainCredentialsResult> {
+    return this.request.delete(`${this.baseRoute}${domain}/credentials/${credentialsLogin}`)
+      .then((res: APIResponse) => this._parseDeletedResponse(res));
+  }
+}

package/lib/events.ts

@@ -1,6 +1,6 @@
 import urljoin from 'url-join';
 import {
-  EventsList, EventsPage, EventsResponse, PagesList, PagesListAccumulator
+  EventsList, EventsPage, EventsResponse, PagesList, PagesListAccumulator, ParsedPagesList
 } from './interfaces/Events';
 
 import Request from './request';
@@ -20,7 +20,7 @@ export default class EventClient {
     return { id, number: this._parsePageNumber(url), url };
   }
 
-  _parsePageLinks(response: EventsResponse) : PagesList {
+  _parsePageLinks(response: EventsResponse) : ParsedPagesList {
     const pages = Object.entries(response.body.paging as PagesList);
     return pages.reduce(
       (acc: PagesListAccumulator, entrie: [url: string, id: string]) => {
@@ -29,7 +29,7 @@ export default class EventClient {
         acc[id] = this._parsePage(id, url);
         return acc;
       }, {}
-    ) as unknown as PagesList;
+    ) as unknown as ParsedPagesList;
   }
 
   _parseEventList(response: EventsResponse) : EventsList {
@@ -39,14 +39,14 @@ export default class EventClient {
     };
   }
 
-  get(domain: string, query: { page: string }) : Promise<EventsList> {
+  get(domain: string, query?: { page: string }) : Promise<EventsList> {
     let url;
     const queryCopy = { ...query };
     if (queryCopy && queryCopy.page) {
-      url = urljoin('/v2', domain, 'events', queryCopy.page);
+      url = urljoin('/v3', domain, 'events', queryCopy.page);
       delete queryCopy.page;
     } else {
-      url = urljoin('/v2', domain, 'events');
+      url = urljoin('/v3', domain, 'events');
     }
     return this.request.get(url, queryCopy)
       .then((response: EventsResponse) => this._parseEventList(response));

package/lib/interfaces/DomainCredentials.ts

@@ -0,0 +1,68 @@
+/* eslint-disable camelcase */
+export interface DomainCredentialsQuery {
+    limit: number;
+    skip: number;
+}
+
+export interface DomainCredentials {
+    login: string;
+    password: string;
+}
+
+export interface DomainCredentialsItem {
+    created_at: string,
+    login: string,
+    mailbox: string,
+    size_bytes: number | null
+}
+export interface DomainCredentialsResponseData {
+    status: number;
+    body: {
+        items: DomainCredentialsItem[];
+        total_count: number;
+    }
+}
+
+export interface DomainCredentialsList {
+    items: DomainCredentialsItem[];
+    totalCount: number;
+}
+export interface DomainCredentialsResult {
+    status: number,
+    message: string;
+    spec?: string;
+}
+
+export interface CreatedUpdatedDomainCredentialsResponse {
+    status: number,
+    body: {
+        message: string;
+    }
+}
+
+export interface DeletedDomainCredentialsResponse {
+    status: number,
+    body: {
+        message: string;
+        spec: string;
+    }
+}
+
+export interface UpdateDomainCredentialsData {
+    password: string;
+}
+
+export interface IDomainCredentials {
+    list(domain: string, query: DomainCredentialsQuery): Promise<DomainCredentialsList>
+    create(domain: string, data: DomainCredentials
+    ): Promise<DomainCredentialsResult>
+    update(
+        domain: string,
+        credentialsLogin: string,
+        data: UpdateDomainCredentialsData
+    ): Promise<DomainCredentialsResult>
+    destroy(
+        domain: string,
+        credentialsLogin: string
+    ): Promise<DomainCredentialsResult>
+}

package/lib/interfaces/DomainTracking.ts

@@ -18,7 +18,7 @@ export interface DomainTrackingResponse {
 }
 
 export interface UpdatedOpenTracking {
-    message: 'Domain tracking settings have been updated';
+    message: string;
     open?: { active: boolean };
     click?: { active: boolean | 'htmlonly'};
     unsubscribe?: {
@@ -34,14 +34,14 @@ export interface UpdateDomainTrackingResponse {
 }
 
 export interface OpenTrackingInfo {
-    active: 'yes' | 'no';
+    active: 'yes'| 'no' | 'true' | 'false';
 }
 export interface ClickTrackingInfo {
-    active: 'yes' | 'no' | 'htmlonly';
+    active: 'yes'| 'no' | 'true' | 'false' | 'htmlonly';
 }
 
 export interface UnsubscribeTrackingInfo {
-    active: boolean;
+    active: 'yes'| 'no' | 'true' | 'false';
     html_footer: string;
     text_footer: string;
 }

package/lib/interfaces/Domains.ts

@@ -11,7 +11,7 @@ export interface DomainInfo {
     smtp_password: string;
     spam_action?: 'disabled' | 'block' | 'tag';
     wildcard?: boolean;
-    force_dkim_authority?: true;
+    force_dkim_authority?: boolean | 'true' | 'false';
     dkim_key_size?: 1024 | 2048;
     ips?: '';
     pool_id?: '';
@@ -69,13 +69,74 @@ export interface DomainListResponseData {
     }
 }
 
-export interface DestroyedDomain {
-    message: string;
+export interface MessageResponse {
+    message : string
 }
 
 export interface DestroyedDomainResponse {
     status: number;
+    body: MessageResponse
+}
+
+export interface ConnectionSettings {
+    require_tls: boolean;
+    skip_verification: boolean;
+}
+export interface ConnectionSettingsResponse {
     body: {
-        message: string;
+        connection: ConnectionSettings
     }
+    status: number
+}
+
+export interface UpdatedConnectionSettings {
+    message: string,
+    require_tls: boolean,
+    skip_verification: boolean
+}
+
+export interface UpdatedConnectionSettingsRes {
+    body: UpdatedConnectionSettings,
+    status: number
+}
+
+export interface DKIMAuthorityInfo {
+    self: boolean | 'yes' | 'no' | 'true' |'false'
+}
+
+export interface UpdatedDKIMAuthority {
+    changed: boolean,
+    message: string,
+    sending_dns_records: DNSRecord[]
+}
+
+export interface UpdatedDKIMAuthorityResponse {
+    body: UpdatedDKIMAuthority,
+    status: 200
+}
+
+export interface DKIMSelectorInfo {
+    dkimSelector: string
+}
+
+export interface UpdatedDKIMSelectorResponse {
+    body:MessageResponse,
+    status: number
+}
+
+export interface WebPrefixInfo {
+    webPrefix: string
+}
+
+export interface UpdatedWebPrefix {
+    message : string
+}
+export interface UpdatedWebPrefixResponse {
+    body:MessageResponse,
+    status: number
+}
+
+export interface ReplacementForPool {
+    pool_id?: string;
+    ip?: string;
 }

package/lib/interfaces/Events.ts

@@ -15,10 +15,74 @@ export interface EventsResponse {
         paging: PagesList;
     }
 }
+export interface DomainEvent {
+    severity: string;
+    tags: string[];
+    storage: {
+        url: string;
+        key: string
+    };
+    'delivery-status': {
+        tls: boolean;
+        'mx-host': string;
+        code: number;
+        description: string;
+        'session-seconds': number;
+        utf8: boolean;
+        'attempt-no': number;
+        message: string;
+        'certificate-verified': boolean
+    };
+    'recipient-domain': string;
+    id: string;
+    campaigns: [];
+    reason: string;
+    'user-variables': {
+        [key: string]: any;
+    };
+    flags: {
+        'is-routed': boolean;
+        'is-authenticated': boolean;
+        'is-system-test': boolean;
+        'is-test-mode': boolean
+    };
+    'log-level' : string;
+    template?: any;
+    timestamp: number;
+    envelope: {
+        transport: string;
+        sender: string;
+        'sending-ip': string;
+        targets: string
+    };
+    message: {
+        headers: {
+            to: string;
+            'message-id': string;
+            from: string;
+            subject: string
+        };
+        attachments: [];
+        size: 308
+    };
+    recipient: string;
+    event: string;
+}
 
+export interface ParsedPage{
+    id: string;
+    number: string;
+    url: string
+}
+export interface ParsedPagesList {
+    previous: ParsedPage;
+    first: ParsedPage;
+    last: ParsedPage;
+    next: ParsedPage;
+}
 export interface EventsList {
-    items: [];
-    pages: PagesList;
+    items: DomainEvent[];
+    pages: ParsedPagesList;
 }
 export interface PagesListAccumulator {
     [index: string]: EventsPage