@smartsoft001/payu 2.76.0 → 2.80.0

package/index.js

@@ -0,0 +1,188 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// packages/shared/payu/src/lib/payu.service.ts
+import { Injectable, Logger } from "@nestjs/common";
+
+// packages/shared/payu/src/lib/payu.config.ts
+var PayuConfig = class {
+};
+var PAYU_CONFIG_PROVIDER = "PAYU_CONFIG_PROVIDER";
+var IPayuConfigProvider = class {
+};
+
+// packages/shared/payu/src/lib/payu.service.ts
+var PayuService = class {
+  constructor(httpService, config, moduleRef) {
+    this.httpService = httpService;
+    this.config = config;
+    this.moduleRef = moduleRef;
+  }
+  async create(obj) {
+    const config = await this.getConfig(obj.data);
+    const token = await this.getToken(config);
+    const data = {
+      customerIp: obj.clientIp,
+      extOrderId: obj.id,
+      merchantPosId: config.posId,
+      description: obj.name,
+      currencyCode: "PLN",
+      totalAmount: obj.amount,
+      notifyUrl: config.notifyUrl,
+      continueUrl: config.continueUrl,
+      products: [
+        {
+          name: obj.name,
+          unitPrice: obj.amount,
+          quantity: "1"
+        }
+      ]
+    };
+    if (obj.options && obj.options["payMethod"]) {
+      data["payMethods"] = {
+        payMethod: obj.options["payMethod"]
+      };
+    }
+    if (obj.contactPhone || obj.email || obj.firstName || obj.lastName) {
+      data["buyer"] = {
+        email: obj.email,
+        phone: obj.contactPhone,
+        firstName: obj.firstName,
+        lastName: obj.lastName
+      };
+    }
+    try {
+      await this.httpService.post(this.getBaseUrl(config) + "/api/v2_1/orders", data, {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + token,
+          "X-Requested-With": "XMLHttpRequest"
+        },
+        maxRedirects: 0
+      }).toPromise();
+      return null;
+    } catch (e) {
+      if (e.response && e.response.status === 302) {
+        return {
+          redirectUrl: e.response.data.redirectUri,
+          orderId: e.response.data.orderId
+        };
+      }
+      console.error(e);
+      throw e;
+    }
+  }
+  async getStatus(trans) {
+    const orderId = this.getOrderId(trans);
+    const config = await this.getConfig(trans.data);
+    const token = await this.getToken(config);
+    const response = await this.httpService.get(this.getBaseUrl(config) + "/api/v2_1/orders/" + orderId, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + token,
+        "X-Requested-With": "XMLHttpRequest"
+      },
+      maxRedirects: 0
+    }).toPromise();
+    if (!response.data.orders)
+      return null;
+    const order = response.data.orders[0];
+    return {
+      status: this.getStatusFromExternal(order.status),
+      data: order
+    };
+  }
+  async refund(trans, comment) {
+    const orderId = this.getOrderId(trans);
+    const config = await this.getConfig(trans.data);
+    const token = await this.getToken(config);
+    const response = await this.httpService.post(
+      this.getBaseUrl(config) + "/api/v2_1/orders/" + orderId,
+      {
+        refund: {
+          description: comment
+        }
+      },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + token,
+          "X-Requested-With": "XMLHttpRequest"
+        },
+        maxRedirects: 0
+      }
+    ).toPromise();
+    return response.data;
+  }
+  getOrderId(trans) {
+    const historyItem = trans.history.find((x) => x.status === "started");
+    if (!historyItem) {
+      console.warn("Transaction without start status");
+      return null;
+    }
+    return historyItem.data.orderId;
+  }
+  async getToken(config) {
+    try {
+      const response = await this.httpService.post(
+        this.getBaseUrl(config) + "/pl/standard/user/oauth/authorize",
+        `grant_type=client_credentials&client_id=${config.clientId}&client_secret=${config.clientSecret}`
+      ).toPromise();
+      return response.data["access_token"];
+    } catch (e) {
+      console.error({
+        url: this.getBaseUrl(config) + "/pl/standard/user/oauth/authorize",
+        data: `grant_type=client_credentials&client_id=${config.clientId}&client_secret=${config.clientSecret}`,
+        ex: e
+      });
+      throw e;
+    }
+  }
+  async getConfig(data) {
+    try {
+      const provider = this.moduleRef.get(
+        PAYU_CONFIG_PROVIDER,
+        { strict: false }
+      );
+      return await provider.get(data);
+    } catch (e) {
+      Logger.warn("PayPal config provider not found", PayuService.name);
+    }
+    return this.config;
+  }
+  getBaseUrl(config) {
+    if (config.test)
+      return "https://secure.snd.payu.com";
+    return "https://secure.payu.com";
+  }
+  getStatusFromExternal(status) {
+    switch (status) {
+      case "COMPLETED":
+        return "completed";
+      case "CANCELED":
+        return "canceled";
+      case "PENDING":
+        return "pending";
+      default:
+        return status;
+    }
+  }
+};
+PayuService = __decorateClass([
+  Injectable()
+], PayuService);
+export {
+  IPayuConfigProvider,
+  PAYU_CONFIG_PROVIDER,
+  PayuConfig,
+  PayuService
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartsoft001/payu",
-  "version": "2.76.0",
+  "version": "2.80.0",
   "description": "Utils for payu",
   "repository": {
     "type": "git",

package/src/lib/payu.config.d.ts

@@ -0,0 +1,12 @@
+export declare class PayuConfig {
+    test?: boolean;
+    clientId: string;
+    clientSecret: string;
+    notifyUrl: string;
+    continueUrl: string;
+    posId: string;
+}
+export declare const PAYU_CONFIG_PROVIDER = "PAYU_CONFIG_PROVIDER";
+export declare abstract class IPayuConfigProvider {
+    abstract get(data: any): Promise<PayuConfig>;
+}

package/src/lib/payu.service.d.ts

@@ -0,0 +1,35 @@
+import { HttpService } from '@nestjs/axios';
+import { ModuleRef } from '@nestjs/core';
+import { ITransPaymentSingleService, Trans, TransStatus } from '@smartsoft001/trans-domain';
+import { PayuConfig } from './payu.config';
+export declare class PayuService implements ITransPaymentSingleService {
+    private readonly httpService;
+    private config;
+    private moduleRef;
+    constructor(httpService: HttpService, config: PayuConfig, moduleRef: ModuleRef);
+    create(obj: {
+        id: string;
+        name: string;
+        amount: number;
+        firstName?: string;
+        lastName?: string;
+        email?: string;
+        contactPhone?: string;
+        clientIp: string;
+        data: any;
+        options?: any;
+    }): Promise<{
+        orderId: string;
+        redirectUrl: string;
+    }>;
+    getStatus<T>(trans: Trans<T>): Promise<{
+        status: TransStatus;
+        data: any;
+    }>;
+    refund(trans: Trans<any>, comment: string): Promise<any>;
+    private getOrderId;
+    private getToken;
+    private getConfig;
+    private getBaseUrl;
+    private getStatusFromExternal;
+}

package/.eslintrc

@@ -1,13 +0,0 @@
-{
-  "extends": "../../../.eslintrc.json",
-  "ignorePatterns": ["!**/*"],
-  "rules": {
-
-  },
-  "overrides": [
-    {
-      "files": ["*.json"],
-      "parser": "jsonc-eslint-parser"
-    }
-  ]
-}

package/jest.config.ts

@@ -1,27 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'shared-payu',
-  globals: {},
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]sx?$': [
-      'ts-jest',
-      {
-        tsConfig: '<rootDir>/tsconfig.spec.json',
-      },
-    ],
-  },
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
-  coverageDirectory: '../../../coverage/libs/shared/payu',
-  preset: '../../../jest.preset.js',
-  /* TODO: Update to latest Jest snapshotFormat
-   * By default Nx has kept the older style of Jest Snapshot formats
-   * to prevent breaking of any existing tests with snapshots.
-   * It's recommend you update to the latest format.
-   * You can do this by removing snapshotFormat property
-   * and running tests with --update-snapshot flag.
-   * Example: From within the project directory, run "nx test --update-snapshot"
-   * More info: https://jestjs.io/docs/upgrading-to-jest29#snapshot-format
-   */
-  snapshotFormat: { escapeString: true, printBasicPrototype: true },
-};

package/project.json

@@ -1,37 +0,0 @@
-{
-  "name": "shared-payu",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/shared/payu/src",
-  "projectType": "library",
-  "tags": ["scope:shared", "type:util"],
-  "generators": {},
-  "targets": {
-    "lint": {
-      "executor": "@nx/eslint:lint",
-      "options": {
-        "lintFilePatterns": [
-          "packages/shared/payu/**/*.{ts,tsx,js,jsx}",
-          "packages/shared/payu/package.json"
-        ]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "options": {
-        "jestConfig": "packages/shared/payu/jest.config.ts"
-      },
-      "outputs": ["{workspaceRoot}/coverage/packages/shared/payu"]
-    },
-    "build": {
-      "executor": "@nx/esbuild:esbuild",
-      "options": {
-        "outputPath": "dist/packages/shared/payu",
-        "tsConfig": "packages/shared/payu/tsconfig.lib.json",
-        "packageJson": "packages/shared/payu/package.json",
-        "main": "packages/shared/payu/src/index.ts",
-        "assets": ["packages/shared/payu/*.md"]
-      },
-      "outputs": ["{options.outputPath}"]
-    }
-  }
-}

package/src/lib/payu.config.ts

@@ -1,14 +0,0 @@
-export class PayuConfig {
-  test?: boolean;
-  clientId: string;
-  clientSecret: string;
-  notifyUrl: string;
-  continueUrl: string;
-  posId: string;
-}
-
-export const PAYU_CONFIG_PROVIDER = 'PAYU_CONFIG_PROVIDER';
-
-export abstract class IPayuConfigProvider {
-  abstract get(data: any): Promise<PayuConfig>;
-}

package/src/lib/payu.service.spec.ts

@@ -1,483 +0,0 @@
-import { HttpService } from '@nestjs/axios';
-import { ModuleRef } from '@nestjs/core';
-import { Test, TestingModule } from '@nestjs/testing';
-import { of, throwError } from 'rxjs';
-
-import { PayuConfig } from './payu.config';
-import { PayuService } from './payu.service';
-
-const mockHttpService = {
-  post: jest.fn(),
-  get: jest.fn(),
-};
-
-const mockModuleRef = {
-  get: jest.fn(),
-};
-
-const mockPayuConfig = {
-  posId: 'mock-pos-id',
-  clientId: 'mock-client-id',
-  clientSecret: 'mock-client-secret',
-  notifyUrl: 'https://mock.notify.url',
-  continueUrl: 'https://mock.continue.url',
-  test: true,
-};
-
-describe('payu: PayuService', () => {
-  let service: PayuService;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        PayuService,
-        { provide: PayuConfig, useValue: mockPayuConfig },
-        { provide: HttpService, useValue: mockHttpService },
-        { provide: ModuleRef, useValue: mockModuleRef },
-      ],
-    }).compile();
-
-    service = module.get<PayuService>(PayuService);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('create', () => {
-    it('should obtain OAuth token before creating payment', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockErrorResponse = {
-        response: {
-          status: 302,
-          data: {
-            redirectUri: 'https://redirect.url',
-            orderId: 'test-order-id',
-          },
-        },
-      };
-
-      mockHttpService.post
-        .mockReturnValueOnce(of(mockTokenResponse))
-        .mockReturnValueOnce(throwError(() => mockErrorResponse));
-
-      await service.create({
-        id: 'test-id',
-        name: 'test-name',
-        amount: 100,
-        email: 'test@example.com',
-        clientIp: '127.0.0.1',
-        data: {},
-      });
-
-      const firstCall = mockHttpService.post.mock.calls[0];
-      expect(firstCall[0]).toBe(
-        'https://secure.snd.payu.com/pl/standard/user/oauth/authorize',
-      );
-      expect(firstCall[1]).toBe(
-        'grant_type=client_credentials&client_id=mock-client-id&client_secret=mock-client-secret',
-      );
-    });
-
-    it('should create payment with correct request body', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockErrorResponse = {
-        response: {
-          status: 302,
-          data: {
-            redirectUri: 'https://redirect.url',
-            orderId: 'test-order-id',
-          },
-        },
-      };
-
-      mockHttpService.post
-        .mockReturnValueOnce(of(mockTokenResponse))
-        .mockReturnValueOnce(throwError(() => mockErrorResponse));
-
-      await service.create({
-        id: 'test-id',
-        name: 'test-name',
-        amount: 100,
-        email: 'test@example.com',
-        clientIp: '127.0.0.1',
-        data: {},
-      });
-
-      expect(mockHttpService.post.mock.calls[1][1]).toEqual({
-        customerIp: '127.0.0.1',
-        extOrderId: 'test-id',
-        merchantPosId: 'mock-pos-id',
-        description: 'test-name',
-        currencyCode: 'PLN',
-        totalAmount: 100,
-        notifyUrl: 'https://mock.notify.url',
-        continueUrl: 'https://mock.continue.url',
-        products: [
-          {
-            name: 'test-name',
-            unitPrice: 100,
-            quantity: '1',
-          },
-        ],
-        buyer: {
-          email: 'test@example.com',
-        },
-      });
-    });
-
-    it('should create payment with correct headers', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockErrorResponse = {
-        response: {
-          status: 302,
-          data: {
-            redirectUri: 'https://redirect.url',
-            orderId: 'test-order-id',
-          },
-        },
-      };
-
-      mockHttpService.post
-        .mockReturnValueOnce(of(mockTokenResponse))
-        .mockReturnValueOnce(throwError(() => mockErrorResponse));
-
-      await service.create({
-        id: 'test-id',
-        name: 'test-name',
-        amount: 100,
-        email: 'test@example.com',
-        clientIp: '127.0.0.1',
-        data: {},
-      });
-
-      expect(mockHttpService.post.mock.calls[1][2]).toEqual({
-        headers: {
-          Authorization: 'Bearer mock-token',
-          'Content-Type': 'application/json',
-          'X-Requested-With': 'XMLHttpRequest',
-        },
-        maxRedirects: 0,
-      });
-    });
-
-    it('should return redirect URL and order ID on successful payment creation', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockErrorResponse = {
-        response: {
-          status: 302,
-          data: {
-            redirectUri: 'https://redirect.url',
-            orderId: 'test-order-id',
-          },
-        },
-      };
-
-      mockHttpService.post
-        .mockReturnValueOnce(of(mockTokenResponse))
-        .mockReturnValueOnce(throwError(() => mockErrorResponse));
-
-      const result = await service.create({
-        id: 'test-id',
-        name: 'test-name',
-        amount: 100,
-        email: 'test@example.com',
-        clientIp: '127.0.0.1',
-        data: {},
-      });
-
-      expect(result).toEqual({
-        orderId: 'test-order-id',
-        redirectUrl: 'https://redirect.url',
-      });
-    });
-  });
-
-  describe('getStatus', () => {
-    it('should obtain OAuth token before checking status', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockStatusResponse = {
-        data: {
-          orders: [
-            {
-              status: 'COMPLETED',
-              orderId: 'test-order-id',
-            },
-          ],
-        },
-      };
-
-      mockHttpService.post.mockReturnValueOnce(of(mockTokenResponse));
-      mockHttpService.get.mockReturnValueOnce(of(mockStatusResponse));
-
-      await service.getStatus({
-        data: {},
-        history: [
-          {
-            status: 'started',
-            data: { orderId: 'test-order-id' },
-          },
-        ],
-      } as any);
-
-      const firstCall = mockHttpService.post.mock.calls[0];
-      expect(firstCall[0]).toBe(
-        'https://secure.snd.payu.com/pl/standard/user/oauth/authorize',
-      );
-      expect(firstCall[1]).toBe(
-        'grant_type=client_credentials&client_id=mock-client-id&client_secret=mock-client-secret',
-      );
-    });
-
-    it('should check status with correct headers', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockStatusResponse = {
-        data: {
-          orders: [
-            {
-              status: 'COMPLETED',
-              orderId: 'test-order-id',
-            },
-          ],
-        },
-      };
-
-      mockHttpService.post.mockReturnValueOnce(of(mockTokenResponse));
-      mockHttpService.get.mockReturnValueOnce(of(mockStatusResponse));
-
-      await service.getStatus({
-        data: {},
-        history: [
-          {
-            status: 'started',
-            data: { orderId: 'test-order-id' },
-          },
-        ],
-      } as any);
-
-      const getCall = mockHttpService.get.mock.calls[0];
-      expect(getCall[1]).toEqual({
-        headers: {
-          Authorization: 'Bearer mock-token',
-          'Content-Type': 'application/json',
-          'X-Requested-With': 'XMLHttpRequest',
-        },
-        maxRedirects: 0,
-      });
-    });
-
-    it('should return correct status and data', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockStatusResponse = {
-        data: {
-          orders: [
-            {
-              status: 'COMPLETED',
-              orderId: 'test-order-id',
-            },
-          ],
-        },
-      };
-
-      mockHttpService.post.mockReturnValueOnce(of(mockTokenResponse));
-      mockHttpService.get.mockReturnValueOnce(of(mockStatusResponse));
-
-      const result = await service.getStatus({
-        data: {},
-        history: [
-          {
-            status: 'started',
-            data: { orderId: 'test-order-id' },
-          },
-        ],
-      } as any);
-
-      expect(result).toEqual({
-        status: 'completed',
-        data: {
-          status: 'COMPLETED',
-          orderId: 'test-order-id',
-        },
-      });
-    });
-  });
-
-  describe('refund', () => {
-    it('should obtain OAuth token before processing refund', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockRefundResponse = {
-        data: {
-          refundId: 'test-refund-id',
-        },
-      };
-
-      mockHttpService.post
-        .mockReturnValueOnce(of(mockTokenResponse))
-        .mockReturnValueOnce(of(mockRefundResponse));
-
-      await service.refund(
-        {
-          data: {},
-          history: [
-            {
-              status: 'started',
-              data: { orderId: 'test-order-id' },
-            },
-          ],
-        } as any,
-        'test comment',
-      );
-
-      const firstCall = mockHttpService.post.mock.calls[0];
-      expect(firstCall[0]).toBe(
-        'https://secure.snd.payu.com/pl/standard/user/oauth/authorize',
-      );
-      expect(firstCall[1]).toBe(
-        'grant_type=client_credentials&client_id=mock-client-id&client_secret=mock-client-secret',
-      );
-    });
-
-    it('should process refund with correct request body', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockRefundResponse = {
-        data: {
-          refundId: 'test-refund-id',
-        },
-      };
-
-      mockHttpService.post
-        .mockReturnValueOnce(of(mockTokenResponse))
-        .mockReturnValueOnce(of(mockRefundResponse));
-
-      await service.refund(
-        {
-          data: {},
-          history: [
-            {
-              status: 'started',
-              data: { orderId: 'test-order-id' },
-            },
-          ],
-        } as any,
-        'test comment',
-      );
-
-      const secondCall = mockHttpService.post.mock.calls[1];
-      expect(secondCall[1]).toEqual({
-        refund: {
-          description: 'test comment',
-        },
-      });
-    });
-
-    it('should process refund with correct headers', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockRefundResponse = {
-        data: {
-          refundId: 'test-refund-id',
-        },
-      };
-
-      mockHttpService.post
-        .mockReturnValueOnce(of(mockTokenResponse))
-        .mockReturnValueOnce(of(mockRefundResponse));
-
-      await service.refund(
-        {
-          data: {},
-          history: [
-            {
-              status: 'started',
-              data: { orderId: 'test-order-id' },
-            },
-          ],
-        } as any,
-        'test comment',
-      );
-
-      const secondCall = mockHttpService.post.mock.calls[1];
-      expect(secondCall[2]).toEqual({
-        headers: {
-          Authorization: 'Bearer mock-token',
-          'Content-Type': 'application/json',
-          'X-Requested-With': 'XMLHttpRequest',
-        },
-        maxRedirects: 0,
-      });
-    });
-
-    it('should return refund response data', async () => {
-      const mockTokenResponse = {
-        data: {
-          access_token: 'mock-token',
-        },
-      };
-      const mockRefundResponse = {
-        data: {
-          refundId: 'test-refund-id',
-        },
-      };
-
-      mockHttpService.post
-        .mockReturnValueOnce(of(mockTokenResponse))
-        .mockReturnValueOnce(of(mockRefundResponse));
-
-      const result = await service.refund(
-        {
-          data: {},
-          history: [
-            {
-              status: 'started',
-              data: { orderId: 'test-order-id' },
-            },
-          ],
-        } as any,
-        'test comment',
-      );
-
-      expect(result).toEqual({
-        refundId: 'test-refund-id',
-      });
-    });
-  });
-});

package/src/lib/payu.service.ts

@@ -1,219 +0,0 @@
-import { HttpService } from '@nestjs/axios';
-import { Inject, Injectable, Logger, Optional } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-
-import {
-  ITransPaymentSingleService,
-  Trans,
-  TransStatus,
-} from '@smartsoft001/trans-domain';
-
-import {
-  IPayuConfigProvider,
-  PAYU_CONFIG_PROVIDER,
-  PayuConfig,
-} from './payu.config';
-
-@Injectable()
-export class PayuService implements ITransPaymentSingleService {
-  constructor(
-    private readonly httpService: HttpService,
-    private config: PayuConfig,
-    private moduleRef: ModuleRef,
-  ) {}
-
-  async create(obj: {
-    id: string;
-    name: string;
-    amount: number;
-    firstName?: string;
-    lastName?: string;
-    email?: string;
-    contactPhone?: string;
-    clientIp: string;
-    data: any;
-    options?: any;
-  }): Promise<{ orderId: string; redirectUrl: string }> {
-    const config = await this.getConfig(obj.data);
-    const token = await this.getToken(config);
-
-    const data = {
-      customerIp: obj.clientIp,
-      extOrderId: obj.id,
-      merchantPosId: config.posId,
-      description: obj.name,
-      currencyCode: 'PLN',
-      totalAmount: obj.amount,
-      notifyUrl: config.notifyUrl,
-      continueUrl: config.continueUrl,
-      products: [
-        {
-          name: obj.name,
-          unitPrice: obj.amount,
-          quantity: '1',
-        },
-      ],
-    };
-
-    if (obj.options && obj.options['payMethod']) {
-      data['payMethods'] = {
-        payMethod: obj.options['payMethod'],
-      };
-    }
-
-    if (obj.contactPhone || obj.email || obj.firstName || obj.lastName) {
-      data['buyer'] = {
-        email: obj.email,
-        phone: obj.contactPhone,
-        firstName: obj.firstName,
-        lastName: obj.lastName,
-      };
-    }
-
-    try {
-      await this.httpService
-        .post(this.getBaseUrl(config) + '/api/v2_1/orders', data, {
-          headers: {
-            'Content-Type': 'application/json',
-            Authorization: 'Bearer ' + token,
-            'X-Requested-With': 'XMLHttpRequest',
-          },
-          maxRedirects: 0,
-        })
-        .toPromise();
-
-      return null;
-    } catch (e) {
-      if (e.response && e.response.status === 302) {
-        return {
-          redirectUrl: e.response.data.redirectUri,
-          orderId: e.response.data.orderId,
-        };
-      }
-      console.error(e);
-      throw e;
-    }
-  }
-
-  async getStatus<T>(
-    trans: Trans<T>,
-  ): Promise<{ status: TransStatus; data: any }> {
-    const orderId = this.getOrderId(trans);
-    const config = await this.getConfig(trans.data);
-
-    const token = await this.getToken(config);
-
-    const response = await this.httpService
-      .get(this.getBaseUrl(config) + '/api/v2_1/orders/' + orderId, {
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: 'Bearer ' + token,
-          'X-Requested-With': 'XMLHttpRequest',
-        },
-        maxRedirects: 0,
-      })
-      .toPromise();
-
-    if (!response.data.orders) return null;
-
-    const order = response.data.orders[0];
-
-    return {
-      status: this.getStatusFromExternal(order.status),
-      data: order,
-    };
-  }
-
-  async refund(trans: Trans<any>, comment: string): Promise<any> {
-    const orderId = this.getOrderId(trans);
-    const config = await this.getConfig(trans.data);
-
-    const token = await this.getToken(config);
-
-    const response = await this.httpService
-      .post(
-        this.getBaseUrl(config) + '/api/v2_1/orders/' + orderId,
-        {
-          refund: {
-            description: comment,
-          },
-        },
-        {
-          headers: {
-            'Content-Type': 'application/json',
-            Authorization: 'Bearer ' + token,
-            'X-Requested-With': 'XMLHttpRequest',
-          },
-          maxRedirects: 0,
-        },
-      )
-      .toPromise();
-
-    return response.data;
-  }
-
-  private getOrderId(trans: Trans<any>): string {
-    const historyItem = trans.history.find((x) => x.status === 'started');
-
-    if (!historyItem) {
-      console.warn('Transaction without start status');
-      return null;
-    }
-
-    return historyItem.data.orderId;
-  }
-
-  private async getToken(config: PayuConfig): Promise<string> {
-    try {
-      const response = await this.httpService
-        .post(
-          this.getBaseUrl(config) + '/pl/standard/user/oauth/authorize',
-          `grant_type=client_credentials&client_id=${config.clientId}&client_secret=${config.clientSecret}`,
-        )
-        .toPromise();
-
-      return response.data['access_token'];
-    } catch (e) {
-      console.error({
-        url: this.getBaseUrl(config) + '/pl/standard/user/oauth/authorize',
-        data: `grant_type=client_credentials&client_id=${config.clientId}&client_secret=${config.clientSecret}`,
-        ex: e,
-      });
-
-      throw e;
-    }
-  }
-
-  private async getConfig(data: any): Promise<PayuConfig> {
-    try {
-      const provider: IPayuConfigProvider = this.moduleRef.get(
-        PAYU_CONFIG_PROVIDER,
-        { strict: false },
-      );
-      return await provider.get(data);
-    } catch (e) {
-      Logger.warn('PayPal config provider not found', PayuService.name);
-    }
-
-    return this.config;
-  }
-
-  private getBaseUrl(config: PayuConfig): string {
-    if (config.test) return 'https://secure.snd.payu.com';
-
-    return 'https://secure.payu.com';
-  }
-
-  private getStatusFromExternal(status: string): any {
-    switch (status) {
-      case 'COMPLETED':
-        return 'completed';
-      case 'CANCELED':
-        return 'canceled';
-      case 'PENDING':
-        return 'pending';
-      default:
-        return status;
-    }
-  }
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "outDir": "../../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "exclude": ["**/*.spec.ts", "**/*.test.ts", "jest.config.ts"],
-  "include": ["**/*.ts"]
-}

package/tsconfig.spec.json

@@ -1,20 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../../dist/out-tsc",
-    "module": "commonjs",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "**/*.spec.ts",
-    "**/*.test.ts",
-    "**/*.spec.tsx",
-    "**/*.test.tsx",
-    "**/*.spec.js",
-    "**/*.test.js",
-    "**/*.spec.jsx",
-    "**/*.test.jsx",
-    "**/*.d.ts",
-    "jest.config.ts"
-  ]
-}