mailgun.js 5.0.1 → 5.0.4

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [5.0.4](https://github.com/mailgun/mailgun.js/compare/v5.0.3...v5.0.4) (2022-03-29)
+
+
+### Bug Fixes
+
+* Remove dts-bundle dependency. Add package.json to dist ([94cfd56](https://github.com/mailgun/mailgun.js/commits/94cfd561908317c897d6764e2bbb9fed8b8bd854))
+* Update postchangelog command ([08439c8](https://github.com/mailgun/mailgun.js/commits/08439c835ca4f5757cff8d52ec588288892817f7))
+
+### [5.0.3](https://github.com/mailgun/mailgun.js/compare/v5.0.2...v5.0.3) (2022-03-23)
+
+
+### Bug Fixes
+
+* Remove deprecated url package ([406eb56](https://github.com/mailgun/mailgun.js/commits/406eb56916bd52ca8e3d9b1ffacf419d42db5a86))
+* TypeError -> mailgun_js_1.default is not a constructor ([ff91333](https://github.com/mailgun/mailgun.js/commits/ff91333c3f34434c54e993da62a61dc38d6196f4))
+* Update DomainsQuery interface for mg.domains.list ([b55eb52](https://github.com/mailgun/mailgun.js/commits/b55eb52c18eb6d81dd3e6fcb991a8b7b5a75a4ab))
+* Update get method in Domain templates client interface to have an optional parameter ([12868a8](https://github.com/mailgun/mailgun.js/commits/12868a88e5465d4f3dcb3e3797522c7b4fc552a0))
+
+
+### Other changes
+
+* Update webpack release config ([240038a](https://github.com/mailgun/mailgun.js/commits/240038a180eb0ad6a704bf24ed01e3c241bef5d5))
+
+### [5.0.2](https://github.com/mailgun/mailgun.js/compare/v5.0.1...v5.0.2) (2022-03-14)
+
+
+### Bug Fixes
+
+* Make `StatsQuery` interface properties optional, add `StatsEvent` type ([91a2d6a](https://github.com/mailgun/mailgun.js/commits/91a2d6ae22f2c9cb86ee64ccab636d23926bb6d1))
+
 ### [5.0.1](https://github.com/mailgun/mailgun.js/compare/v5.0.0...v5.0.1) (2022-02-23)
 
 

package/README.md

@@ -1829,10 +1829,21 @@ npm install
 ```
 
 ## Build
-
+Build for dev purposes(without minimizing)
 ```sh
 npm run build
 ```
+Build for release purposes(include minimizing)
+```sh
+npm run build:release
+```
+
+## Merging changes
+
+Before PR merge check that commits info will be correctly added to the CHANGELOG.md file:
+'npm run release -- --dry-run'
+
+> CI process isn't working currently, so please manually run ```npm run test```
 
 ## Tests
 
@@ -1846,6 +1857,9 @@ Watch tests with
 npm run watch-tests
 ```
 
+To test new functionality locally using ```npm link``` please use npm script ```npm run link```.
+This is needed for correct exporting d.ts files.
+
 ## Release Process
 
 Releases occur after feature branches have been tested and merged into master.
@@ -1861,5 +1875,3 @@ Next, run ```npm run release```.
 
 After that, run ```npm login``` and ```npm publish``` to publish changes on npm.
 
-## TODO
-- add browser demo to heroku

package/client.d.ts

@@ -0,0 +1,29 @@
+import Options from './interfaces/Options';
+import DomainClient from './domains';
+import EventClient from './events';
+import StatsClient from './stats';
+import SuppressionClient from './suppressions';
+import WebhookClient from './webhooks';
+import MessagesClient from './messages';
+import RoutesClient from './routes';
+import ValidateClient from './validate';
+import IpsClient from './ips';
+import IpPoolsClient from './ip-pools';
+import ListsClient from './lists';
+import { InputFormData } from './interfaces/IFormData';
+import { IMailgunClient } from './interfaces/IMailgunClient';
+export default class Client implements IMailgunClient {
+    private request;
+    domains: DomainClient;
+    webhooks: WebhookClient;
+    events: EventClient;
+    stats: StatsClient;
+    suppressions: SuppressionClient;
+    messages: MessagesClient;
+    routes: RoutesClient;
+    validate: ValidateClient;
+    ips: IpsClient;
+    ip_pools: IpPoolsClient;
+    lists: ListsClient;
+    constructor(options: Options, formData: InputFormData);
+}

package/domains.d.ts

@@ -0,0 +1,53 @@
+import { DomainsQuery, DomainInfo, DomainShortData, DNSRecord, ConnectionSettings, UpdatedConnectionSettings, DKIMAuthorityInfo, UpdatedDKIMAuthority, DKIMSelectorInfo, UpdatedDKIMSelectorResponse, WebPrefixInfo, UpdatedWebPrefixResponse, ReplacementForPool, MessageResponse } from './interfaces/Domains';
+import APIResponse from './interfaces/ApiResponse';
+import Request from './request';
+import { DomainTrackingData, OpenTrackingInfo, ClickTrackingInfo, UnsubscribeTrackingInfo, UpdatedOpenTracking } from './interfaces/DomainTracking';
+import { IDomainCredentials } from './interfaces/DomainCredentials';
+import { IDomainTemplatesClient } from './interfaces/DomainTemplates';
+import DomainCredentialsClient from './domainsCredentials';
+import DomainTemplatesClient from './domainsTemplates';
+import { IDomainTagsClient } from './interfaces/DomainTags';
+import DomainTagsClient from './domainsTags';
+export declare class Domain {
+    name: string;
+    require_tls: boolean;
+    skip_verification: boolean;
+    state: string;
+    wildcard: boolean;
+    spam_action: string;
+    created_at: string;
+    smtp_password: string;
+    smtp_login: string;
+    type: string;
+    receiving_dns_records: DNSRecord[] | null;
+    sending_dns_records: DNSRecord[] | null;
+    constructor(data: DomainShortData, receiving?: DNSRecord[] | null, sending?: DNSRecord[] | null);
+}
+export default class DomainClient {
+    request: Request;
+    domainCredentials: IDomainCredentials;
+    domainTemplates: IDomainTemplatesClient;
+    domainTags: IDomainTagsClient;
+    constructor(request: Request, domainCredentialsClient: DomainCredentialsClient, domainTemplatesClient: DomainTemplatesClient, domainTagsClient: DomainTagsClient);
+    private _parseMessage;
+    private _parseDomainList;
+    private _parseDomain;
+    private _parseTrackingSettings;
+    private _parseTrackingUpdate;
+    list(query?: DomainsQuery): Promise<Domain[]>;
+    get(domain: string): Promise<Domain>;
+    create(data: DomainInfo): Promise<Domain>;
+    destroy(domain: string): Promise<MessageResponse>;
+    getConnection(domain: string): Promise<ConnectionSettings>;
+    updateConnection(domain: string, data: ConnectionSettings): Promise<UpdatedConnectionSettings>;
+    getTracking(domain: string): Promise<DomainTrackingData>;
+    updateTracking(domain: string, type: string, data: OpenTrackingInfo | ClickTrackingInfo | UnsubscribeTrackingInfo): Promise<UpdatedOpenTracking>;
+    getIps(domain: string): Promise<string[]>;
+    assignIp(domain: string, ip: string): Promise<APIResponse>;
+    deleteIp(domain: string, ip: string): Promise<APIResponse>;
+    linkIpPool(domain: string, pool_id: string): Promise<APIResponse>;
+    unlinkIpPoll(domain: string, replacement: ReplacementForPool): Promise<APIResponse>;
+    updateDKIMAuthority(domain: string, data: DKIMAuthorityInfo): Promise<UpdatedDKIMAuthority>;
+    updateDKIMSelector(domain: string, data: DKIMSelectorInfo): Promise<UpdatedDKIMSelectorResponse>;
+    updateWebPrefix(domain: string, data: WebPrefixInfo): Promise<UpdatedWebPrefixResponse>;
+}

package/domainsCredentials.d.ts

@@ -0,0 +1,14 @@
+import Request from './request';
+import { DomainCredentials, DomainCredentialsList, DomainCredentialsQuery, DomainCredentialsResult, IDomainCredentials, UpdateDomainCredentialsData } from './interfaces/DomainCredentials';
+export default class DomainCredentialsClient implements IDomainCredentials {
+    baseRoute: string;
+    request: Request;
+    constructor(request: Request);
+    private _parseDomainCredentialsList;
+    private _parseMessageResponse;
+    private _parseDeletedResponse;
+    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/domainsTags.d.ts

@@ -0,0 +1,34 @@
+import Request from './request';
+import { DomainTagCountriesAggregation, DomainTagDevicesAggregation, DomainTagProvidersAggregation, DomainTagsItem, DomainTagsItemInfo, DomainTagsList, DomainTagsMessageRes, DomainTagsQuery, DomainTagsStatisticQuery, DomainTagStatAPIResponse, DomainTagStatisticItem, DomainTagStatisticResult, IDomainTagsClient, Resolution } from './interfaces/DomainTags';
+export declare class DomainTag implements DomainTagsItem {
+    tag: string;
+    description: string;
+    'first-seen': Date;
+    'last-seen': Date;
+    constructor(tagInfo: DomainTagsItemInfo);
+}
+export declare class DomainTagStatistic implements DomainTagStatisticResult {
+    tag: string;
+    description: string;
+    start: Date;
+    end: Date;
+    resolution: Resolution;
+    stats: DomainTagStatisticItem[];
+    constructor(tagStatisticInfo: DomainTagStatAPIResponse);
+}
+export default class DomainTagsClient implements IDomainTagsClient {
+    baseRoute: string;
+    request: Request;
+    constructor(request: Request);
+    private _parsePageLinks;
+    private _parseDomainTagsList;
+    private _parseTagStatistic;
+    list(domain: string, query?: DomainTagsQuery): Promise<DomainTagsList>;
+    get(domain: string, tag: string): Promise<DomainTagsItem>;
+    update(domain: string, tag: string, description: string): Promise<DomainTagsMessageRes>;
+    destroy(domain: string, tag: string): Promise<DomainTagsMessageRes>;
+    statistic(domain: string, tag: string, query: DomainTagsStatisticQuery): Promise<DomainTagStatistic>;
+    countries(domain: string, tag: string): Promise<DomainTagCountriesAggregation>;
+    providers(domain: string, tag: string): Promise<DomainTagProvidersAggregation>;
+    devices(domain: string, tag: string): Promise<DomainTagDevicesAggregation>;
+}

package/domainsTemplates.d.ts

@@ -0,0 +1,35 @@
+import Request from './request';
+import { CreateDomainTemplateVersionResult, DomainTemplate, DomainTemplateData, DomainTemplatesQuery, DomainTemplateUpdateData, DomainTemplateUpdateVersionData, DomainTemplateVersionData, IDomainTemplatesClient, ListDomainTemplatesResult, ListDomainTemplateVersionsResult, MutateDomainTemplateVersionResult, NotificationResult, ShortTemplateVersion, TemplateQuery, TemplateVersion, UpdateOrDeleteDomainTemplateResult } from './interfaces/DomainTemplates';
+export declare class DomainTemplateItem implements DomainTemplate {
+    name: string;
+    description: string;
+    createdAt: Date | '';
+    createdBy: string;
+    id: string;
+    version?: TemplateVersion;
+    versions?: ShortTemplateVersion[];
+    constructor(domainTemplateFromAPI: DomainTemplate);
+}
+export default class DomainTemplatesClient implements IDomainTemplatesClient {
+    baseRoute: string;
+    request: Request;
+    constructor(request: Request);
+    private parseCreationResponse;
+    private parseCreationVersionResponse;
+    private parseMutationResponse;
+    private parseNotificationResponse;
+    private parseMutateTemplateVersionResponse;
+    private parseList;
+    private parseListTemplateVersions;
+    list(domain: string, query?: DomainTemplatesQuery): Promise<ListDomainTemplatesResult>;
+    get(domain: string, templateName: string, query?: TemplateQuery): Promise<DomainTemplateItem>;
+    create(domain: string, data: DomainTemplateData): Promise<DomainTemplateItem>;
+    update(domain: string, templateName: string, data: DomainTemplateUpdateData): Promise<UpdateOrDeleteDomainTemplateResult>;
+    destroy(domain: string, templateName: string): Promise<UpdateOrDeleteDomainTemplateResult>;
+    destroyAll(domain: string): Promise<NotificationResult>;
+    createVersion(domain: string, templateName: string, data: DomainTemplateVersionData): Promise<CreateDomainTemplateVersionResult>;
+    getVersion(domain: string, templateName: string, tag: string): Promise<DomainTemplateItem>;
+    updateVersion(domain: string, templateName: string, tag: string, data: DomainTemplateUpdateVersionData): Promise<MutateDomainTemplateVersionResult>;
+    destroyVersion(domain: string, templateName: string, tag: string): Promise<MutateDomainTemplateVersionResult>;
+    listVersions(domain: string, templateName: string, query?: DomainTemplatesQuery): Promise<ListDomainTemplateVersionsResult>;
+}

package/error.d.ts

@@ -0,0 +1,7 @@
+import APIErrorOptions from './interfaces/APIErrorOptions';
+export default class APIError extends Error {
+    status: number | string;
+    stack: string;
+    details: string;
+    constructor({ status, statusText, message, body }: APIErrorOptions);
+}

package/events.d.ts

@@ -0,0 +1,13 @@
+import { EventsList, EventsPage, EventsResponse, ParsedPagesList } from './interfaces/Events';
+import Request from './request';
+export default class EventClient {
+    request: Request;
+    constructor(request: Request);
+    _parsePageNumber(url: string): string;
+    _parsePage(id: string, url: string): EventsPage;
+    _parsePageLinks(response: EventsResponse): ParsedPagesList;
+    _parseEventList(response: EventsResponse): EventsList;
+    get(domain: string, query?: {
+        page: string;
+    }): Promise<EventsList>;
+}

package/index.d.ts

@@ -0,0 +1,9 @@
+import Client from './client';
+import { InputFormData } from './interfaces/IFormData';
+import Options from './interfaces/Options';
+export default class Mailgun {
+    static get default(): typeof Mailgun;
+    private formData;
+    constructor(FormData: InputFormData);
+    client(options: Options): Client;
+}

package/interfaces/APIErrorOptions.d.ts

@@ -0,0 +1,11 @@
+interface APIErrorOptions {
+    headers: {
+        [key: string]: any;
+    };
+    status: number | string;
+    message: string;
+    body: any;
+    url: string;
+    statusText: string;
+}
+export default APIErrorOptions;

package/{lib/interfaces/ApiResponse.ts → interfaces/ApiResponse.d.ts}

@@ -1,6 +1,5 @@
- interface APIResponse {
+interface APIResponse {
     status: number;
     body: any;
 }
-
 export default APIResponse;

package/{lib/interfaces/DomainCredentials.ts → interfaces/DomainCredentials.d.ts}

@@ -1,68 +1,52 @@
-/* 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
+    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,
+    status: number;
     message: string;
     spec?: string;
 }
-
 export interface CreatedUpdatedDomainCredentialsResponse {
-    status: number,
+    status: number;
     body: {
         message: string;
-    }
+    };
 }
-
 export interface DeletedDomainCredentialsResponse {
-    status: number,
+    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>
+    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/DomainTags.ts → interfaces/DomainTags.d.ts}

@@ -1,15 +1,12 @@
-/* eslint-disable camelcase */
 import { DomainTagStatistic } from '../domainsTags';
-
-export enum Resolution {
-    HOUR = 'hour',
-    DAY = 'day',
-    MONTH = 'month'
+export declare enum Resolution {
+    HOUR = "hour",
+    DAY = "day",
+    MONTH = "month"
 }
 export interface DomainTagsQuery {
     limit: number;
 }
-
 export interface DomainTagsStatisticQuery {
     event: string;
     start?: number;
@@ -17,31 +14,27 @@ export interface DomainTagsStatisticQuery {
     resolution?: Resolution;
     duration?: string;
 }
-
 export interface DomainTagsItemInfo {
-    tag: string,
-    description: string,
-    'first-seen': string,
-    'last-seen': string
+    tag: string;
+    description: string;
+    'first-seen': string;
+    'last-seen': string;
 }
-
 export interface DomainTagsItem {
-    tag: string,
-    description: string,
-    'first-seen': Date,
-    'last-seen': Date
+    tag: string;
+    description: string;
+    'first-seen': Date;
+    'last-seen': Date;
 }
-
 export interface PagesList {
     previous: string;
     first: string;
     last: string;
     next: string;
 }
-
-export interface ParsedPage{
+export interface ParsedPage {
     id: string;
-    url: string
+    url: string;
 }
 export interface ParsedPagesList {
     previous: ParsedPage;
@@ -49,40 +42,35 @@ export interface ParsedPagesList {
     last: ParsedPage;
     next: ParsedPage;
 }
-
 export interface TagsPage {
     id: string;
     url: string;
 }
-
 export interface PagesListAccumulator {
-    [index: string]: TagsPage
+    [index: string]: TagsPage;
 }
 export interface DomainTagsResponseData {
     status: number;
     body: {
         items: DomainTagsItemInfo[];
-        paging: PagesList
-    }
+        paging: PagesList;
+    };
 }
-
 export interface DomainTagsList {
     items: DomainTagsItem[];
     pages: ParsedPagesList;
 }
-
 export interface DomainTagsMessageRes {
     message: string;
     status?: number;
 }
-
 export interface DomainTagAPIResponseStatsItem {
-    time:string
+    time: string;
     accepted?: {
         incoming: number;
         outgoing: number;
-        total: number
-    }
+        total: number;
+    };
     delivered?: {
         smtp: number;
         http: number;
@@ -93,7 +81,7 @@ export interface DomainTagAPIResponseStatsItem {
         total: number;
     };
     failed?: {
-        temporary:{
+        temporary: {
             espblock: number;
             total: number;
         };
@@ -107,7 +95,7 @@ export interface DomainTagAPIResponseStatsItem {
             optimized: number;
             total: number;
         };
-    },
+    };
     clicked?: {
         total: number;
     };
@@ -119,22 +107,21 @@ export interface DomainTagAPIResponseStatsItem {
     };
     stored?: {
         total: number;
-    }
+    };
 }
 export interface DomainTagStatAPIResponse {
-    body:{
+    body: {
         tag: string;
         description: string;
         start: string;
         end: string;
         resolution: Resolution;
         stats: DomainTagAPIResponseStatsItem[];
-    }
+    };
 }
-export interface DomainTagStatisticItem extends Omit <DomainTagAPIResponseStatsItem, 'time'>{
-    time: Date
+export interface DomainTagStatisticItem extends Omit<DomainTagAPIResponseStatsItem, 'time'> {
+    time: Date;
 }
-
 export interface DomainTagStatisticResult {
     tag: string;
     description: string;
@@ -143,25 +130,23 @@ export interface DomainTagStatisticResult {
     resolution: Resolution;
     stats: DomainTagStatisticItem[];
 }
-
 export interface DomainTagCountriesAPIResponse {
     body: {
-        tag:string;
+        tag: string;
         country: {
-            [key:string]: {
+            [key: string]: {
                 clicked: number;
                 complained: number;
                 opened: number;
                 unique_clicked: number;
                 unique_opened: number;
                 unsubscribed: number;
-            }
+            };
         };
-    }
+    };
 }
-
 export interface DomainTagCountriesAggregation {
-    tag:string;
+    tag: string;
     country: {
         [key: string]: {
             clicked: number;
@@ -170,15 +155,14 @@ export interface DomainTagCountriesAggregation {
             unique_clicked: number;
             unique_opened: number;
             unsubscribed: number;
-        }
-    }
+        };
+    };
 }
-
 export interface DomainTagProvidersAPIResponse {
     body: {
-        tag:string;
+        tag: string;
         provider: {
-            [key:string]: {
+            [key: string]: {
                 accepted: number;
                 clicked: number;
                 complained: number;
@@ -187,12 +171,11 @@ export interface DomainTagProvidersAPIResponse {
                 unique_clicked: number;
                 unique_opened: number;
                 unsubscribed: number;
-            }
+            };
         };
-    }
+    };
     status: number;
 }
-
 export interface DomainTagProvidersAggregation {
     tag: string;
     provider: {
@@ -205,10 +188,9 @@ export interface DomainTagProvidersAggregation {
             unique_clicked: number;
             unique_opened: number;
             unsubscribed: number;
-        }
+        };
     };
 }
-
 export interface DeviceStatistic {
     clicked: number;
     complained: number;
@@ -217,46 +199,30 @@ export interface DeviceStatistic {
     unique_opened: number;
     unsubscribed: number;
 }
-
 export interface DevicesTypes {
     desktop: DeviceStatistic;
     mobile: DeviceStatistic;
     tablet: DeviceStatistic;
     unknown: DeviceStatistic;
 }
-
 export interface DomainTagDevicesAPIResponse {
     body: {
-        tag:string;
+        tag: string;
         device: DevicesTypes;
-    }
+    };
     status: number;
 }
-
 export interface DomainTagDevicesAggregation {
     tag: string;
     device: DevicesTypes;
 }
-
-
 export interface IDomainTagsClient {
-    list(domain: string): Promise<DomainTagsList>
-    get(domain: string, tag: string): Promise<DomainTagsItem>
-    update(
-        domain: string,
-        tag: string,
-        description: string
-    ): Promise<DomainTagsMessageRes>
-    destroy(
-        domain: string,
-        tag: string
-    ): Promise<DomainTagsMessageRes>
-    statistic(
-        domain: string,
-        tag: string,
-        query: DomainTagsStatisticQuery
-    ): Promise<DomainTagStatistic>
-    countries(domain: string, tag: string): Promise<DomainTagCountriesAggregation>
-    providers(domain: string, tag: string): Promise<DomainTagProvidersAggregation>
-    devices(domain: string, tag: string): Promise<DomainTagDevicesAggregation>
+    list(domain: string): Promise<DomainTagsList>;
+    get(domain: string, tag: string): Promise<DomainTagsItem>;
+    update(domain: string, tag: string, description: string): Promise<DomainTagsMessageRes>;
+    destroy(domain: string, tag: string): Promise<DomainTagsMessageRes>;
+    statistic(domain: string, tag: string, query: DomainTagsStatisticQuery): Promise<DomainTagStatistic>;
+    countries(domain: string, tag: string): Promise<DomainTagCountriesAggregation>;
+    providers(domain: string, tag: string): Promise<DomainTagProvidersAggregation>;
+    devices(domain: string, tag: string): Promise<DomainTagDevicesAggregation>;
 }