@spreeloop/orange_money 1.0.0

package/src/utils/https.ts

@@ -0,0 +1,266 @@
+import * as axios from 'axios';
+import { AxiosError } from 'axios';
+import base64url from 'base64url';
+import * as https from 'https';
+import { LoggerInterface } from './logging_interface';
+
+export enum RequestStatusCode {
+  unauthorized = 401,
+  expectationFailed = 417,
+}
+
+export type RequestResponse<T> = {
+  response?: {
+    data: T;
+    status: number;
+  };
+  error?: unknown;
+};
+
+/**
+ * Posts an http request to the given route.
+ * @param {Record<string, string | undefined> | string} data The data to be posted.
+ * @param {string} route The end point url.
+ * @param {Record<string, string>} headers The type content  of request.
+ * @param {LoggerInterface} logger The logger to use when posting data.
+ * @return {Promise<unknown | undefined>} The server response.
+ */
+export async function postRequest<T>({
+  data,
+  route,
+  headers,
+  logger,
+  rejectUnauthorized = true,
+}: {
+  data?: Record<string, unknown> | string | null;
+  route: string;
+  logger: LoggerInterface;
+  headers?: Record<string, string>;
+  rejectUnauthorized?: boolean;
+}): Promise<RequestResponse<T>> {
+  try {
+    logger.info(
+      `Request on the route ${route} is running with data : ${JSON.stringify({
+        headers,
+        data,
+        route,
+      })}`
+    );
+    const agent = new https.Agent({
+      rejectUnauthorized: rejectUnauthorized,
+    });
+    const response = await axios.default({
+      method: 'post',
+      url: route,
+      headers: headers,
+      data: data,
+      httpsAgent: agent,
+    });
+    logger.info(
+      `Request on the route ${route} completed successfully with data : ${JSON.stringify(
+        {
+          response: response.data,
+          status: response.status,
+          statusText: response.statusText,
+        }
+      )}`
+    );
+    return { response: { data: response.data, status: response.status } };
+  } catch (error) {
+    logger.warn(
+      `[Axios] failed to post request on the route: ${route} with data : ${JSON.stringify(
+        { headers, data, route }
+      )}`
+    );
+    const parsedError = parseAxiosError(error);
+    logger.warn(JSON.stringify(error));
+    if (error instanceof AxiosError) {
+      if (error.response) {
+        return {
+          response: {
+            status: error.response.status,
+            data: error.response.data,
+          },
+          error: parsedError,
+        };
+      }
+    }
+
+    return { error: parsedError };
+  }
+}
+
+/**
+ * Gets an http request to the given route.
+ * @param {Record<string, string | undefined> | string} data The data to be posted.
+ * @param {string} route The end point url.
+ * @param {Record<string, string>} headers The type content  of request.
+ * @param {LoggerInterface} logger The logger to use when getting data.
+ * @return {Promise<unknown | undefined>} The server response.
+ */
+export async function getRequest<T>({
+  data,
+  route,
+  headers,
+  logger,
+  rejectUnauthorized = true,
+}: {
+  data?: Record<string, string | undefined> | string;
+  route: string;
+  headers?: Record<string, string>;
+  logger: LoggerInterface;
+  rejectUnauthorized?: boolean;
+}): Promise<RequestResponse<T>> {
+  try {
+    logger.info(
+      `Request on the route ${route} is running with data : ${JSON.stringify({
+        headers,
+        data,
+        route,
+      })}`
+    );
+    const agent = new https.Agent({
+      rejectUnauthorized: rejectUnauthorized,
+    });
+    const response = await axios.default({
+      method: 'get',
+      url: route,
+      headers: headers,
+      data: data,
+      httpsAgent: agent,
+    });
+    logger.info(
+      `Request on the route ${route} completed successfully with data : ${JSON.stringify(
+        {
+          response: response.data,
+          status: response.status,
+          statusText: response.statusText,
+        }
+      )}`
+    );
+    return { response: { data: response.data, status: response.status } };
+  } catch (error) {
+    logger.warn(
+      `[Axios] failed to get request on the route: ${route} with data : ${JSON.stringify(
+        { headers, data, route }
+      )}`
+    );
+    const parsedError = parseAxiosError(error);
+    logger.warn(JSON.stringify(error));
+    if (error instanceof AxiosError) {
+      if (error.response) {
+        return {
+          response: {
+            status: error.response.status,
+            data: error.response.data,
+          },
+          error: parsedError,
+        };
+      }
+    }
+
+    return { error: parsedError };
+  }
+}
+
+/**
+ * Parses an Axios error and returns a modified error object.
+ *
+ * @param {unknown} error - The error object to be parsed.
+ * @return {unknown} The modified error object.
+ */
+export function parseAxiosError(error: unknown): unknown {
+  let err = error;
+  if (error instanceof AxiosError) {
+    if (error.response) {
+      err = {
+        responseError: {
+          data: error.response.data,
+          status: error.response.status,
+          statusText: error.response.statusText,
+          headers: error.response.headers,
+        },
+        requestBody: error.request.body,
+      };
+    } else if (error.request) {
+      err = {
+        requestFailed: {
+          headers: error.config?.headers,
+          data: error.config?.data,
+        },
+      };
+    } else {
+      err = {
+        configFailed: error.message,
+      };
+    }
+  }
+  return err;
+}
+
+/**
+ * Generates a hash using the given key and secret.
+ *
+ * @param {string} key - The key to be hashed.
+ * @param {string} secret - The secret to be hashed.
+ * @return {string} - The generated hash.
+ */
+export function hash(key: string, secret: string): string {
+  const toHash = `${key}:${secret}`;
+  if (!global.btoa) {
+    return Buffer.from(toHash).toString('base64');
+  }
+  return global.btoa(toHash);
+}
+
+/**
+ * Encode the body of the request.
+ * @param {Record<string, string>} bodyRequest the body request.
+ * @return {string} the encoded body request result.
+ */
+export function encodeTheBodyOfRequest(
+  bodyRequest: Record<string, string>
+): string {
+  const formBody = [];
+  for (const key in bodyRequest) {
+    if ({}.hasOwnProperty.call(bodyRequest, key)) {
+      const encodedKey = encodeURIComponent(key);
+      const encodedValue = encodeURIComponent(bodyRequest[key]);
+      formBody.push(encodedKey + '=' + encodedValue);
+    }
+  }
+  return formBody.join('&');
+}
+
+// Encode to base64
+export const encodeToBase64 = (
+  apiUsername: string,
+  apiPassword: string
+): string => {
+  return base64url(`${apiUsername}:${apiPassword}`);
+};
+
+/**
+ * Encode the data to w3 x form encoded url.
+ * @param {Record<string, string>} data the data to encode.
+ * @return {string} the encoded value.
+ */
+export function encodeDataToXFormUrl(data: Record<string, string>): string {
+  const segments: string[] = [];
+  for (const key in data) {
+    if (Object.hasOwnProperty.call(data, key)) {
+      const encodedKey = encodeURIComponent(key);
+      const encodedValue = encodeURIComponent(data[key]);
+      segments.push(`${encodedKey}=${encodedValue}`);
+    }
+  }
+  return segments.join('&');
+}
+
+/**
+ * Checks if the code is a successful code response.
+ * @param {num} code .
+ * @return {boolean} true if the code is valid.
+ */
+export const isSuccessfulCodeResponse = (code: number): boolean =>
+  code >= 200 && code < 300;

package/src/utils/logging_interface.ts

@@ -0,0 +1,25 @@
+export interface LoggerInterface {
+  /**
+   * Logs a debug level message.
+   * @param {string[]} args
+   */
+  log(...args: string[]): void;
+
+  /**
+   * Logs an info level message.
+   * @param {string[]} args
+   */
+  info(...args: string[]): void;
+
+  /**
+   * Logs a waning level message.
+   * @param {string[]} args
+   */
+  warn(...args: string[]): void;
+
+  /**
+   * Logs an error level message.
+   * @param {string[]} args
+   */
+  error(...args: string[]): void;
+}

package/src/utils/operation_response.ts

@@ -0,0 +1,17 @@
+/**
+ * Data return to user when requesting an operation.
+ */
+export type OperationResponse<T, T2 = unknown, R = unknown> = Promise<
+  SuccessfulOperationResponse<T, T2> | FailedOperationResponse<R>
+>;
+type SuccessfulOperationResponse<T, T2 = unknown> = {
+  data: T;
+  raw: T2;
+  error?: never;
+};
+
+type FailedOperationResponse<R = unknown> = {
+  data?: never;
+  raw?: unknown;
+  error: R;
+};

package/src/utils/utils.ts

@@ -0,0 +1,5 @@
+export enum TargetEnvironment {
+  sandbox = 'dev',
+  prod = 'prod',
+  fake = 'fake',
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["**/*.spec.ts"]
+}

package/tsconfig.dev.json

@@ -0,0 +1,4 @@
+{
+  "include": [".eslintrc.js", "index.spec.ts", "jest.config.ts", "jest.before-test.ts", "babel.config.js"],
+  "exclude": []
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "es2017",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "moduleResolution": "node",                          /* Specify how TypeScript looks up a file from a given module specifier. */
+    "declaration": true,                                 /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    "declarationMap": true,                              /* Create sourcemaps for d.ts files. */
+    "sourceMap": true,                                   /* Create source map files for emitted JavaScript files. */
+    "outDir": "dist",                                   /* Specify an output folder for all emitted files. */
+    "removeComments": false,                             /* Disable emitting comments. */
+    "allowSyntheticDefaultImports": true,                /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    "noImplicitThis": true,                              /* Enable error reporting when 'this' is given the type 'any'. */
+    "noUnusedLocals": true,                              /* Enable error reporting when local variables aren't read. */
+    "noImplicitReturns": true,                           /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    "noFallthroughCasesInSwitch": true,                  /* Enable error reporting for fallthrough cases in switch statements. */
+    "skipLibCheck": true,                                /* Skip type checking all .d.ts files. */
+    "baseUrl": ".",
+    "paths": {
+      "@spreeloop-core/logging": ["../logging"]
+    }
+  },
+  "include": ["src", "index.ts"],
+  "exclude": []
+}