Started working on the test setup.

Author: JustSamuel

src/Endpoints/alias-endpoints.ts

@@ -1,23 +1,49 @@
-import { AliasDeleteRequest, AliasPostRequest, AliasResponse, AliasUpdateRequest, MailcowResponse } from '../types';
+import {
+  Alias,
+  AliasDeleteRequest,
+  AliasPostRequest,
+  AliasUpdateRequest,
+  MailcowResponse
+} from '../types';
 import MailcowClient from '../index';
+import { wrapPromiseToArray } from '../request-factory';
 
-export interface AliasInterface {
+export interface AliasEndpoints {
   /**
-   * Get mailbox aliases existing in system.
+   * Endpoint for getting mailbox aliases in the system.
    * @param id - The id of the alias you want to get. Use 'all' to retrieve all aliases in the system.
+   *
+   * @example Get all aliases:
+   * ```typescript
+   * mcc.aliases.get('all').then((res) => { console.log(res); });
+   * ```
+   * @example Get a single alias:
+   * ```typescript
+   * mcc.aliases.get(8).then((res) => { console.log(res); });
+   * ```
    */
-  get: (id?: number | 'all') => Promise<AliasResponse[] | AliasResponse>,
-  create: any,
-  update: any,
-  delete: any,
+  get: (id?: number | 'all') => Promise<Alias[]>,
+
+  /**
+   * Endpoint for creating mailbox aliases.
+   * @param payload - View {@link AliasAttributes} for payload parameters.
+   */
+  create: (payload: AliasPostRequest) => Promise<MailcowResponse>,
+  /**
+   * Update for editing a mailbox alias.
+   * @param payload -
+   */
+  update: (payload: AliasUpdateRequest) => Promise<MailcowResponse>,
+  delete: (payload: AliasDeleteRequest) => Promise<MailcowResponse>,
 }
 
-export default function AliasEndpoints(bind: MailcowClient): AliasInterface {
+export function aliasEndpoints(bind: MailcowClient): AliasEndpoints {
   return {
-    get(id = 'all'): Promise<AliasResponse[]> {
-      return  bind.requestFactory.get<AliasResponse[]>(
-        `/api/v1/get/alias/${ id }`,
-      );
+    get(id = 'all'): Promise<Alias[]> {
+      return wrapPromiseToArray<Alias>(
+        bind.requestFactory.get<Alias[] | Alias>(
+          `/api/v1/get/alias/${ id }`
+        ));
     },
     create: (payload: AliasPostRequest): Promise<MailcowResponse> => {
       return bind.requestFactory.post<MailcowResponse>(

src/index.ts

@@ -7,7 +7,7 @@ import domainEndpoints from './Endpoints/domain-endpoints';
 import antiSpamEndpoints from './Endpoints/antispam-endpoints';
 import mailboxEndpoints from './Endpoints/mailbox-endpoint';
 import RequestFactory from './request-factory';
-import aliasEndpoints, { AliasInterface } from './Endpoints/alias-endpoints';
+import { aliasEndpoints, AliasEndpoints } from './Endpoints/alias-endpoints';
 
 /**
  * Class containing all the logic to interface with the Mailcow API in TypeScript.
@@ -49,7 +49,7 @@ export class MailcowClient {
   /**
    * All endpoints related to Aliases.
    */
-  public aliases: AliasInterface = aliasEndpoints(this)
+  public aliases: AliasEndpoints = aliasEndpoints(this)
 
   public domains = domainEndpoints(this)
 

src/request-factory.ts

@@ -2,6 +2,18 @@ import axios, { AxiosError, AxiosResponse } from 'axios';
 import { MailcowErrorResponse, MailcowException, Payload } from './types';
 import MailcowClient from './index';
 
+function wrapToArray<T>(item: T | T[]): T[] {
+  return Array.isArray(item) ? item : [item];
+}
+
+export function wrapPromiseToArray<T>(promise: Promise<T|T[]>): Promise<T[]> {
+  return new Promise<T[]>((resolve, reject) => {
+    promise
+      .then((res: T | T[]) => resolve(wrapToArray(res)))
+      .catch((err) => reject(err));
+  });
+}
+
 /**
  * Factory method patterns for creating Axios Requests.
  * @internal
@@ -18,7 +30,7 @@ export default class RequestFactory {
    * @param route - The route to which to send the request.
    * @param payload - The payload to send with the request.
    */
-  async post <T>(route: string, payload: Payload): Promise<T> {
+  async post<T>(route: string, payload: Payload): Promise<T> {
     return new Promise((resolve, reject) => {
       axios
         .post(this.ctx.BASE_URL + route, payload, this.ctx.HEADERS)

src/types.ts

@@ -220,18 +220,39 @@ export interface ACLEditRequest {
 }
 
 export type AliasAttributes = {
-  address: string;
+  /**
+   * The alias address, for catchall use "@domain.tld".
+   */
+  address: string
+  /**
+   * The destination address, comma separated.
+   */
   goto: string;
+  /**
+   * If true: silently ignore.
+   */
   goto_null?: boolean;
+  /**
+   * If true: learn as spam.
+   */
   goto_spam?: boolean;
+  /**
+   * If true: learn as ham.
+   */
   goto_ham?: boolean;
+  /**
+   * If alias is visible in sogo.
+   */
   sogo_visible: boolean;
+  /**
+   * If alias is active or not.
+   */
   active: boolean;
 };
 
-export type AliasEditAttributes = AliasAttributes & {
-  private_comment: string;
-  public_comment: string;
+export type AliasEditAttributes = Partial<AliasAttributes> & {
+  private_comment?: string;
+  public_comment?: string;
 };
 
 export type AliasPostRequest = AliasAttributes;
@@ -245,18 +266,17 @@ export interface AliasDeleteRequest {
   items: number[];
 }
 
-export interface AliasResponse {
-  in_primary_domain: string;
-  id: number;
-  domain: string;
-  public_comment: string;
-  private_comment: string;
-  goto: string;
-  address: string;
-  is_catch_all: boolean;
-  active: boolean;
-  created: string;
-  modified: string;
+export interface Alias extends AliasAttributes {
+  in_primary_domain: string,
+  id: number,
+  domain: string,
+  public_comment: string,
+  private_comment: string,
+  is_catch_all: boolean,
+  active_int: number,
+  sogo_visible_int: number,
+  created: string,
+  modified: string | null
 }
 
 export class MailcowException extends Error {
@@ -268,13 +288,13 @@ export class MailcowException extends Error {
  *
  * This is used when the API call doesn't return any objects, i.e. POST requests.
  */
-export interface MailcowResponseContent {
+export interface BaseResponse {
   log?: (string | Payload)[];
   msg: string[] | string;
   type: 'succes' | 'danger' | 'error';
 }
 
-export type MailcowResponse = MailcowResponseContent[];
+export type MailcowResponse<T = BaseResponse> = T[];
 
 export interface MailcowErrorResponse extends MailcowResponse {
   msg: string;

test/index.test.ts

@@ -1,19 +1,63 @@
 import MailcowClient from "../src";
-import { expect } from "chai";
+import { expect, assert } from "chai";
 import { describe } from "mocha";
+import { Alias, AliasPostRequest, MailcowResponse } from "../src/types";
+import { AliasEditAttributes } from "../src/types";
 
 const mcc: MailcowClient = new MailcowClient("https://demo.mailcow.email/", "390448-22B69F-FA37D9-19701B-6F033F")
 
+async function thenTestOrFail(promise: Promise<any>, test: Function): Promise<void> {
+  await promise.then((res: any) => {
+    test(res);
+  }).catch((err) => {
+    assert.fail('expected', 'actual', err);
+  });
+}
+
 describe("Alias Endpoint tests", (): void => {
-  it('should get all aliases', (): void => {
-    mcc.aliases.get().then((res) => {
-      expect(res).to.be.length.least(1)
-    })
+  it('should get all aliases', async () => {
+    await thenTestOrFail(mcc.aliases.get(), (res: Alias[]) => expect(res).to.be.length.least(1))
   });
-  it('should get a single alias', (): void => {
-    mcc.aliases.get(8).then((res) => {
-      expect(res).to.be.length(1)
-    })
+  it('should get a single alias', async () => {
+    await thenTestOrFail(mcc.aliases.get(8), (res: Alias[]) => expect(res).to.be.length.least(1))
   });
+  describe("Modify aliases", (): void => {
+    const attr: AliasPostRequest = {
+      active: true,
+      address: "ts-mailcow-api@440044.xyz",
+      goto: "demo@440044.xyz",
+      sogo_visible: true,
+    }
+    const editAttr: AliasEditAttributes = {
+      active: false,
+      address: "ts-mailcow-api-edit@440044.xyz",
+      goto: "demo-edit@440044.xyz",
+      private_comment: "private comment",
+      public_comment: "public comment",
+      sogo_visible: false,
+    }
+    let id: number;
+    it('should create an alias', async () => {
+      await thenTestOrFail(mcc.aliases.create(attr), (res: MailcowResponse) => {
+        expect(res[0].type).to.be.equal("success")
+        id = parseInt(res[0].msg[2])
+      })
+    });
+    it('should delete edit previously created alias', async () => {
+      await thenTestOrFail(mcc.aliases.update({ attr: editAttr, items: [id] }), (res: MailcowResponse) => {
+        expect(res[0].type).to.be.equal("success")
+      })
+      await thenTestOrFail(mcc.aliases.get(id), (res: Alias[]) => {
+        const alias: Alias = res[0]
+        for (let editAttrKey in editAttr) {
+          assert((alias as any)[editAttrKey] == (editAttr as any)[editAttrKey])
+        }
+      })
+    });
+    it('should delete the previously created alias', async () => {
+      await thenTestOrFail(mcc.aliases.delete({ items: [id] }), (res: MailcowResponse) => {
+        expect(res[0].type).to.be.equal("success")
+      })
+    });
+  })
 })
-