mailgun.js 4.1.2 → 4.1.6

package/lib/client.ts

@@ -18,6 +18,7 @@ import MailListsMembers from './mailListMembers';
 import { InputFormData } from './interfaces/IFormData';
 import DomainCredentialsClient from './domainsCredentials';
 import MultipleValidationClient from './multipleValidation';
+import DomainTemplatesClient from './domainsTemplates';
 
 export default class Client {
   private request;
@@ -53,9 +54,10 @@ export default class Client {
     this.request = new Request(config, formData);
     const mailListsMembers = new MailListsMembers(this.request);
     const domainCredentialsClient = new DomainCredentialsClient(this.request);
+    const domainTemplatesClient = new DomainTemplatesClient(this.request);
     const multipleValidationClient = new MultipleValidationClient(this.request);
 
-    this.domains = new DomainClient(this.request, domainCredentialsClient);
+    this.domains = new DomainClient(this.request, domainCredentialsClient, domainTemplatesClient);
     this.webhooks = new WebhookClient(this.request);
     this.events = new EventClient(this.request);
     this.stats = new StatsClient(this.request);

package/lib/domains.ts

@@ -37,7 +37,10 @@ import {
   UpdateDomainTrackingResponse,
   UpdatedOpenTracking
 } from './interfaces/DomainTracking';
+import { IDomainCredentials } from './interfaces/DomainCredentials';
+import { IDomainTemplatesClient } from './interfaces/DomainTemplates';
 import DomainCredentialsClient from './domainsCredentials';
+import DomainTemplatesClient from './domainsTemplates';
 
 export class Domain {
   name: string;
@@ -72,11 +75,17 @@ export class Domain {
 
 export default class DomainClient {
   request: Request;
-  public domainCredentials: DomainCredentialsClient;
-
-  constructor(request: Request, domainCredentialsClient: DomainCredentialsClient) {
+  public domainCredentials: IDomainCredentials;
+  public domainTemplates: IDomainTemplatesClient
+
+  constructor(
+    request: Request,
+    domainCredentialsClient: DomainCredentialsClient,
+    domainTemplatesClient: DomainTemplatesClient
+  ) {
     this.request = request;
     this.domainCredentials = domainCredentialsClient;
+    this.domainTemplates = domainTemplatesClient;
   }
 
   private _parseMessage(response: DestroyedDomainResponse) : MessageResponse {

package/lib/domainsTemplates.ts

@@ -0,0 +1,235 @@
+import urljoin from 'url-join';
+import APIResponse from './interfaces/ApiResponse';
+import Request from './request';
+
+import {
+  CreateDomainTemplateAPIResponse,
+  CreateDomainTemplateVersionAPIResponse,
+  CreateDomainTemplateVersionResult,
+  DomainTemplate, DomainTemplateData,
+  DomainTemplatesQuery,
+  DomainTemplateUpdateData,
+  DomainTemplateUpdateVersionData,
+  DomainTemplateVersionData,
+  GetDomainTemplateAPIResponse,
+  IDomainTemplatesClient,
+  ListDomainTemplatesAPIResponse,
+  ListDomainTemplatesResult,
+  ListDomainTemplateVersionsAPIResponse,
+  ListDomainTemplateVersionsResult,
+  MutateDomainTemplateVersionAPIResponse,
+  MutateDomainTemplateVersionResult,
+  NotificationAPIResponse,
+  NotificationResult,
+  ShortTemplateVersion,
+  TemplateQuery,
+  TemplateVersion,
+  UpdateOrDeleteDomainTemplateAPIResponse,
+  UpdateOrDeleteDomainTemplateResult
+} from './interfaces/DomainTemplates';
+
+export class DomainTemplateItem implements DomainTemplate {
+  name : string;
+  description : string;
+  createdAt : Date | '';
+  createdBy : string;
+  id : string;
+  version?: TemplateVersion;
+  versions?: ShortTemplateVersion[];
+
+  constructor(domainTemplateFromAPI: DomainTemplate) {
+    this.name = domainTemplateFromAPI.name;
+    this.description = domainTemplateFromAPI.description;
+    this.createdAt = domainTemplateFromAPI.createdAt ? new Date(domainTemplateFromAPI.createdAt) : '';
+    this.createdBy = domainTemplateFromAPI.createdBy;
+    this.id = domainTemplateFromAPI.id;
+
+    if (domainTemplateFromAPI.version) {
+      this.version = domainTemplateFromAPI.version;
+      if (domainTemplateFromAPI.version.createdAt) {
+        this.version.createdAt = new Date(domainTemplateFromAPI.version.createdAt);
+      }
+    }
+
+    if (domainTemplateFromAPI.versions && domainTemplateFromAPI.versions.length) {
+      this.versions = domainTemplateFromAPI.versions.map((version) => {
+        const result = { ...version };
+        result.createdAt = new Date(version.createdAt);
+        return result;
+      });
+    }
+  }
+}
+
+export default class DomainTemplatesClient implements IDomainTemplatesClient {
+  baseRoute: string;
+  request: Request;
+
+  constructor(request: Request) {
+    this.request = request;
+    this.baseRoute = '/v3/';
+  }
+
+  private parseCreationResponse(data: CreateDomainTemplateAPIResponse): DomainTemplateItem {
+    return new DomainTemplateItem(data.body.template);
+  }
+
+  private parseCreationVersionResponse(
+    data: CreateDomainTemplateVersionAPIResponse
+  ): CreateDomainTemplateVersionResult {
+    const result: CreateDomainTemplateVersionResult = {} as CreateDomainTemplateVersionResult;
+    result.status = data.status;
+    result.message = data.body.message;
+    if (data.body && data.body.template) {
+      result.template = new DomainTemplateItem(data.body.template);
+    }
+    return result;
+  }
+
+  private parseMutationResponse(
+    data: UpdateOrDeleteDomainTemplateAPIResponse
+  ): UpdateOrDeleteDomainTemplateResult {
+    const result: UpdateOrDeleteDomainTemplateResult = {} as UpdateOrDeleteDomainTemplateResult;
+    result.status = data.status;
+    result.message = data.body.message;
+    if (data.body && data.body.template) {
+      result.templateName = data.body.template.name;
+    }
+    return result;
+  }
+
+  private parseNotificationResponse(data: NotificationAPIResponse): NotificationResult {
+    const result: NotificationResult = {} as NotificationResult;
+    result.status = data.status;
+    result.message = data.body.message;
+    return result;
+  }
+
+  private parseMutateTemplateVersionResponse(
+    data: MutateDomainTemplateVersionAPIResponse
+  ): MutateDomainTemplateVersionResult {
+    const result: MutateDomainTemplateVersionResult = {} as MutateDomainTemplateVersionResult;
+    result.status = data.status;
+    result.message = data.body.message;
+    if (data.body.template) {
+      result.templateName = data.body.template.name;
+      result.templateVersion = { tag: data.body.template.version.tag };
+    }
+    return result;
+  }
+
+  private parseList(response: ListDomainTemplatesAPIResponse): ListDomainTemplatesResult {
+    const data = {} as ListDomainTemplatesResult;
+
+    data.items = response.body.items.map((d: DomainTemplate) => new DomainTemplateItem(d));
+
+    data.pages = response.body.paging;
+
+    return data;
+  }
+
+  private parseListTemplateVersions(
+    response: ListDomainTemplateVersionsAPIResponse
+  ): ListDomainTemplateVersionsResult {
+    const data = {} as ListDomainTemplateVersionsResult;
+
+    data.template = new DomainTemplateItem(response.body.template);
+
+    data.pages = response.body.paging;
+
+    return data;
+  }
+
+  list(domain: string, query?: DomainTemplatesQuery): Promise<ListDomainTemplatesResult> {
+    return this.request.get(urljoin(this.baseRoute, domain, '/templates'), query)
+      .then(
+        (res: APIResponse) => this.parseList(res)
+      );
+  }
+
+  get(domain: string, templateName: string, query?: TemplateQuery): Promise<DomainTemplateItem> {
+    return this.request.get(urljoin(this.baseRoute, domain, '/templates/', templateName), query)
+      .then(
+        (res: GetDomainTemplateAPIResponse) => new DomainTemplateItem(res.body.template)
+      );
+  }
+
+  create(
+    domain: string,
+    data: DomainTemplateData
+  ): Promise<DomainTemplateItem> {
+    return this.request.postWithFD(urljoin(this.baseRoute, domain, '/templates'), data)
+      .then((res: CreateDomainTemplateAPIResponse) => this.parseCreationResponse(res));
+  }
+
+  update(
+    domain: string,
+    templateName: string,
+    data: DomainTemplateUpdateData
+  ): Promise<UpdateOrDeleteDomainTemplateResult> {
+    return this.request.putWithFD(urljoin(this.baseRoute, domain, '/templates/', templateName), data)
+      .then((res: UpdateOrDeleteDomainTemplateAPIResponse) => this.parseMutationResponse(res));
+  }
+
+  destroy(domain: string, templateName: string): Promise<UpdateOrDeleteDomainTemplateResult> {
+    return this.request.delete(urljoin(this.baseRoute, domain, '/templates/', templateName))
+      .then((res: UpdateOrDeleteDomainTemplateAPIResponse) => this.parseMutationResponse(res));
+  }
+
+  destroyAll(domain: string): Promise<NotificationResult> {
+    return this.request.delete(urljoin(this.baseRoute, domain, '/templates'))
+      .then((res: NotificationAPIResponse) => this.parseNotificationResponse(res));
+  }
+
+  createVersion(
+    domain: string,
+    templateName: string,
+    data: DomainTemplateVersionData
+  ): Promise<CreateDomainTemplateVersionResult> {
+    return this.request.postWithFD(urljoin(this.baseRoute, domain, '/templates/', templateName, '/versions'), data)
+      .then(
+        (res: CreateDomainTemplateVersionAPIResponse) => this.parseCreationVersionResponse(res)
+      );
+  }
+
+  getVersion(domain: string, templateName: string, tag: string): Promise<DomainTemplateItem> {
+    return this.request.get(urljoin(this.baseRoute, domain, '/templates/', templateName, '/versions/', tag))
+      .then(
+        (res: GetDomainTemplateAPIResponse) => new DomainTemplateItem(res.body.template)
+      );
+  }
+
+  updateVersion(
+    domain: string,
+    templateName: string,
+    tag: string,
+    data: DomainTemplateUpdateVersionData
+  ): Promise<MutateDomainTemplateVersionResult> {
+    return this.request.putWithFD(urljoin(this.baseRoute, domain, '/templates/', templateName, '/versions/', tag), data)
+      .then(
+        // eslint-disable-next-line max-len
+        (res: MutateDomainTemplateVersionAPIResponse) => this.parseMutateTemplateVersionResponse(res)
+      );
+  }
+
+  destroyVersion(
+    domain: string,
+    templateName: string,
+    tag: string
+  ): Promise<MutateDomainTemplateVersionResult> {
+    return this.request.delete(urljoin(this.baseRoute, domain, '/templates/', templateName, '/versions/', tag))
+      // eslint-disable-next-line max-len
+      .then((res: MutateDomainTemplateVersionAPIResponse) => this.parseMutateTemplateVersionResponse(res));
+  }
+
+  listVersions(
+    domain: string,
+    templateName: string,
+    query?: DomainTemplatesQuery
+  ): Promise<ListDomainTemplateVersionsResult> {
+    return this.request.get(urljoin(this.baseRoute, domain, '/templates', templateName, '/versions'), query)
+      .then(
+        (res: ListDomainTemplateVersionsAPIResponse) => this.parseListTemplateVersions(res)
+      );
+  }
+}

package/lib/interfaces/DomainTemplates.ts

@@ -0,0 +1,238 @@
+import { DomainTemplateItem } from '../domainsTemplates';
+
+export enum YesNo {
+    YES = 'yes',
+    NO = 'no'
+}
+
+export enum Pages {
+    FIRST = 'first',
+    LAST = 'last',
+    NEXT = 'next',
+    PREV = 'prev'
+}
+/* eslint-disable camelcase */
+export interface DomainTemplateData {
+    name: string;
+    description: string;
+    template: string;
+    tag?: string;
+    engine?: string;
+    comment?: string;
+}
+
+export interface DomainTemplateVersionData {
+    template: string;
+    tag: string;
+    engine?: string;
+    comment?: string;
+    active?: YesNo;
+}
+
+export interface DomainTemplateUpdateData {
+    description: string;
+}
+
+export interface DomainTemplateUpdateVersionData {
+    template?: string;
+    comment?: string;
+    active?: YesNo;
+}
+
+export interface DomainTemplatesQuery {
+    page: Pages;
+    limit: number;
+    p: string;
+}
+
+export interface TemplateQuery {
+    active: YesNo;
+}
+
+export interface ShortTemplateVersion {
+    tag: string;
+    engine: string;
+    mjml: string;
+    createdAt: string | Date;
+    comment: string;
+    active: boolean;
+    id: string;
+}
+
+export interface TemplateVersion extends ShortTemplateVersion{
+    template: string;
+}
+export interface DomainTemplate {
+    name: string;
+    description: string;
+    createdAt: string | Date;
+    createdBy: string;
+    id: string;
+    version?: TemplateVersion;
+    versions?: ShortTemplateVersion[];
+}
+
+export interface CreateDomainTemplateAPIResponse {
+    status: number;
+    body: {
+        message: string;
+        template: DomainTemplate;
+    };
+}
+
+export interface ListDomainTemplatesAPIResponse {
+    status: number;
+    body: {
+        items: DomainTemplate[];
+        paging: {
+            first: string;
+            last: string;
+            next: string;
+            previous: string;
+        };
+    };
+}
+
+export interface ListDomainTemplatesResult {
+        items: DomainTemplate[];
+        pages: {
+            first: string;
+            last: string;
+            next: string;
+            previous: string;
+        };
+}
+
+export interface GetDomainTemplateAPIResponse {
+    status: number;
+    body: {
+        template: DomainTemplate;
+    };
+}
+
+export interface UpdateOrDeleteDomainTemplateAPIResponse {
+    status: number;
+    body: {
+        message: string;
+        template: {
+            name: string
+        }
+    };
+}
+
+export interface UpdateOrDeleteDomainTemplateResult {
+    status: number;
+    message: string;
+    templateName?: string;
+}
+
+export interface NotificationAPIResponse {
+    status: number;
+    body: {
+        message: string;
+    };
+}
+
+export interface NotificationResult {
+    status: number;
+    message: string;
+}
+
+export interface CreateDomainTemplateVersionAPIResponse {
+    status: number;
+    body: {
+        message: string;
+        template: DomainTemplate;
+    };
+}
+
+export interface CreateDomainTemplateVersionResult {
+    status: number;
+    message: string;
+    template: DomainTemplate;
+}
+
+export interface MutateDomainTemplateVersionAPIResponse {
+    status: number;
+    body: {
+        message: string;
+        template: {
+            name: string;
+            version: {
+                tag: string;
+            }
+        };
+    };
+}
+
+export interface MutateDomainTemplateVersionResult {
+    status: number;
+    message: string;
+    templateName: string;
+    templateVersion: {
+        tag: string;
+    }
+}
+
+export interface ListDomainTemplateVersionsAPIResponse {
+    status: number;
+    body: {
+        template: {
+            name: string;
+            description: string;
+            createdAt: string;
+            createdBy: string;
+            id: string;
+            versions: ShortTemplateVersion[]
+        }
+        paging: {
+            first: string;
+            last: string;
+            next: string;
+            previous: string;
+        };
+    };
+}
+
+export interface ListDomainTemplateVersionsResult {
+    template: DomainTemplateItem;
+    pages: {
+        first: string;
+        last: string;
+        next: string;
+        previous: string;
+    };
+}
+
+export interface IDomainTemplatesClient {
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mailgun.js",
-  "version": "4.1.2",
+  "version": "4.1.6",
   "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",
@@ -60,15 +60,16 @@
     "form-data": "^3.0.1",
     "husky": "^7.0.1",
     "json-loader": "^0.5.7",
-    "mocha": "^9.1.3",
+    "mocha": "^9.2.0",
     "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",
     "ts-loader": "^8.0.12",
     "ts-node": "^9.1.1",
-    "typedoc": "^0.20.36",
+    "typedoc": "^0.22.11",
     "typescript": "^4.1.3",
     "webpack": "^5.3.2",
     "webpack-cli": "^4.1.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');
   });