feat(medusa): cleanup

packages/medusa/src/interfaces/payment-service.ts

@@ -6,12 +6,14 @@ import {
   PaymentSession,
   PaymentSessionStatus,
 } from "../models"
+import { PaymentService } from "medusa-interfaces"
 
 export type Data = Record<string, unknown>
 export type PaymentData = Data
 export type PaymentSessionData = Data
 
-export interface PaymentService {
+export interface PaymentService<T extends TransactionBaseService<never>>
+  extends TransactionBaseService<T> {
   getIdentifier(): string
 
   getPaymentData(paymentSession: PaymentSession): Promise<PaymentData>
@@ -50,9 +52,11 @@ export interface PaymentService {
   ): Promise<PaymentSessionStatus>
 }
 
-export abstract class AbstractPaymentService
-  extends TransactionBaseService<AbstractPaymentService>
-  implements PaymentService
+export abstract class AbstractPaymentService<
+    T extends TransactionBaseService<never>
+  >
+  extends TransactionBaseService<T>
+  implements PaymentService<T>
 {
   protected constructor(container: unknown, config?: Record<string, unknown>) {
     super(container, config)
@@ -110,3 +114,7 @@ export abstract class AbstractPaymentService
     paymentSessionData: PaymentSessionData
   ): Promise<PaymentSessionStatus>
 }
+
+export function isPaymentService(obj: unknown): boolean {
+  return obj instanceof AbstractPaymentService || obj instanceof PaymentService
+}

packages/medusa/src/loaders/plugins.ts

@@ -10,17 +10,15 @@ import {
   FileService,
   FulfillmentService,
   OauthService,
-  PaymentService,
 } from "medusa-interfaces"
 import path from "path"
 import { EntitySchema } from "typeorm"
 import {
-  AbstractFileService,
-  AbstractPaymentService,
   AbstractTaxService,
   isBatchJobStrategy,
   isFileService,
   isNotificationService,
+  isPaymentService,
   isPriceSelectionStrategy,
   isSearchService,
   isTaxCalculationStrategy,
@@ -351,10 +349,7 @@ export async function registerServices(
         throw new Error(message)
       }
 
-      if (
-        loaded.prototype instanceof AbstractPaymentService ||
-        loaded.prototype instanceof PaymentService
-      ) {
+      if (isPaymentService(loaded.prototype)) {
         // Register our payment providers to paymentProviders
         container.registerAdd(
           "paymentProviders",

packages/medusa/src/models/cart.ts

@@ -210,7 +210,7 @@ export class Cart extends SoftDeletableEntity {
 
   @OneToOne(() => Payment)
   @JoinColumn({ name: "payment_id" })
-  payment?: Payment
+  payment: Payment
 
   @OneToMany(() => ShippingMethod, (method) => method.cart, {
     cascade: ["soft-remove", "remove"],

packages/medusa/src/services/__mocks__/test-pay.js

@@ -1,5 +1,4 @@
-/*
-const testPayService = {
+export const testPayServiceMock = {
   identifier: "test-pay",
   getIdentifier: "test-pay",
   getStatus: jest.fn().mockResolvedValue(Promise.resolve("authorised")),
@@ -34,118 +33,8 @@ const testPayService = {
   })
 }
 
-export default testPayService*/
-
-import { AbstractPaymentService } from "../../interfaces"
-
-class TestPayService extends AbstractPaymentService {
-  static identifier = "test-pay"
-
-  getIdentifier() {
-    return TestPayService.identifier
-  }
-
-  constructor(...args) {
-    super(...args)
-  }
-
-  async getStatus(paymentData) {
-    return "authorized"
-  }
-
-  async retrieveSavedMethods(customer) {
-    return Promise.resolve([])
-  }
-
-  async createPayment(cart) {
-    return undefined
-  }
-
-  async retrievePayment(data) {
-    return {}
-  }
-
-  async getPaymentData(sessionData) {
-    return {}
-  }
-
-  async authorizePayment(sessionData, context = {}) {
-    return { data: {}, status: "authorized" }
-  }
-
-  async updatePaymentData(sessionData, update) {
-    return {}
-  }
-
-  async updatePayment(sessionData, cart) {
-    return {}
-  }
-
-  async deletePayment(payment) {
-    return {}
-  }
-
-  async capturePayment(payment) {
-    return {}
-  }
-
-  async refundPayment(payment, amountToRefund) {
-    return {}
-  }
-
-  async cancelPayment(payment) {
-    return {}
-  }
-}
-
-TestPayService.prototype.createPayment = jest.fn().mockImplementation((cart) => {
-  const fields = [
-      "total",
-      "subtotal",
-      "tax_total",
-      "discount_total",
-      "shipping_total",
-      "gift_card_total",
-    ]
-
-    const data = {}
-    for (const k of fields) {
-      data[k] = cart[k]
-    }
-
-    return data
-})
-
-TestPayService.prototype.updatePayment = jest.fn().mockImplementation(() => {
-  return {}
-})
-
-TestPayService.prototype.deletePayment = jest.fn().mockImplementation(() => {
-  return {}
-})
-
-TestPayService.prototype.deletePayment = jest.fn().mockImplementation(() => {
-  return {}
-})
-
-TestPayService.prototype.authorizePayment = jest.fn().mockImplementation(() => {
-  return {}
-})
-
-TestPayService.prototype.updatePaymentData = jest.fn().mockImplementation(() => {
-  return {}
-})
-
-TestPayService.prototype.cancelPayment = jest.fn().mockImplementation(() => {
-  return {}
-})
-
-TestPayService.prototype.capturePayment = jest.fn().mockImplementation(() => {
-  return {}
-})
-
-TestPayService.prototype.refundPayment = jest.fn().mockImplementation(() => {
-  return {}
+const mock = jest.fn().mockImplementation(() => {
+  return testPayServiceMock
 })
 
-export default TestPayService
+export default mock