@spreeloop/orange_money 1.0.7 → 1.0.9

package/src/utils/https.ts

@@ -1,266 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,17 +0,0 @@
-/**
- * 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

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

package/tsconfig.build.json

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

package/tsconfig.dev.json

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

package/tsconfig.json

@@ -1,27 +0,0 @@
-{
-  "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": []
-}