mofh-client-ts 1.0.0

package/README.md

@@ -0,0 +1,47 @@
+# MOFH Client (TypeScript)
+
+A TypeScript client for the MyOwnFreeHost (MOFH) API. This library provides a strongly-typed interface for interacting with the MOFH XML and JSON APIs.
+
+## Installation
+
+```bash
+npm install mofh-client-ts
+```
+
+## Usage
+
+```typescript
+import { Client } from 'mofh-client-ts';
+
+const client = new Client('your_api_username', 'your_api_password');
+
+// Example: Check domain availability
+const availability = await client.availability('example.com');
+if (availability.isAvailable()) {
+    console.log('Domain is available!');
+}
+
+// Example: Create an account
+const account = await client.createAccount('user123', 'password', 'email@example.com', 'example.com', 'Plan1');
+if (account.isSuccessful()) {
+    console.log('Account created:', account.getVpUsername());
+} else {
+    console.error('Error:', account.getMessage());
+}
+```
+
+## Features
+
+- Full TypeScript support with type definitions.
+- Promise-based API using `axios`.
+- Support for all major MOFH API endpoints:
+    - Create/Suspend/Unsuspend/Remove Account
+    - Change Password/Package
+    - Check Availability
+    - Get User Domains/Domain User
+    - Support Tickets (Create/Reply)
+    - CNAME Verification
+
+## License
+
+MIT

package/dist/Client.d.ts

@@ -0,0 +1,37 @@
+import { AxiosInstance, AxiosResponse } from 'axios';
+import { AvailabilityResponse } from './Message/AvailabilityResponse';
+import { ChangePackageResponse } from './Message/ChangePackageResponse';
+import { CreateAccountResponse } from './Message/CreateAccountResponse';
+import { CreateTicketResponse } from './Message/CreateTicketResponse';
+import { GetCnameResponse } from './Message/GetCnameResponse';
+import { GetDomainUserResponse } from './Message/GetDomainUserResponse';
+import { GetUserDomainsResponse } from './Message/GetUserDomainsResponse';
+import { ListPackagesResponse } from './Message/ListPackagesResponse';
+import { PasswordResponse } from './Message/PasswordResponse';
+import { RemoveAccountResponse } from './Message/RemoveAccountResponse';
+import { ReplyTicketResponse } from './Message/ReplyTicketResponse';
+import { SuspendResponse } from './Message/SuspendResponse';
+import { UnsuspendResponse } from './Message/UnsuspendResponse';
+export declare class Client {
+    protected httpClient: AxiosInstance;
+    protected apiUsername: string;
+    protected apiPassword: string;
+    protected apiUrl: string;
+    constructor(apiUsername: string, apiPassword: string, apiUrl?: string, httpClient?: AxiosInstance);
+    protected sendPostRequest(path: string, parameters: any, timeout?: number): Promise<AxiosResponse>;
+    protected sendGetRequest(path: string, parameters: any, timeout?: number): Promise<AxiosResponse>;
+    private sendRawRequest;
+    createAccount(username: string, password: string, email: string, domain: string, plan: string): Promise<CreateAccountResponse>;
+    suspend(username: string, reason: string, linked?: boolean): Promise<SuspendResponse>;
+    unsuspend(username: string): Promise<UnsuspendResponse>;
+    password(username: string, password: string): Promise<PasswordResponse>;
+    availability(domain: string): Promise<AvailabilityResponse>;
+    getUserDomains(username: string): Promise<GetUserDomainsResponse>;
+    getDomainUser(domain: string): Promise<GetDomainUserResponse>;
+    getCname(domain: string): Promise<GetCnameResponse>;
+    listPackages(): Promise<ListPackagesResponse>;
+    removeAccount(username: string): Promise<RemoveAccountResponse>;
+    changePackage(username: string, packageName: string): Promise<ChangePackageResponse>;
+    createTicket(subject: string, comments: string, domain: string, username: string, ipAddress: string): Promise<CreateTicketResponse>;
+    replyTicket(ticketId: string, comments: string, username: string, ipAddress: string, domain?: string | null): Promise<ReplyTicketResponse>;
+}

package/dist/Client.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const axios_1 = __importDefault(require("axios"));
+const MofhClientHttpException_1 = require("./Exception/MofhClientHttpException");
+const AvailabilityResponse_1 = require("./Message/AvailabilityResponse");
+const ChangePackageResponse_1 = require("./Message/ChangePackageResponse");
+const CreateAccountResponse_1 = require("./Message/CreateAccountResponse");
+const CreateTicketResponse_1 = require("./Message/CreateTicketResponse");
+const GetCnameResponse_1 = require("./Message/GetCnameResponse");
+const GetDomainUserResponse_1 = require("./Message/GetDomainUserResponse");
+const GetUserDomainsResponse_1 = require("./Message/GetUserDomainsResponse");
+const ListPackagesResponse_1 = require("./Message/ListPackagesResponse");
+const PasswordResponse_1 = require("./Message/PasswordResponse");
+const RemoveAccountResponse_1 = require("./Message/RemoveAccountResponse");
+const ReplyTicketResponse_1 = require("./Message/ReplyTicketResponse");
+const SuspendResponse_1 = require("./Message/SuspendResponse");
+const UnsuspendResponse_1 = require("./Message/UnsuspendResponse");
+class Client {
+    constructor(apiUsername, apiPassword, apiUrl = 'https://panel.myownfreehost.net', httpClient) {
+        this.apiUsername = apiUsername;
+        this.apiPassword = apiPassword;
+        if (apiUrl.endsWith('/')) {
+            apiUrl = apiUrl.slice(0, -1);
+        }
+        if (apiUrl.endsWith('/xml-api')) {
+            apiUrl = apiUrl.slice(0, -8);
+        }
+        this.apiUrl = apiUrl;
+        this.httpClient = httpClient || axios_1.default.create({
+            timeout: 5000,
+        });
+    }
+    async sendPostRequest(path, parameters, timeout = 60000) {
+        return this.sendRawRequest('POST', path, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            },
+            data: new URLSearchParams(parameters),
+            auth: {
+                username: this.apiUsername,
+                password: this.apiPassword
+            },
+            timeout: timeout,
+        });
+    }
+    async sendGetRequest(path, parameters, timeout = 10000) {
+        return this.sendRawRequest('GET', path, {
+            params: {
+                api_user: this.apiUsername,
+                api_key: this.apiPassword,
+                ...parameters
+            },
+            timeout: timeout,
+        });
+    }
+    async sendRawRequest(method, url, requestOptions = {}) {
+        try {
+            return await this.httpClient.request({
+                method: method,
+                url: `${this.apiUrl}${url}`,
+                ...requestOptions
+            });
+        }
+        catch (e) {
+            throw new MofhClientHttpException_1.MofhClientHttpException('The MOFH API returned a HTTP error: ' + (e.message || e), 0, e);
+        }
+    }
+    async createAccount(username, password, email, domain, plan) {
+        const response = await this.sendPostRequest('/xml-api/createacct', {
+            username: username,
+            password: password,
+            contactemail: email,
+            domain: domain,
+            plan: plan,
+        });
+        return new CreateAccountResponse_1.CreateAccountResponse(response);
+    }
+    async suspend(username, reason, linked = false) {
+        const response = await this.sendPostRequest('/xml-api/suspendacct', {
+            user: username,
+            reason: reason,
+            linked: linked ? '1' : '0',
+        });
+        return new SuspendResponse_1.SuspendResponse(response);
+    }
+    async unsuspend(username) {
+        const response = await this.sendPostRequest('/xml-api/unsuspendacct', {
+            user: username,
+        });
+        return new UnsuspendResponse_1.UnsuspendResponse(response);
+    }
+    async password(username, password) {
+        const response = await this.sendPostRequest('/xml-api/passwd', {
+            user: username,
+            pass: password,
+        });
+        return new PasswordResponse_1.PasswordResponse(response);
+    }
+    async availability(domain) {
+        const response = await this.sendGetRequest('/xml-api/checkavailable', {
+            domain: domain,
+        });
+        return new AvailabilityResponse_1.AvailabilityResponse(response);
+    }
+    async getUserDomains(username) {
+        const response = await this.sendGetRequest('/json-api/getuserdomains', {
+            username: username,
+        });
+        return new GetUserDomainsResponse_1.GetUserDomainsResponse(response);
+    }
+    async getDomainUser(domain) {
+        const response = await this.sendGetRequest('/json-api/getdomainuser', {
+            domain: domain,
+        });
+        return new GetDomainUserResponse_1.GetDomainUserResponse(response);
+    }
+    async getCname(domain) {
+        const response = await this.sendPostRequest('/xml-api/getcname', {
+            api_user: this.apiUsername,
+            api_key: this.apiPassword,
+            domain_name: domain,
+        });
+        return new GetCnameResponse_1.GetCnameResponse(response);
+    }
+    async listPackages() {
+        const response = await this.sendGetRequest('/json-api/listpkgs', {});
+        return new ListPackagesResponse_1.ListPackagesResponse(response);
+    }
+    async removeAccount(username) {
+        const response = await this.sendPostRequest('/xml-api/removeacct', {
+            user: username,
+        });
+        return new RemoveAccountResponse_1.RemoveAccountResponse(response);
+    }
+    async changePackage(username, packageName) {
+        const response = await this.sendPostRequest('/xml-api/changepackage', {
+            user: username,
+            pkg: packageName.toLowerCase(),
+        });
+        return new ChangePackageResponse_1.ChangePackageResponse(response);
+    }
+    async createTicket(subject, comments, domain, username, ipAddress) {
+        const response = await this.sendPostRequest('/xml-api/supportnewticket', {
+            api_user: this.apiUsername,
+            api_key: this.apiPassword,
+            comments: comments,
+            subject: subject,
+            domain_name: domain,
+            ipaddress: ipAddress,
+            clientusername: username,
+        });
+        return new CreateTicketResponse_1.CreateTicketResponse(response);
+    }
+    async replyTicket(ticketId, comments, username, ipAddress, domain = null) {
+        const params = {
+            api_user: this.apiUsername,
+            api_key: this.apiPassword,
+            comments: comments,
+            ipaddress: ipAddress,
+            clientusername: username,
+            ticket_id: ticketId,
+        };
+        if (domain) {
+            params.domain_name = domain;
+        }
+        const response = await this.sendPostRequest('/xml-api/supportreplyticket', params);
+        return new ReplyTicketResponse_1.ReplyTicketResponse(response);
+    }
+}
+exports.Client = Client;

package/dist/Exception/MismatchedStatusesException.d.ts

@@ -0,0 +1,3 @@
+import { MofhClientException } from './MofhClientException';
+export declare class MismatchedStatusesException extends MofhClientException {
+}

package/dist/Exception/MismatchedStatusesException.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MismatchedStatusesException = void 0;
+const MofhClientException_1 = require("./MofhClientException");
+class MismatchedStatusesException extends MofhClientException_1.MofhClientException {
+}
+exports.MismatchedStatusesException = MismatchedStatusesException;

package/dist/Exception/MofhClientException.d.ts

@@ -0,0 +1,3 @@
+export declare class MofhClientException extends Error {
+    constructor(message: string);
+}

package/dist/Exception/MofhClientException.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MofhClientException = void 0;
+class MofhClientException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, new.target.prototype); // Restore prototype chain
+    }
+}
+exports.MofhClientException = MofhClientException;

package/dist/Exception/MofhClientHttpException.d.ts

@@ -0,0 +1,5 @@
+import { MofhClientException } from './MofhClientException';
+export declare class MofhClientHttpException extends MofhClientException {
+    originalError: any;
+    constructor(message: string, code?: number, previous?: any);
+}

package/dist/Exception/MofhClientHttpException.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MofhClientHttpException = void 0;
+const MofhClientException_1 = require("./MofhClientException");
+class MofhClientHttpException extends MofhClientException_1.MofhClientException {
+    constructor(message, code = 0, previous) {
+        super(message);
+        this.originalError = previous;
+    }
+}
+exports.MofhClientHttpException = MofhClientHttpException;

package/dist/Message/AbstractResponse.d.ts

@@ -0,0 +1,10 @@
+import { AxiosResponse } from 'axios';
+export declare abstract class AbstractResponse {
+    protected data: any;
+    protected response: AxiosResponse;
+    constructor(response: AxiosResponse);
+    protected abstract parseResponse(): void;
+    getData(): any;
+    abstract isSuccessful(): boolean;
+    abstract getMessage(): string | null;
+}

package/dist/Message/AbstractResponse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractResponse = void 0;
+class AbstractResponse {
+    constructor(response) {
+        this.response = response;
+        this.parseResponse();
+    }
+    getData() {
+        return this.data;
+    }
+}
+exports.AbstractResponse = AbstractResponse;

package/dist/Message/AvailabilityResponse.d.ts

@@ -0,0 +1,7 @@
+import { AbstractResponse } from './AbstractResponse';
+export declare class AvailabilityResponse extends AbstractResponse {
+    protected parseResponse(): void;
+    getMessage(): string | null;
+    isSuccessful(): boolean;
+    isAvailable(): boolean;
+}

package/dist/Message/AvailabilityResponse.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvailabilityResponse = void 0;
+const AbstractResponse_1 = require("./AbstractResponse");
+class AvailabilityResponse extends AbstractResponse_1.AbstractResponse {
+    parseResponse() {
+        // data should be string '0' or '1'
+        const data = this.response.data;
+        this.data = typeof data === 'string' ? data.trim() : String(data).trim();
+    }
+    getMessage() {
+        return this.isSuccessful() ? null : this.getData();
+    }
+    isSuccessful() {
+        return ['0', '1'].includes(this.data);
+    }
+    isAvailable() {
+        return this.data === '1';
+    }
+}
+exports.AvailabilityResponse = AvailabilityResponse;

package/dist/Message/ChangePackageResponse.d.ts

@@ -0,0 +1,3 @@
+import { XmlResponse } from './XmlResponse';
+export declare class ChangePackageResponse extends XmlResponse {
+}

package/dist/Message/ChangePackageResponse.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangePackageResponse = void 0;
+const XmlResponse_1 = require("./XmlResponse");
+class ChangePackageResponse extends XmlResponse_1.XmlResponse {
+}
+exports.ChangePackageResponse = ChangePackageResponse;

package/dist/Message/CreateAccountResponse.d.ts

@@ -0,0 +1,4 @@
+import { XmlResponse } from './XmlResponse';
+export declare class CreateAccountResponse extends XmlResponse {
+    getVpUsername(): string | null;
+}

package/dist/Message/CreateAccountResponse.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAccountResponse = void 0;
+const XmlResponse_1 = require("./XmlResponse");
+class CreateAccountResponse extends XmlResponse_1.XmlResponse {
+    getVpUsername() {
+        const data = this.getData();
+        if (data && data.result && data.result.options && data.result.options.vpusername) {
+            return String(data.result.options.vpusername);
+        }
+        return null;
+    }
+}
+exports.CreateAccountResponse = CreateAccountResponse;

package/dist/Message/CreateTicketResponse.d.ts

@@ -0,0 +1,7 @@
+import { AbstractResponse } from './AbstractResponse';
+export declare class CreateTicketResponse extends AbstractResponse {
+    protected parseResponse(): void;
+    isSuccessful(): boolean;
+    getMessage(): string | null;
+    getTicketId(): string | null;
+}

package/dist/Message/CreateTicketResponse.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTicketResponse = void 0;
+const AbstractResponse_1 = require("./AbstractResponse");
+class CreateTicketResponse extends AbstractResponse_1.AbstractResponse {
+    parseResponse() {
+        this.data = String(this.response.data);
+    }
+    isSuccessful() {
+        return String(this.data).includes('SUCCESS');
+    }
+    getMessage() {
+        return this.isSuccessful() ? null : String(this.getData());
+    }
+    getTicketId() {
+        if (this.isSuccessful()) {
+            const dataStr = String(this.data);
+            const successPart = dataStr.substring(dataStr.indexOf('SUCCESS'));
+            const parts = successPart.split(':');
+            return parts[1] ? parts[1].trim() : null;
+        }
+        else {
+            return null;
+        }
+    }
+}
+exports.CreateTicketResponse = CreateTicketResponse;

package/dist/Message/GetCnameResponse.d.ts

@@ -0,0 +1,7 @@
+import { AbstractResponse } from './AbstractResponse';
+export declare class GetCnameResponse extends AbstractResponse {
+    protected parseResponse(): void;
+    isSuccessful(): boolean;
+    getMessage(): string | null;
+    getCname(): string | null;
+}

package/dist/Message/GetCnameResponse.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCnameResponse = void 0;
+const AbstractResponse_1 = require("./AbstractResponse");
+class GetCnameResponse extends AbstractResponse_1.AbstractResponse {
+    parseResponse() {
+        this.data = String(this.response.data);
+    }
+    isSuccessful() {
+        return String(this.data).indexOf('ERROR') !== 0;
+    }
+    getMessage() {
+        return this.isSuccessful() ? null : this.getData();
+    }
+    getCname() {
+        return this.isSuccessful() ? this.getData() : null;
+    }
+}
+exports.GetCnameResponse = GetCnameResponse;

package/dist/Message/GetDomainUserResponse.d.ts

@@ -0,0 +1,8 @@
+import { PlainResponse } from './PlainResponse';
+export declare class GetDomainUserResponse extends PlainResponse {
+    isFound(): boolean;
+    getDomain(): string | undefined;
+    getStatus(): string | undefined;
+    getDocumentRoot(): string | undefined;
+    getUsername(): string | undefined;
+}

package/dist/Message/GetDomainUserResponse.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetDomainUserResponse = void 0;
+const PlainResponse_1 = require("./PlainResponse");
+class GetDomainUserResponse extends PlainResponse_1.PlainResponse {
+    isFound() {
+        return Array.isArray(this.data) && this.data.length > 0;
+    }
+    getDomain() {
+        return this.domain;
+    }
+    getStatus() {
+        return this.status;
+    }
+    getDocumentRoot() {
+        return this.documentRoot;
+    }
+    getUsername() {
+        return this.username;
+    }
+}
+exports.GetDomainUserResponse = GetDomainUserResponse;

package/dist/Message/GetUserDomainsResponse.d.ts

@@ -0,0 +1,8 @@
+import { AbstractResponse } from './AbstractResponse';
+export declare class GetUserDomainsResponse extends AbstractResponse {
+    protected parseResponse(): void;
+    getMessage(): string | null;
+    isSuccessful(): boolean;
+    getDomains(): string[];
+    getStatus(): string | null;
+}

package/dist/Message/GetUserDomainsResponse.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUserDomainsResponse = void 0;
+const AbstractResponse_1 = require("./AbstractResponse");
+const MismatchedStatusesException_1 = require("../Exception/MismatchedStatusesException");
+class GetUserDomainsResponse extends AbstractResponse_1.AbstractResponse {
+    parseResponse() {
+        const responseBody = typeof this.response.data === 'string' ? this.response.data : JSON.stringify(this.response.data);
+        if (responseBody.startsWith('[')) {
+            try {
+                this.data = JSON.parse(responseBody);
+            }
+            catch (e) {
+                this.data = responseBody.trim();
+            }
+        }
+        else if (responseBody === 'null') {
+            this.data = [];
+        }
+        else {
+            this.data = responseBody.trim();
+        }
+    }
+    getMessage() {
+        return this.isSuccessful() ? null : String(this.getData());
+    }
+    isSuccessful() {
+        return Array.isArray(this.data);
+    }
+    getDomains() {
+        if (!Array.isArray(this.data))
+            return [];
+        return this.data.map((item) => item[1]);
+    }
+    getStatus() {
+        if (Array.isArray(this.data) && this.data.length > 0) {
+            const statuses = [...new Set(this.data.map((item) => item[0]))];
+            if (statuses.length === 1) {
+                return String(statuses[0]);
+            }
+            else if (statuses.length > 1) {
+                throw new MismatchedStatusesException_1.MismatchedStatusesException('The account domains have different statuses: ' + statuses.join(', '));
+            }
+            else {
+                return null;
+            }
+        }
+        return null;
+    }
+}
+exports.GetUserDomainsResponse = GetUserDomainsResponse;

package/dist/Message/JsonResponse.d.ts

@@ -0,0 +1,6 @@
+import { AbstractResponse } from './AbstractResponse';
+export declare abstract class JsonResponse extends AbstractResponse {
+    protected parseResponse(): void;
+    getMessage(): string | null;
+    isSuccessful(): boolean;
+}

package/dist/Message/JsonResponse.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonResponse = void 0;
+const AbstractResponse_1 = require("./AbstractResponse");
+class JsonResponse extends AbstractResponse_1.AbstractResponse {
+    parseResponse() {
+        const data = this.response.data;
+        // Axios handles JSON parsing automatically if content-type is json
+        if (typeof data === 'object') {
+            this.data = data;
+        }
+        else {
+            try {
+                this.data = JSON.parse(data);
+            }
+            catch (e) {
+                this.data = typeof data === 'string' ? data.trim() : data;
+            }
+        }
+    }
+    getMessage() {
+        if (this.isSuccessful()) {
+            return null;
+        }
+        else if (this.getData() && this.getData().cpanelresult && this.getData().cpanelresult.error) {
+            return String(this.getData().cpanelresult.error).trim();
+        }
+        else {
+            return typeof this.response.data === 'string' ? this.response.data.trim() : JSON.stringify(this.response.data);
+        }
+    }
+    isSuccessful() {
+        if (this.getData()) {
+            return !(this.getData().cpanelresult && this.getData().cpanelresult.error);
+        }
+        else {
+            return false;
+        }
+    }
+}
+exports.JsonResponse = JsonResponse;

package/dist/Message/ListPackagesResponse.d.ts

@@ -0,0 +1,4 @@
+import { JsonResponse } from './JsonResponse';
+export declare class ListPackagesResponse extends JsonResponse {
+    getPackages(): string[] | null;
+}

package/dist/Message/ListPackagesResponse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListPackagesResponse = void 0;
+const JsonResponse_1 = require("./JsonResponse");
+class ListPackagesResponse extends JsonResponse_1.JsonResponse {
+    getPackages() {
+        if (this.isSuccessful() && this.getData() && this.getData().packages) {
+            return this.getData().packages;
+        }
+        return null;
+    }
+}
+exports.ListPackagesResponse = ListPackagesResponse;

package/dist/Message/PasswordResponse.d.ts

@@ -0,0 +1,9 @@
+import { XmlResponse } from './XmlResponse';
+export declare class PasswordResponse extends XmlResponse {
+    protected status: string | undefined;
+    protected message: string | undefined;
+    protected parseResponse(): void;
+    getMessage(): string | null;
+    isSuccessful(): boolean;
+    getStatus(): string | null;
+}

package/dist/Message/PasswordResponse.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordResponse = void 0;
+const XmlResponse_1 = require("./XmlResponse");
+class PasswordResponse extends XmlResponse_1.XmlResponse {
+    parseResponse() {
+        super.parseResponse();
+        const data = this.getData();
+        if (data && data.passwd && typeof data.passwd.status !== 'undefined') {
+            if (data.passwd.status == '1') {
+                this.status = 'a';
+            }
+            else if (data.passwd.statusmsg && String(data.passwd.statusmsg).includes('error occured changing this password')) {
+                // Idempotent success
+                this.status = 'a';
+            }
+            else {
+                this.message = String(data.passwd.statusmsg).trim();
+                const match = this.message.match(/the account must be active to change the password\s*\(([^)]+)\)/i);
+                if (match) {
+                    this.status = match[1];
+                }
+            }
+        }
+        else {
+            this.message = typeof this.response.data === 'string' ? this.response.data.trim() : JSON.stringify(this.response.data);
+        }
+    }
+    getMessage() {
+        return this.message || null;
+    }
+    isSuccessful() {
+        return this.status === 'a';
+    }
+    getStatus() {
+        return this.status || null;
+    }
+}
+exports.PasswordResponse = PasswordResponse;

package/dist/Message/PlainResponse.d.ts

@@ -0,0 +1,10 @@
+import { AbstractResponse } from './AbstractResponse';
+export declare abstract class PlainResponse extends AbstractResponse {
+    protected status: string | undefined;
+    protected domain: string | undefined;
+    protected documentRoot: string | undefined;
+    protected username: string | undefined;
+    protected parseResponse(): void;
+    getMessage(): string | null;
+    isSuccessful(): boolean;
+}

package/dist/Message/PlainResponse.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlainResponse = void 0;
+const AbstractResponse_1 = require("./AbstractResponse");
+class PlainResponse extends AbstractResponse_1.AbstractResponse {
+    parseResponse() {
+        const responseBody = typeof this.response.data === 'string' ? this.response.data : JSON.stringify(this.response.data);
+        if (responseBody.startsWith('[')) {
+            try {
+                this.data = JSON.parse(responseBody);
+                if (Array.isArray(this.data) && this.data.length === 4) {
+                    [this.status, this.domain, this.documentRoot, this.username] = this.data;
+                }
+            }
+            catch (e) {
+                this.data = responseBody.trim();
+            }
+        }
+        else if (responseBody === 'null') {
+            this.data = [];
+        }
+        else {
+            this.data = responseBody.trim();
+        }
+    }
+    getMessage() {
+        return this.isSuccessful() ? null : String(this.getData());
+    }
+    isSuccessful() {
+        return Array.isArray(this.data);
+    }
+}
+exports.PlainResponse = PlainResponse;

package/dist/Message/RemoveAccountResponse.d.ts

@@ -0,0 +1,3 @@
+import { XmlResponse } from './XmlResponse';
+export declare class RemoveAccountResponse extends XmlResponse {
+}

package/dist/Message/RemoveAccountResponse.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveAccountResponse = void 0;
+const XmlResponse_1 = require("./XmlResponse");
+class RemoveAccountResponse extends XmlResponse_1.XmlResponse {
+}
+exports.RemoveAccountResponse = RemoveAccountResponse;

package/dist/Message/ReplyTicketResponse.d.ts

@@ -0,0 +1,6 @@
+import { AbstractResponse } from './AbstractResponse';
+export declare class ReplyTicketResponse extends AbstractResponse {
+    protected parseResponse(): void;
+    isSuccessful(): boolean;
+    getMessage(): string | null;
+}

package/dist/Message/ReplyTicketResponse.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplyTicketResponse = void 0;
+const AbstractResponse_1 = require("./AbstractResponse");
+class ReplyTicketResponse extends AbstractResponse_1.AbstractResponse {
+    parseResponse() {
+        this.data = String(this.response.data);
+    }
+    isSuccessful() {
+        return String(this.getData()).includes('SUCCESS');
+    }
+    getMessage() {
+        return this.isSuccessful() ? null : String(this.getData());
+    }
+}
+exports.ReplyTicketResponse = ReplyTicketResponse;

package/dist/Message/SuspendResponse.d.ts

@@ -0,0 +1,10 @@
+import { XmlResponse } from './XmlResponse';
+export declare class SuspendResponse extends XmlResponse {
+    protected username: string | undefined;
+    protected status: string | undefined;
+    protected reason: string | undefined;
+    protected parseResponse(): void;
+    getStatus(): string | null;
+    getVpUsername(): string | null;
+    getReason(): string | null;
+}

package/dist/Message/SuspendResponse.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuspendResponse = void 0;
+const XmlResponse_1 = require("./XmlResponse");
+class SuspendResponse extends XmlResponse_1.XmlResponse {
+    parseResponse() {
+        super.parseResponse();
+        if (!this.isSuccessful()) {
+            const message = this.getMessage();
+            if (message) {
+                const match = message.match(/This account is not active so can not be suspended  \( vPuser : (\S+) ,  status : (\S+) , reason : (.*) \) ../s);
+                if (match) {
+                    this.username = match[1].trim();
+                    this.status = match[2].trim();
+                    this.reason = match[3].trim();
+                }
+            }
+        }
+    }
+    getStatus() {
+        return this.status || null;
+    }
+    getVpUsername() {
+        return this.username || null;
+    }
+    getReason() {
+        return this.reason || null;
+    }
+}
+exports.SuspendResponse = SuspendResponse;

package/dist/Message/UnsuspendResponse.d.ts

@@ -0,0 +1,6 @@
+import { XmlResponse } from './XmlResponse';
+export declare class UnsuspendResponse extends XmlResponse {
+    protected status: string | undefined;
+    protected parseResponse(): void;
+    getStatus(): string | null;
+}

package/dist/Message/UnsuspendResponse.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsuspendResponse = void 0;
+const XmlResponse_1 = require("./XmlResponse");
+class UnsuspendResponse extends XmlResponse_1.XmlResponse {
+    parseResponse() {
+        super.parseResponse();
+        if (!this.isSuccessful()) {
+            const message = this.getMessage();
+            if (message) {
+                const match = message.match(/account is NOT currently suspended \(status : (\w*) \)/);
+                if (match) {
+                    const status = match[1].trim();
+                    this.status = status === '' ? 'd' : status;
+                }
+            }
+        }
+    }
+    getStatus() {
+        return this.status || null;
+    }
+}
+exports.UnsuspendResponse = UnsuspendResponse;

package/dist/Message/XmlResponse.d.ts

@@ -0,0 +1,6 @@
+import { AbstractResponse } from './AbstractResponse';
+export declare abstract class XmlResponse extends AbstractResponse {
+    protected parseResponse(): void;
+    getMessage(): string | null;
+    isSuccessful(): boolean;
+}

package/dist/Message/XmlResponse.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmlResponse = void 0;
+const AbstractResponse_1 = require("./AbstractResponse");
+const fast_xml_parser_1 = require("fast-xml-parser");
+class XmlResponse extends AbstractResponse_1.AbstractResponse {
+    parseResponse() {
+        const data = this.response.data;
+        const parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_"
+        });
+        try {
+            // Axios might automatically parse JSON, but for XML it returns string usually.
+            const xmlString = typeof data === 'string' ? data : String(data);
+            // simplexml_load_string logic roughly translated
+            const xmlData = parser.parse(xmlString);
+            this.data = xmlData;
+        }
+        catch (e) {
+            this.data = typeof data === 'string' ? data.trim() : data;
+        }
+    }
+    getMessage() {
+        if (this.isSuccessful()) {
+            return null;
+        }
+        else if (this.getData() && this.getData().result && this.getData().result.statusmsg) {
+            return String(this.getData().result.statusmsg).trim();
+        }
+        else {
+            return typeof this.response.data === 'string' ? this.response.data.trim() : JSON.stringify(this.response.data);
+        }
+    }
+    isSuccessful() {
+        if (this.getData() && this.getData().result && this.getData().result.status) {
+            return this.getData().result.status == 1;
+        }
+        else {
+            return false;
+        }
+    }
+}
+exports.XmlResponse = XmlResponse;

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export * from './Exception/MofhClientException';
+export * from './Exception/MofhClientHttpException';
+export * from './Exception/MismatchedStatusesException';
+export * from './Message/AbstractResponse';
+export * from './Message/XmlResponse';
+export * from './Message/JsonResponse';
+export * from './Message/PlainResponse';
+export * from './Message/AvailabilityResponse';
+export * from './Message/ChangePackageResponse';
+export * from './Message/CreateAccountResponse';
+export * from './Message/CreateTicketResponse';
+export * from './Message/GetCnameResponse';
+export * from './Message/GetDomainUserResponse';
+export * from './Message/GetUserDomainsResponse';
+export * from './Message/ListPackagesResponse';
+export * from './Message/PasswordResponse';
+export * from './Message/RemoveAccountResponse';
+export * from './Message/ReplyTicketResponse';
+export * from './Message/SuspendResponse';
+export * from './Message/UnsuspendResponse';
+export * from './Client';

package/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Exception/MofhClientException"), exports);
+__exportStar(require("./Exception/MofhClientHttpException"), exports);
+__exportStar(require("./Exception/MismatchedStatusesException"), exports);
+__exportStar(require("./Message/AbstractResponse"), exports);
+__exportStar(require("./Message/XmlResponse"), exports);
+__exportStar(require("./Message/JsonResponse"), exports);
+__exportStar(require("./Message/PlainResponse"), exports);
+__exportStar(require("./Message/AvailabilityResponse"), exports);
+__exportStar(require("./Message/ChangePackageResponse"), exports);
+__exportStar(require("./Message/CreateAccountResponse"), exports);
+__exportStar(require("./Message/CreateTicketResponse"), exports);
+__exportStar(require("./Message/GetCnameResponse"), exports);
+__exportStar(require("./Message/GetDomainUserResponse"), exports);
+__exportStar(require("./Message/GetUserDomainsResponse"), exports);
+__exportStar(require("./Message/ListPackagesResponse"), exports);
+__exportStar(require("./Message/PasswordResponse"), exports);
+__exportStar(require("./Message/RemoveAccountResponse"), exports);
+__exportStar(require("./Message/ReplyTicketResponse"), exports);
+__exportStar(require("./Message/SuspendResponse"), exports);
+__exportStar(require("./Message/UnsuspendResponse"), exports);
+__exportStar(require("./Client"), exports);

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "mofh-client-ts",
+    "version": "1.0.0",
+    "description": "TypeScript MOFH Client",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "keywords": [
+        "mofh",
+        "myownfreehost",
+        "client",
+        "api",
+        "typescript"
+    ],
+    "author": "Mehtab Hassan",
+    "license": "MIT",
+    "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "prepublishOnly": "npm run build"
+    },
+    "dependencies": {
+        "axios": "^1.6.0",
+        "fast-xml-parser": "^4.3.0"
+    },
+    "devDependencies": {
+        "@types/jest": "^30.0.0",
+        "@types/node": "^20.19.33",
+        "jest": "^30.2.0",
+        "ts-jest": "^29.4.6",
+        "typescript": "^5.0.0"
+    }
+}