@spreeloop/orange_money 1.0.0

package/src/disbursements/implementations/src/live.ts

@@ -0,0 +1,79 @@
+import {
+  TransferRequest,
+  TransferResponse,
+  transfer,
+} from '../../operations/transfer';
+import {
+  CreateAccessTokenResponse,
+  createAccessToken,
+} from '../../operations/create_access_token';
+import { Routes } from '../../routes/routes';
+import {
+  DisbursementInterface,
+  DisbursementServiceConfig,
+} from '../disbursement_service';
+import {
+  GetTransferStatusRequest,
+  GetTransferStatusResponse,
+  getTransferStatus,
+} from '../../operations/get_transfer_status';
+
+/**
+ * Orange Money API Live Disbursement.
+ * @class
+ */
+export class DisbursementLive implements DisbursementInterface {
+  protected readonly config: DisbursementServiceConfig;
+  protected readonly routes: Routes;
+  /**
+   * Constructs a new {Disbursement}.
+   * @constructor
+   * @param {DisbursementServiceConfig} config - The required global route configuration.
+   */
+  constructor(config: DisbursementServiceConfig) {
+    this.routes = new Routes();
+    this.config = config;
+  }
+
+  /**
+   * Creates an access token.
+   *
+   * @return {Promise<CreateAccessTokenResponse>} The method response containing a string and a token.
+   */
+  async createAccessToken(): Promise<CreateAccessTokenResponse> {
+    return await createAccessToken({
+      configs: this.config,
+      endPoint: this.routes.createAccessToken(),
+    });
+  }
+
+  /**
+   * Transfers the specified amount of money from one account to another.
+   *
+   * @param {TransferRequest} params - The parameters for the transfer.
+   * @return {Promise<TransferResponse>} - The response from the transfer method.
+   */
+  async transfer(params: TransferRequest): Promise<TransferResponse> {
+    return await transfer({
+      configs: this.config,
+      params: params,
+      endPoint: this.routes.transfer(),
+    });
+  }
+
+  /**
+   * Retrieves the status of a transfer.
+   *
+   * @param {GetTransferStatusRequest} params - The parameters for retrieving the transfer status.
+   * @return {Promise<GetTransferStatusResponse>} - The method response containing the status and transfer status response.
+   */
+  async getTransferStatus(
+    params: GetTransferStatusRequest
+  ): Promise<GetTransferStatusResponse> {
+    return await getTransferStatus({
+      configs: this.config,
+      params: params,
+      endPoint: this.routes.transferStatus(params.messageId),
+    });
+  }
+}

package/src/disbursements/implementations/src/sandbox.ts

@@ -0,0 +1,124 @@
+import { TransferResponse } from '../../operations/transfer';
+import { CreateAccessTokenResponse } from '../../operations/create_access_token';
+import { Routes } from '../../routes/routes';
+import {
+  DisbursementInterface,
+  DisbursementServiceConfig,
+} from '../disbursement_service';
+import {
+  DisbursementStep,
+  GetTransferStatusResponse,
+} from '../../operations/get_transfer_status';
+import {
+  DisbursementApiRawStatus,
+  DisbursementStatus,
+} from '../../utils/status';
+
+/**
+ * Orange Money API Fake Disbursement.
+ * @class
+ */
+export class DisbursementFake implements DisbursementInterface {
+  protected readonly config: DisbursementServiceConfig;
+  protected readonly routes: Routes;
+  /**
+   * Constructs a new {Disbursement}.
+   * @constructor
+   * @param {DisbursementServiceConfig} config - The required global route configuration.
+   */
+  constructor(config: DisbursementServiceConfig) {
+    this.routes = new Routes();
+    this.config = config;
+  }
+
+  /**
+   * Creates an access token.
+   *
+   * @return {Promise<CreateAccessTokenResponse>} The method response containing a string and a token.
+   */
+  async createAccessToken(): Promise<CreateAccessTokenResponse> {
+    return {
+      data: 'accessToken',
+      raw: {
+        access_token: 'accessToken',
+        token_type: 'Bearer',
+        expires_in: '300',
+      },
+    };
+  }
+
+  /**
+   * Transfers the specified amount of money from one account to another.
+   *
+   * @param {TransferRequest} params - The parameters for the transfer.
+   * @return {Promise<TransferResponse>} - The response from the transfer method.
+   */
+  async transfer(): Promise<TransferResponse> {
+    return {
+      data: 'f7ec5a39-b1ad-4fa5-a734-60ab4217ba75',
+      raw: {
+        MD5OfMessageBody: '4b55cf6629b5f0ee3c8ac91435a2eb35',
+        MD5OfMessageAttributes: '50e3084aee2bf840dd63b6bbf0a62fa9',
+        MessageId: 'f7ec5a39-b1ad-4fa5-a734-60ab4217ba75',
+        ResponseMetadata: {
+          RequestId: 'bbb43d42-95d1-5a6b-92a7-60c0d420e103',
+          HTTPStatusCode: 200,
+          HTTPHeaders: {
+            'x-amzn-requestid': 'bbb43d42-95d1-5a6b-92a7-60c0d420e103',
+            'x-amzn-trace-id':
+              'Root=1-65083fb1-37fbf881380338ed3b5fcd2b;Parent=6bfc3c24556c9b27;Sampled=0;Lineage=79e6faf7:0',
+            date: 'Mon, 18 Sep 2023 12:16:49 GMT',
+            'content-type': 'text/xml',
+            'content-length': '459',
+          },
+          RetryAttempts: 0,
+        },
+      },
+    };
+  }
+
+  /**
+   * Retrieves the status of a transfer.
+   *
+   * @param {GetTransferStatusRequest} params - The parameters for retrieving the transfer status.
+   * @return {Promise<GetTransferStatusResponse>} - The method response containing the status and transfer status response.
+   */
+  async getTransferStatus(): Promise<GetTransferStatusResponse> {
+    return {
+      data: {
+        status: DisbursementStatus.succeeded,
+        refundStep: DisbursementStep.TransferSent,
+      },
+      raw: {
+        result: {
+          message: 'Cash in performed successfully',
+          data: {
+            subscriberMsisdn: 'subscriberMsisdn',
+            channelUserMsisdn: 'channelUserMsisdn',
+            createtime: '1695039280',
+            amount: 100,
+            payToken: 'C2C2309183CB702A1CBB39ECE32C',
+            txnid: 'PP230918.1314.B57973',
+            txnmode: 'refundYNote',
+            txnstatus: '00068',
+            orderId: 'refundYNote',
+            status: DisbursementApiRawStatus.succeeded,
+            description: 'Remboursement Fond',
+          },
+        },
+        parameters: {
+          amount: '100',
+          xauth: 'WU5PVEVIRUFEOllOT1RFSEVBRDIwMjA=',
+          channel_user_msisdn: 'channel_user_msisdn',
+          customer_key: 'customer_key',
+          customer_secret: 'customer_secret',
+          final_customer_name: 'Steve',
+          final_customer_phone: '692232239',
+        },
+        CreateAt: '09-18-2023 12:14:43',
+        MessageId: 'caee8310-02fa-45da-9b22-a1effcada25c',
+        RefundStep: DisbursementStep.TransferSent,
+      },
+    };
+  }
+}

package/src/disbursements/operations/create_access_token.spec.ts

@@ -0,0 +1,87 @@
+import { AxiosError, AxiosResponse } from 'axios';
+import { Logger } from '../../../../logging/src/logging';
+import * as requests from '../../utils/https';
+import { DisbursementXTargetEnvironmentType } from '../utils/constants';
+import { Token, createAccessToken } from './create_access_token';
+
+describe('createAccessToken', () => {
+  it('Should fail on invalid parameter', async () => {
+    const result = await createAccessToken({
+      endPoint: '',
+      configs: {
+        channelUserMsisdn: '',
+        clientId: '',
+        clientSecret: '',
+        customerKey: '',
+        customerSecret: '',
+        pin: '',
+        environment: DisbursementXTargetEnvironmentType.sandbox,
+        logger: new Logger(),
+      },
+    });
+    expect(result.data).toBeUndefined();
+  });
+
+  it('Should fail on request rejection', async () => {
+    const errorMessage = 'mock reject the request';
+    const postSpy = jest
+      .spyOn(requests, 'postRequest')
+      .mockImplementation()
+      .mockResolvedValue({ error: new AxiosError(errorMessage) });
+
+    const result = await createAccessToken({
+      endPoint: 'https://route.com/link',
+      configs: {
+        channelUserMsisdn: '237699947943',
+        clientId: 'clientId',
+        clientSecret: 'clientSecret',
+        customerKey: 'customerKey',
+        customerSecret: 'customerSecret',
+        pin: 'pin',
+        environment: DisbursementXTargetEnvironmentType.sandbox,
+        logger: new Logger(),
+      },
+    });
+
+    expect(postSpy).toHaveBeenCalledTimes(1);
+    expect(result.data).toBeUndefined();
+    expect(result.error).toBeDefined();
+    postSpy.mockRestore();
+  });
+
+  it('Should successfully retrieve token', async () => {
+    const accessToken = 'THEaCCESStOKEN';
+    const postSpy = jest
+      .spyOn(requests, 'postRequest')
+      .mockImplementation()
+      .mockResolvedValue({
+        response: <AxiosResponse<Token>>{
+          data: {
+            access_token: accessToken,
+          },
+        },
+      });
+
+    const result = await createAccessToken({
+      endPoint: 'https://route.com/link',
+      configs: {
+        channelUserMsisdn: '237699947943',
+        clientId: 'clientId',
+        clientSecret: 'clientSecret',
+        customerKey: 'customerKey',
+        customerSecret: 'customerSecret',
+        pin: 'pin',
+        environment: DisbursementXTargetEnvironmentType.sandbox,
+        logger: new Logger(),
+      },
+    });
+
+    expect(postSpy).toHaveBeenCalledTimes(1);
+    expect(result.error).toBeUndefined();
+    expect(result.raw).toEqual({
+      access_token: accessToken,
+    });
+    expect(result.data).toBe(accessToken);
+    postSpy.mockRestore();
+  });
+});

package/src/disbursements/operations/create_access_token.ts

@@ -0,0 +1,83 @@
+import {
+  RequestResponse,
+  encodeDataToXFormUrl,
+  hash,
+  postRequest,
+} from '../../utils/https';
+import { OperationResponse } from '../../utils/operation_response';
+import {
+  DisbursementServiceConfig,
+  DisbursementServiceConfigSchema,
+} from '../implementations/disbursement_service';
+
+export type Token = {
+  /**
+   * The requested token.
+   */
+  access_token: string;
+
+  scope?: string;
+
+  /**
+   * The type of the requested token.
+   */
+  token_type: string;
+
+  /** The time to live in seconds. */
+  expires_in: string;
+};
+
+export type CreateAccessTokenResponse = OperationResponse<string, Token>;
+
+/**
+ * Creates an access token.
+ *
+ * @param {CreateAccessTokenRequest} configs - The disbursement service config.
+ * @param {string} endPoint - The end point.
+ * @return {CreateAccessTokenResponse} The method response containing the access token and raw response.
+ */
+export async function createAccessToken({
+  configs,
+  endPoint,
+}: {
+  configs: DisbursementServiceConfig;
+  endPoint: string;
+}): Promise<CreateAccessTokenResponse> {
+  const logger = configs.logger;
+  logger.info('createAccessToken is running ...');
+  const { error: configsValidationError, value: configValues } =
+    DisbursementServiceConfigSchema.validate(configs);
+
+  if (configsValidationError) {
+    logger.error(
+      `Invalid DisbursementServiceConfig request parameters. params : ${JSON.stringify(
+        configsValidationError.details
+      )}`
+    );
+    return { error: configsValidationError.details };
+  }
+  const authorization = hash(configValues.clientId, configValues.clientSecret);
+  const headers = {
+    'Content-Type': 'application/x-www-form-urlencoded',
+    Authorization: `Basic ${authorization}`,
+  };
+  const body = encodeDataToXFormUrl({
+    grant_type: 'client_credentials',
+  });
+  const response: RequestResponse<Token> = await postRequest<Token>({
+    logger: logger,
+    route: endPoint,
+    data: body,
+    headers: headers,
+    rejectUnauthorized: false,
+  });
+
+  if (!response.response) {
+    return { error: response.error };
+  }
+
+  return {
+    data: response.response.data.access_token,
+    raw: response.response.data,
+  };
+}

package/src/disbursements/operations/get_transfer_status.spec.ts

@@ -0,0 +1,132 @@
+import { AxiosResponse } from 'axios';
+import { Logger } from '../../../../logging/src/logging';
+import * as requests from '../../utils/https';
+import { DisbursementXTargetEnvironmentType } from '../utils/constants';
+import { DisbursementApiRawStatus, DisbursementStatus } from '../utils/status';
+import { DisbursementStep, getTransferStatus } from './get_transfer_status';
+
+describe('getTransferStatus', () => {
+  it('should fail on invalid parameter provided', async () => {
+    const { error, data, raw } = await getTransferStatus({
+      configs: {
+        channelUserMsisdn: '',
+        clientId: '',
+        clientSecret: '',
+        customerKey: '',
+        customerSecret: '',
+        pin: '',
+        environment: DisbursementXTargetEnvironmentType.sandbox,
+        logger: new Logger(),
+      },
+      params: {
+        token: 55 as unknown as string,
+        messageId: 'messageId',
+      },
+      endPoint: 'https://example.com',
+    });
+
+    expect(data).not.toBeDefined();
+    expect(raw).not.toBeDefined();
+    expect(error).toBeDefined();
+  });
+  it('should fail on request failure', async () => {
+    const requestSpy = jest
+      .spyOn(requests, 'getRequest')
+      .mockImplementation()
+      .mockResolvedValue({
+        error: {},
+      });
+    const { error, data, raw } = await getTransferStatus({
+      configs: {
+        channelUserMsisdn: '237699947943',
+        clientId: 'clientId',
+        clientSecret: 'clientSecret',
+        customerKey: 'customerKey',
+        customerSecret: 'customerSecret',
+        pin: 'pin',
+        environment: DisbursementXTargetEnvironmentType.sandbox,
+        logger: new Logger(),
+      },
+      params: {
+        token: 'token',
+        messageId: 'messageId',
+      },
+      endPoint: 'https://example.com',
+    });
+
+    expect(data).not.toBeDefined();
+    expect(raw).not.toBeDefined();
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(error).toBeDefined();
+  });
+  it('should succeed on request succeed', async () => {
+    const succeedEg = {
+      result: {
+        message: 'message',
+        data: {
+          createtime: 'createtime',
+          subscriberMsisdn: 'subscriberMsisdn',
+          amount: 500,
+          payToken: 'payToken',
+          txnid: 'txnid',
+          txnmode: 'txnmode',
+          txnstatus: 'txnstatus',
+          orderId: 'orderId',
+          status: DisbursementApiRawStatus.succeeded,
+          channelUserMsisdn: 'channelUserMsisdn',
+          description: 'description',
+        },
+      },
+      parameters: {
+        amount: 500,
+        xauth: 'xauth',
+        channel_user_msisdn: 'channel_user_msisdn',
+        customer_key: 'customer_key',
+        customer_secret: 'customer_secret',
+        final_customer_name: 'final_customer_name',
+        final_customer_phone: 'final_customer_phone',
+      },
+      CreateAt: 'CreateAt',
+      MessageId: 'MessageId',
+      RefundStep: DisbursementStep.TransferSent,
+    };
+    const requestSpy = jest
+      .spyOn(requests, 'getRequest')
+      .mockImplementation()
+      .mockResolvedValue({
+        response: { data: Object(succeedEg) } as AxiosResponse<
+          unknown,
+          unknown
+        >,
+      });
+    const { error, data, raw } = await getTransferStatus({
+      configs: {
+        channelUserMsisdn: '237699947943',
+        clientId: 'clientId',
+        clientSecret: 'clientSecret',
+        customerKey: 'customerKey',
+        customerSecret: 'customerSecret',
+        pin: 'pin',
+        environment: DisbursementXTargetEnvironmentType.sandbox,
+        logger: new Logger(),
+      },
+      params: {
+        token: 'token',
+        messageId: 'messageId',
+      },
+      endPoint: 'https://example.com',
+    });
+
+    expect(error).not.toBeDefined();
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(raw).toEqual(succeedEg);
+    expect(
+      (raw as { parameters?: { customer_secret?: unknown } })?.parameters
+        ?.customer_secret
+    ).toBeNull();
+    expect(data).toStrictEqual({
+      status: DisbursementStatus.succeeded,
+      refundStep: DisbursementStep.TransferSent,
+    });
+  });
+});