meta-cloud-api 0.0.1-beta.0 → 0.0.2

package/src/api/template.ts

@@ -0,0 +1,70 @@
+import { objectToQueryString } from 'src/utils/objectToQueryString';
+import type { WabaConfigType } from '../types/config';
+import { HttpMethodsEnum, WabaConfigEnum } from '../types/enums';
+import type { RequesterClass, RequesterResponseInterface, ResponsePagination, ResponseSuccess } from '../types/request';
+import type {
+    TemplateClass,
+    TemplateDeleteParams,
+    TemplateGetParams,
+    TemplateRequestBody,
+    TemplateResponse,
+} from '../types/template';
+import BaseAPI from './base';
+
+export default class TemplateApi extends BaseAPI implements TemplateClass {
+    private readonly endpoint = 'message_templates';
+
+    constructor(config: WabaConfigType, client: RequesterClass) {
+        super(config, client);
+    }
+
+    async getTemplate(templateId: string): Promise<RequesterResponseInterface<TemplateResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `${templateId}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async updateTemplate(
+        templateId: string,
+        template: Partial<TemplateRequestBody>,
+    ): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${templateId}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify(template),
+        );
+    }
+
+    async getTemplates(
+        params: TemplateGetParams,
+    ): Promise<RequesterResponseInterface<ResponsePagination<TemplateResponse>>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `${this.config[WabaConfigEnum.BusinessAcctId]}/${this.endpoint}${objectToQueryString(params)}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async createTemplate(template: TemplateRequestBody): Promise<RequesterResponseInterface<TemplateResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.BusinessAcctId]}/${this.endpoint}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify(template),
+        );
+    }
+
+    async deleteTemplate(params: TemplateDeleteParams): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Delete,
+            `${this.config[WabaConfigEnum.BusinessAcctId]}/${this.endpoint}${objectToQueryString(params)}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+}

package/src/api/twoStepVerification.ts

@@ -0,0 +1,24 @@
+import { TwoStepVerificationClass } from '../types/twoStepVerification';
+import type { WabaConfigType } from '../types/config';
+import { HttpMethodsEnum, WabaConfigEnum } from '../types/enums';
+import type { RequesterClass, RequesterResponseInterface, ResponseSuccess } from '../types/request';
+import BaseAPI from './base';
+
+export default class TwoStepVerificationAPI extends BaseAPI implements TwoStepVerificationClass {
+    constructor(config: WabaConfigType, client: RequesterClass) {
+        super(config, client);
+    }
+
+    async setTwoStepVerificationCode(pin: string): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        const body = {
+            pin,
+        };
+
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify(body),
+        );
+    }
+}

package/src/api/waba.ts

@@ -0,0 +1,55 @@
+import { HttpMethodsEnum, WabaConfigEnum } from '../types/enums';
+import type { WabaConfigType } from '../types/config';
+import type { RequesterClass, RequesterResponseInterface, ResponseSuccess } from '../types/request';
+import BaseAPI from './base';
+import { WABAClass, WabaSubscriptions } from '../types/waba';
+
+export default class WabaAPI extends BaseAPI implements WABAClass {
+    constructor(config: WabaConfigType, client: RequesterClass) {
+        super(config, client);
+    }
+
+    async getAllWabaSubscriptions(): Promise<RequesterResponseInterface<WabaSubscriptions>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `${this.config[WabaConfigEnum.BusinessAcctId]}/subscribed_apps`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async subscribeToWaba(): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.BusinessAcctId]}/subscribed_apps`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async unsubscribeFromWaba(): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Delete,
+            `${this.config[WabaConfigEnum.BusinessAcctId]}/subscribed_apps`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async overrideWabaWebhook(
+        webhookUrl: string,
+        verifyToken: string,
+    ): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        const body = {
+            url: webhookUrl,
+            verify_token: verifyToken,
+        };
+
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.BusinessAcctId]}/webhooks`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify(body),
+        );
+    }
+}

package/src/httpsClient.ts

@@ -0,0 +1,83 @@
+import { Agent } from 'https';
+
+import Logger from './utils/logger';
+import { HttpMethodsEnum } from './types/enums';
+import { HttpsClientClass, HttpsClientResponseClass, ResponseHeaders, ResponseJSONBody } from './types/httpsClient';
+
+const LIB_NAME = 'HttpsClient';
+const LOG_LOCAL = false;
+const LOGGER = new Logger(LIB_NAME, process.env.DEBUG === 'true' || LOG_LOCAL);
+
+export default class HttpsClient implements HttpsClientClass {
+    agent: Agent;
+
+    constructor() {
+        this.agent = new Agent({ keepAlive: true });
+    }
+
+    clearSockets(): boolean {
+        this.agent.destroy();
+        return true;
+    }
+
+    async sendRequest(
+        hostname: string,
+        path: string,
+        method: HttpMethodsEnum,
+        headers: HeadersInit,
+        timeout: number,
+        body?: BodyInit | null,
+    ): Promise<HttpsClientResponseClass> {
+        const url = `https://${hostname}/${path}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                body,
+                signal: controller.signal,
+            });
+            LOGGER.log(`${method} : ${url} - ${JSON.stringify(response)}`);
+
+            clearTimeout(timeoutId);
+            return new HttpsClientResponse(response);
+        } catch (error) {
+            throw error;
+        }
+    }
+}
+
+export class HttpsClientResponse implements HttpsClientResponseClass {
+    res: Response;
+    respStatusCode: number;
+    respHeaders: ResponseHeaders;
+
+    constructor(resp: Response) {
+        this.res = resp;
+        this.respStatusCode = resp.status;
+        this.respHeaders = Object.fromEntries(resp.headers.entries());
+    }
+
+    statusCode(): number {
+        return this.respStatusCode;
+    }
+
+    headers(): ResponseHeaders {
+        return this.respHeaders;
+    }
+
+    rawResponse(): Response {
+        return this.res;
+    }
+
+    async json(): Promise<ResponseJSONBody> {
+        try {
+            return (await this.res.json()) as ResponseJSONBody;
+        } catch (err) {
+            // TODO Error Handling
+            throw new Error('Failed to parse response body to JSON: ' + (err as Error).message);
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import WhatsApp from './whatsapp';
+
+export default WhatsApp;

package/src/request.ts

@@ -0,0 +1,104 @@
+import HttpsClient from './httpsClient';
+import Logger from './utils/logger';
+import type { HttpMethodsEnum } from './types/enums';
+import type { RequesterClass } from './types/request';
+import { MetaError } from './utils/isMetaError';
+import { isMetaError } from './utils/isMetaError';
+
+const LIB_NAME = 'REQUESTER';
+const LOG_LOCAL = false;
+const LOGGER = new Logger(LIB_NAME, process.env.DEBUG === 'true' || LOG_LOCAL);
+
+export default class Requester implements RequesterClass {
+    client: Readonly<HttpsClient>;
+    accessToken: Readonly<string>;
+    phoneNumberId: Readonly<number>;
+    businessAcctId: Readonly<string>;
+    apiVersion: Readonly<string>;
+    userAgent: Readonly<string>;
+    host: Readonly<string>;
+    protocol: Readonly<string> = 'https:';
+
+    constructor(
+        host: string,
+        apiVersion: string,
+        phoneNumberId: number,
+        accessToken: string,
+        businessAcctId: string,
+        userAgent: string,
+    ) {
+        this.client = new HttpsClient();
+        this.host = host;
+        this.apiVersion = apiVersion;
+        this.phoneNumberId = phoneNumberId;
+        this.accessToken = accessToken;
+        this.businessAcctId = businessAcctId;
+        this.userAgent = userAgent;
+    }
+
+    buildHeader(contentType: string): HeadersInit {
+        const headers: HeadersInit = {
+            'Content-Type': contentType,
+            Authorization: `Bearer ${this.accessToken}`,
+            'User-Agent': this.userAgent,
+        };
+        return headers;
+    }
+
+    buildCAPIPath(endpoint: string): string {
+        return `v${this.apiVersion}.0/${endpoint}`;
+    }
+
+    async sendRequest(method: HttpMethodsEnum, endpoint: string, timeout: number, body?: any) {
+        const contentType = 'application/json';
+        const path = `${this.protocol.toLowerCase()}//${this.host}/${this.buildCAPIPath(endpoint)}`;
+
+        LOGGER.log(`${method} : ${path}`);
+
+        try {
+            const response = await this.client.sendRequest(
+                this.host,
+                this.buildCAPIPath(endpoint),
+                method,
+                this.buildHeader(contentType),
+                timeout,
+                method === 'POST' || method === 'PUT' ? body : undefined,
+            );
+
+            if (!response.rawResponse().ok) {
+                const errorData = await response.json();
+                if (isMetaError(errorData)) {
+                    throw errorData;
+                }
+                // If the error doesn't match Meta's format, create a generic MetaError
+                throw {
+                    name: 'MetaError',
+                    message: 'Unknown error occurred',
+                    error: {
+                        message: errorData.message || 'Unknown error occurred',
+                        type: 'UnknownError',
+                        code: response.statusCode(),
+                        fbtrace_id: '',
+                    },
+                } as MetaError;
+            }
+
+            return response;
+        } catch (error) {
+            if (isMetaError(error)) {
+                throw error;
+            }
+            // Handle network errors or other unexpected errors
+            throw {
+                name: 'MetaError',
+                message: error instanceof Error ? error.message : 'Network error occurred',
+                error: {
+                    message: error instanceof Error ? error.message : 'Network error occurred',
+                    type: 'NetworkError',
+                    code: 500,
+                    fbtrace_id: '',
+                },
+            } as MetaError;
+        }
+    }
+}

package/src/types/base.ts

@@ -0,0 +1,5 @@
+import type { WabaConfigType } from './config';
+
+export declare class BaseClass {
+    constructor(config: WabaConfigType);
+}

package/src/types/config.ts

@@ -0,0 +1,68 @@
+import { WabaConfigEnum } from './enums';
+
+export type WabaConfigType = {
+    /**
+     * That base URL of the Cloud API, hosted by Meta.
+     * @default 'graph.facebook.com/'
+     */
+    [WabaConfigEnum.BaseURL]: string;
+
+    /**
+     * The Meta for Developers business application Id for this registered application.
+     */
+    [WabaConfigEnum.AppId]: string;
+
+    /**
+     * The Meta for Developers business application secret for this registered application.
+     */
+    [WabaConfigEnum.AppSecret]: string;
+
+    /**
+     * The Meta for Developers phone number id used by the registered business.
+     */
+    [WabaConfigEnum.PhoneNumberId]: number;
+
+    /**
+     * The Meta for Developers business id for the registered business.
+     */
+    [WabaConfigEnum.BusinessAcctId]: string;
+    /**
+     * The version of the Cloud API being used. Starts with a "v" and follows the major number.
+     */
+    [WabaConfigEnum.APIVersion]: string;
+
+    /**
+     * The access token to make calls on behalf of the signed in Meta for Developers account or business.
+     */
+    [WabaConfigEnum.AccessToken]: string;
+
+    /**
+     * The endpoint path (e.g. if the value here is webhook, the webhook URL would look like http/https://{host}/webhook).
+     */
+    [WabaConfigEnum.WebhookEndpoint]: string;
+
+    /**
+     * The verification token that needs to match what is sent by the Cloud API webhook in order to subscribe.
+     */
+    [WabaConfigEnum.WebhookVerificationToken]: string;
+
+    /**
+     * The listener port for the webhook web server.
+     */
+    [WabaConfigEnum.ListenerPort]: number;
+
+    /**
+     * To turn on global debugging of the logger to print verbose output across the APIs.
+     */
+    [WabaConfigEnum.Debug]: boolean;
+
+    /**
+     * The total number of times a request should be retried after the wait period if it fails.
+     */
+    [WabaConfigEnum.MaxRetriesAfterWait]: number;
+
+    /**
+     * The timeout period for a request to quit and destroy the attempt in ms.
+     */
+    [WabaConfigEnum.RequestTimeout]: number;
+};

package/src/types/encryption.ts

@@ -0,0 +1,11 @@
+import { ResponseData, ResponseSuccess, RequesterResponseInterface } from './request';
+
+export type EncryptionPublicKeyResponse = ResponseData<{
+    business_public_key: string;
+    business_public_key_signature_status: 'VALID' | 'MISMATCH';
+}>;
+
+export interface EncryptionClass {
+    getEncryptionPublicKey(): Promise<RequesterResponseInterface<EncryptionPublicKeyResponse>>;
+    setEncryptionPublicKey(businessPublicKey: string): Promise<RequesterResponseInterface<ResponseSuccess>>;
+}