Feat(order): post purchase support (#7666)

integration-tests/modules/__tests__/order/order.spec.ts

@@ -257,7 +257,7 @@ medusaIntegrationTestRunner({
                 value: "1",
                 precision: 20,
               },
-              detail: {
+              detail: expect.objectContaining({
                 id: expect.any(String),
                 order_id: expect.any(String),
                 version: 1,
@@ -301,7 +301,7 @@ medusaIntegrationTestRunner({
                 return_received_quantity: 0,
                 return_dismissed_quantity: 0,
                 written_off_quantity: 0,
-              },
+              }),
               subtotal: 50,
               total: 50,
               original_total: 50,

packages/core/types/src/order/common.ts

@@ -1109,6 +1109,12 @@ export interface OrderDTO {
   raw_original_shipping_tax_total: BigNumberRawValue
 }
 
+type ReturnStatus = "requested" | "received" | "partially_received" | "canceled"
+
+export interface ReturnDTO extends Omit<OrderDTO, "status" | "version"> {
+  status: ReturnStatus
+}
+
 export type PaymentStatus =
   | "not_paid"
   | "awaiting"

packages/core/types/src/order/mutations.ts

@@ -249,6 +249,9 @@ export interface UpdateOrderShippingMethodAdjustmentDTO {
 
 export interface CreateOrderChangeDTO {
   order_id: string
+  return_id?: string
+  claim_id?: string
+  exchange_id?: string
   description?: string
   internal_note?: string
   requested_by?: string
@@ -298,6 +301,10 @@ export interface ConfirmOrderChangeDTO {
 
 export interface CreateOrderChangeActionDTO {
   order_change_id?: string
+  order_id?: string
+  return_id?: string
+  claim_id?: string
+  exchange_id?: string
   version?: number
   reference?: string
   reference_id?: string
@@ -368,39 +375,53 @@ export interface UpdateOrderItemWithSelectorDTO {
 
 /** ORDER bundled action flows  */
 
+interface BaseOrderBundledItemActionsDTO {
+  id: string
+  quantity: BigNumberInput
+  internal_note?: string
+  metadata?: Record<string, unknown> | null
+}
 interface BaseOrderBundledActionsDTO {
   order_id: string
+  return_id?: string
+  claim_id?: string
+  exchange_id?: string
+
   description?: string
   internal_note?: string
   reference?: string
   reference_id?: string
   created_by?: string
-  items: {
-    id: string
-    quantity: BigNumberInput
-    internal_note?: string
-    metadata?: Record<string, unknown> | null
-  }[]
   metadata?: Record<string, unknown> | null
 }
 
 export interface RegisterOrderFulfillmentDTO
-  extends BaseOrderBundledActionsDTO {}
+  extends BaseOrderBundledActionsDTO {
+  items: BaseOrderBundledItemActionsDTO[]
+}
 
-export interface CancelOrderFulfillmentDTO extends BaseOrderBundledActionsDTO {}
+export interface CancelOrderFulfillmentDTO extends BaseOrderBundledActionsDTO {
+  items: BaseOrderBundledItemActionsDTO[]
+}
 
-export interface RegisterOrderShipmentDTO extends BaseOrderBundledActionsDTO {}
+export interface RegisterOrderShipmentDTO extends BaseOrderBundledActionsDTO {
+  items: BaseOrderBundledItemActionsDTO[]
+}
 
 export interface CreateOrderReturnDTO extends BaseOrderBundledActionsDTO {
+  items: BaseOrderBundledItemActionsDTO[]
   shipping_method: Omit<CreateOrderShippingMethodDTO, "order_id"> | string
 }
 
 export interface CancelOrderReturnDTO {
-  order_id: string
   return_id: string
 }
 
-export interface ReceiveOrderReturnDTO extends BaseOrderBundledActionsDTO {}
+export interface ReceiveOrderReturnDTO
+  extends Omit<BaseOrderBundledActionsDTO, "order_id"> {
+  items: BaseOrderBundledItemActionsDTO[]
+  return_id: string
+}
 
 /** ORDER bundled action flows */
 

packages/core/types/src/order/service.ts

@@ -26,6 +26,7 @@ import {
   OrderShippingMethodDTO,
   OrderShippingMethodTaxLineDTO,
   OrderTransactionDTO,
+  ReturnDTO,
 } from "./common"
 import {
   CancelOrderChangeDTO,
@@ -130,6 +131,24 @@ export interface IOrderModuleService extends IModuleService {
     sharedContext?: Context
   ): Promise<[OrderDTO[], number]>
 
+  retrieveReturn(
+    returnId: string,
+    config?: FindConfig<ReturnDTO>,
+    sharedContext?: Context
+  ): Promise<ReturnDTO>
+
+  listReturns(
+    filters?: FilterableOrderProps,
+    config?: FindConfig<ReturnDTO>,
+    sharedContext?: Context
+  ): Promise<ReturnDTO[]>
+
+  listAndCountReturns(
+    filters?: FilterableOrderProps,
+    config?: FindConfig<ReturnDTO>,
+    sharedContext?: Context
+  ): Promise<[ReturnDTO[], number]>
+
   /**
    * This method creates {return type}(s)
    *
@@ -1513,7 +1532,7 @@ export interface IOrderModuleService extends IModuleService {
   createReturn(
     returnData: CreateOrderReturnDTO,
     sharedContext?: Context
-  ): Promise<void>
+  ): Promise<any> // TODO: ReturnDTO
 
   /*
   cancelReturn(
@@ -1525,5 +1544,5 @@ export interface IOrderModuleService extends IModuleService {
   receiveReturn(
     returnData: ReceiveOrderReturnDTO,
     sharedContext?: Context
-  ): Promise<void>
+  ): Promise<any> // TODO: ReturnDTO
 }

packages/core/utils/src/order/status.ts

@@ -33,27 +33,23 @@ export enum OrderStatus {
 /**
  * @enum
  *
- * The order change's status.
+ * The return's status.
  */
-export enum OrderChangeStatus {
+export enum ReturnStatus {
   /**
-   * The order change is confirmed.
+   * The return is requested.
-   */
-  CONFIRMED = "confirmed",
-  /**
-   * The order change is declined.
-   */
-  DECLINED = "declined",
-  /**
-   * The order change is requested.
    */
   REQUESTED = "requested",
   /**
-   * The order change is pending.
+   * The return is received.
    */
-  PENDING = "pending",
+  RECEIVED = "received",
   /**
-   * The order change is canceled.
+   * The return is partially received.
+   */
+  PARTIALLY_RECEIVED = "partially_received",
+  /**
+   * The return is canceled.
    */
   CANCELED = "canceled",
 }

packages/modules/order/integration-tests/__tests__/order-return.ts

@@ -233,12 +233,15 @@ moduleIntegrationTestRunner({
         )
 
         // Return
-        await service.createReturn({
+        const orderReturn = await service.createReturn({
           order_id: createdOrder.id,
           reference: Modules.FULFILLMENT,
           description: "Return all the items",
           internal_note: "user wants to return all items",
-          shipping_method: createdOrder.shipping_methods![0].id,
+          shipping_method: {
+            name: "Return method",
+            amount: 35,
+          },
           items: createdOrder.items!.map((item) => {
             return {
               id: item.id,
@@ -302,6 +305,141 @@ moduleIntegrationTestRunner({
             ],
           })
         )
+
+        // Receive Return
+        const allItems = createdOrder.items!.map((item) => {
+          return {
+            id: item.id,
+            quantity: item.quantity,
+          }
+        })
+        const lastItem = allItems.pop()!
+        const receive = await service.receiveReturn({
+          return_id: orderReturn.id,
+          internal_note: "received some items",
+          items: allItems,
+        })
+
+        const receiveComplete = await service.receiveReturn({
+          return_id: orderReturn.id,
+          internal_note: "received remaining items",
+          items: [lastItem],
+        })
+
+        expect(receive).toEqual(
+          expect.objectContaining({
+            id: orderReturn.id,
+            status: "partially_received",
+            received_at: null,
+            items: expect.arrayContaining([
+              expect.objectContaining({
+                id: allItems[0].id,
+                detail: expect.objectContaining({
+                  return_requested_quantity: 0,
+                  return_received_quantity: 1,
+                }),
+              }),
+              expect.objectContaining({
+                id: allItems[1].id,
+                detail: expect.objectContaining({
+                  return_requested_quantity: 0,
+                  return_received_quantity: 2,
+                }),
+              }),
+            ]),
+          })
+        )
+
+        expect(receiveComplete).toEqual(
+          expect.objectContaining({
+            id: orderReturn.id,
+            status: "received",
+            received_at: expect.any(Date),
+            items: expect.arrayContaining([
+              expect.objectContaining({
+                id: allItems[0].id,
+                detail: expect.objectContaining({
+                  return_requested_quantity: 0,
+                  return_received_quantity: 1,
+                }),
+              }),
+              expect.objectContaining({
+                id: allItems[1].id,
+                detail: expect.objectContaining({
+                  return_requested_quantity: 0,
+                  return_received_quantity: 2,
+                }),
+              }),
+              expect.objectContaining({
+                id: lastItem.id,
+                detail: expect.objectContaining({
+                  return_requested_quantity: 0,
+                  return_received_quantity: 1,
+                }),
+              }),
+            ]),
+          })
+        )
+
+        getOrder = await service.retrieve(createdOrder.id, {
+          select: [
+            "id",
+            "version",
+            "items.id",
+            "items.quantity",
+            "items.detail.id",
+            "items.detail.version",
+            "items.detail.quantity",
+            "items.detail.shipped_quantity",
+            "items.detail.fulfilled_quantity",
+            "items.detail.return_requested_quantity",
+            "items.detail.return_received_quantity",
+          ],
+          relations: ["items", "items.detail"],
+        })
+
+        serializedOrder = JSON.parse(JSON.stringify(getOrder))
+
+        expect(serializedOrder).toEqual(
+          expect.objectContaining({
+            version: 6,
+            items: [
+              expect.objectContaining({
+                quantity: 1,
+                detail: expect.objectContaining({
+                  version: 6,
+                  quantity: 1,
+                  fulfilled_quantity: 1,
+                  shipped_quantity: 1,
+                  return_requested_quantity: 0,
+                  return_received_quantity: 1,
+                }),
+              }),
+              expect.objectContaining({
+                quantity: 2,
+                detail: expect.objectContaining({
+                  version: 6,
+                  quantity: 2,
+                  fulfilled_quantity: 2,
+                  shipped_quantity: 2,
+                  return_requested_quantity: 0,
+                  return_received_quantity: 2,
+                }),
+              }),
+              expect.objectContaining({
+                quantity: 1,
+                detail: expect.objectContaining({
+                  version: 6,
+                  quantity: 1,
+                  fulfilled_quantity: 1,
+                  shipped_quantity: 1,
+                  return_requested_quantity: 0,
+                  return_received_quantity: 1,
+                }),
+              }),
+            ],
+          })
+        )
       })
     })
   },

packages/modules/order/src/migrations/Migration20240604100512.ts

@@ -0,0 +1,212 @@
+import { Migration } from "@mikro-orm/migrations"
+
+export class Migration20240604100512 extends Migration {
+  async up(): Promise<void> {
+    const sql = `
+    ALTER TABLE "order_change"
+    ADD COLUMN if NOT exists "change_type" TEXT  NULL;
+
+    ALTER TABLE "order_change"
+    ADD COLUMN if NOT exists "deleted_at" timestamptz NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_change_change_type" ON "order_change" (
+        change_type
+    );
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_change_deleted_at" ON "order_change" (
+        deleted_at
+    );
+
+
+
+    ALTER TABLE "order_item"
+    ADD COLUMN if NOT exists "return_id" TEXT NULL;
+
+    ALTER TABLE "order_item"
+    ADD COLUMN if NOT exists "claim_id" TEXT NULL;
+
+    ALTER TABLE "order_item"
+    ADD COLUMN if NOT exists "exchange_id" TEXT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_item_return_id" ON "order_item" (
+        return_id
+    )
+    WHERE return_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_item_claim_id" ON "order_item" (
+        claim_id
+    )
+    WHERE claim_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_item_exchange_id" ON "order_item" (
+        exchange_id
+    )
+    WHERE exchange_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+
+
+    ALTER TABLE "order_transaction"
+    ADD COLUMN if NOT exists "return_id" TEXT NULL;
+
+    ALTER TABLE "order_transaction"
+    ADD COLUMN if NOT exists "claim_id" TEXT NULL;
+
+    ALTER TABLE "order_transaction"
+    ADD COLUMN if NOT exists "exchange_id" TEXT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_transaction_return_id" ON "order_transaction" (
+        return_id
+    )
+    WHERE return_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_transaction_claim_id" ON "order_transaction" (
+        claim_id
+    )
+    WHERE claim_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_transaction_exchange_id" ON "order_transaction" (
+        exchange_id
+    )
+    WHERE exchange_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+
+
+    ALTER TABLE "order_shipping"
+    ADD COLUMN if NOT exists "return_id" TEXT NULL;
+
+    ALTER TABLE "order_shipping"
+    ADD COLUMN if NOT exists "claim_id" TEXT NULL;
+
+    ALTER TABLE "order_shipping"
+    ADD COLUMN if NOT exists "exchange_id" TEXT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_shipping_return_id" ON "order_shipping" (
+        return_id
+    )
+    WHERE return_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_shipping_claim_id" ON "order_shipping" (
+        claim_id
+    )
+    WHERE claim_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_shipping_exchange_id" ON "order_shipping" (
+        exchange_id
+    )
+    WHERE exchange_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+
+
+
+    ALTER TABLE "order_change"
+    ADD COLUMN if NOT exists "return_id" TEXT NULL;
+
+    ALTER TABLE "order_change"
+    ADD COLUMN if NOT exists "claim_id" TEXT NULL;
+
+    ALTER TABLE "order_change"
+    ADD COLUMN if NOT exists "exchange_id" TEXT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_change_return_id" ON "order_change" (
+        return_id
+    )
+    WHERE return_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_change_claim_id" ON "order_change" (
+        claim_id
+    )
+    WHERE claim_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_change_exchange_id" ON "order_change" (
+        exchange_id
+    )
+    WHERE exchange_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+
+
+    ALTER TABLE "order_change_action"
+    ADD COLUMN if NOT exists "deleted_at" timestamptz NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_change_action_deleted_at" ON "order_change_action" (
+        deleted_at
+    );
+
+    ALTER TABLE "order_change_action"
+    ADD COLUMN if NOT exists "return_id" TEXT NULL;
+
+    ALTER TABLE "order_change_action"
+    ADD COLUMN if NOT exists "claim_id" TEXT NULL;
+
+    ALTER TABLE "order_change_action"
+    ADD COLUMN if NOT exists "exchange_id" TEXT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_change_action_return_id" ON "order_change_action" (
+        return_id
+    )
+    WHERE return_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_change_action_claim_id" ON "order_change_action" (
+        claim_id
+    )
+    WHERE claim_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_order_change_action_exchange_id" ON "order_change_action" (
+        exchange_id
+    )
+    WHERE exchange_id IS NOT NULL AND deleted_at IS NOT NULL;
+    
+    
+
+    CREATE TABLE IF NOT EXISTS "return" (
+        "id" TEXT NOT NULL,
+        "order_id" TEXT NOT NULL,
+        "claim_id" TEXT NULL,
+        "exchange_id" TEXT NULL,
+        "order_version" INTEGER NOT NULL,
+        "display_id" SERIAL,
+        "status" text NOT NULL,
+        "no_notification" boolean NULL,
+        "refund_amount" NUMERIC NULL,
+        "raw_refund_amount" JSONB NULL,
+        "metadata" jsonb NULL,
+        "created_at" timestamptz NOT NULL DEFAULT now(),
+        "updated_at" timestamptz NOT NULL DEFAULT now(),
+        "deleted_at" timestamptz NULL,
+        "received_at" timestamptz NULL,
+        "canceled_at" timestamptz NULL,
+        CONSTRAINT "return_pkey" PRIMARY KEY ("id")
+    );
+    
+    CREATE TYPE return_status_enum AS ENUM (
+        'requested',
+        'received',
+        'partially_received',
+        'canceled'
+    );
+    ALTER TABLE "return" ALTER COLUMN status DROP DEFAULT;
+    ALTER TABLE "return" ALTER COLUMN status TYPE return_status_enum USING (status::text::return_status_enum);
+    ALTER TABLE "return" ALTER COLUMN status SET DEFAULT 'requested';
+
+    CREATE INDEX IF NOT EXISTS "IDX_return_order_id" ON "return" (
+        order_id
+    )
+    WHERE deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_return_claim_id" ON "return" (
+        claim_id
+    )
+    WHERE claim_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_return_exchange_id" ON "return" (
+        exchange_id
+    )
+    WHERE exchange_id IS NOT NULL AND deleted_at IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "IDX_return_display_id" ON "return" (
+        display_id
+    ) 
+    WHERE deleted_at IS NOT NULL;
+    `
+    this.addSql(sql)
+  }
+}

packages/modules/order/src/models/index.ts

@@ -8,6 +8,7 @@ export { default as OrderChangeAction } from "./order-change-action"
 export { default as OrderItem } from "./order-item"
 export { default as OrderShippingMethod } from "./order-shipping-method"
 export { default as OrderSummary } from "./order-summary"
+export { default as Return } from "./return"
 export { default as ReturnReason } from "./return-reason"
 export { default as ShippingMethod } from "./shipping-method"
 export { default as ShippingMethodAdjustment } from "./shipping-method-adjustment"

packages/modules/order/src/models/order-change-action.ts

@@ -14,6 +14,7 @@ import {
   PrimaryKey,
   Property,
 } from "@mikro-orm/core"
+import { Return } from "@models"
 import Order from "./order"
 import OrderChange from "./order-change"
 
@@ -22,16 +23,31 @@ type OptionalLineItemProps = DAL.EntityDateColumns
 const OrderChangeIdIndex = createPsqlIndexStatementHelper({
   tableName: "order_change_action",
   columns: "order_change_id",
+  where: "deleted_at IS NOT NULL",
 })
 
 const OrderIdIndex = createPsqlIndexStatementHelper({
   tableName: "order_change_action",
   columns: "order_id",
+  where: "deleted_at IS NOT NULL",
+})
+
+const ReturnIdIndex = createPsqlIndexStatementHelper({
+  tableName: "order_change_action",
+  columns: "return_id",
+  where: "return_id IS NOT NULL AND deleted_at IS NOT NULL",
+})
+
+const DeletedAtIndex = createPsqlIndexStatementHelper({
+  tableName: "order_change_action",
+  columns: "deleted_at",
+  where: "deleted_at IS NOT NULL",
 })
 
 const ActionOrderingIndex = createPsqlIndexStatementHelper({
   tableName: "order_change_action",
   columns: "ordering",
+  where: "deleted_at IS NOT NULL",
 })
 
 @Entity({ tableName: "order_change_action" })
@@ -62,6 +78,21 @@ export default class OrderChangeAction {
   })
   order: Order | null = null
 
+  @ManyToOne({
+    entity: () => Return,
+    mapToPk: true,
+    fieldName: "return_id",
+    columnType: "text",
+    nullable: true,
+  })
+  @ReturnIdIndex.MikroORMIndex()
+  return_id: string | null = null
+
+  @ManyToOne(() => Return, {
+    persist: false,
+  })
+  return: Return
+
   @Property({ columnType: "integer", nullable: true })
   version: number | null = null
 
@@ -133,6 +164,10 @@ export default class OrderChangeAction {
   })
   updated_at: Date
 
+  @Property({ columnType: "timestamptz", nullable: true })
+  @DeletedAtIndex.MikroORMIndex()
+  deleted_at: Date | null = null
+
   @BeforeCreate()
   onCreate() {
     this.id = generateEntityId(this.id, "ordchact")

packages/modules/order/src/models/order-change.ts

@@ -1,6 +1,5 @@
 import { DAL } from "@medusajs/types"
 import {
-  OrderChangeStatus,
   createPsqlIndexStatementHelper,
   generateEntityId,
 } from "@medusajs/utils"
@@ -17,6 +16,8 @@ import {
   PrimaryKey,
   Property,
 } from "@mikro-orm/core"
+import { Return } from "@models"
+import { OrderChangeStatus, OrderChangeType } from "@types"
 import Order from "./order"
 import OrderChangeAction from "./order-change-action"
 
@@ -25,16 +26,37 @@ type OptionalLineItemProps = DAL.EntityDateColumns
 const OrderIdIndex = createPsqlIndexStatementHelper({
   tableName: "order_change",
   columns: "order_id",
+  where: "deleted_at IS NOT NULL",
+})
+
+const ReturnIdIndex = createPsqlIndexStatementHelper({
+  tableName: "order_change",
+  columns: "return_id",
+  where: "return_id IS NOT NULL AND deleted_at IS NOT NULL",
 })
 
 const OrderChangeStatusIndex = createPsqlIndexStatementHelper({
   tableName: "order_change",
   columns: "status",
+  where: "deleted_at IS NOT NULL",
+})
+
+const OrderChangeTypeIndex = createPsqlIndexStatementHelper({
+  tableName: "order_change",
+  columns: "change_type",
+  where: "deleted_at IS NOT NULL",
+})
+
+const DeletedAtIndex = createPsqlIndexStatementHelper({
+  tableName: "order_change",
+  columns: "deleted_at",
+  where: "deleted_at IS NOT NULL",
 })
 
 const VersionIndex = createPsqlIndexStatementHelper({
   tableName: "order_change",
   columns: ["order_id", "version"],
+  where: "deleted_at IS NOT NULL",
 })
 
 @Entity({ tableName: "order_change" })
@@ -60,10 +82,29 @@ export default class OrderChange {
   })
   order: Order
 
+  @ManyToOne({
+    entity: () => Return,
+    mapToPk: true,
+    fieldName: "return_id",
+    columnType: "text",
+    nullable: true,
+  })
+  @ReturnIdIndex.MikroORMIndex()
+  return_id: string | null = null
+
+  @ManyToOne(() => Return, {
+    persist: false,
+  })
+  return: Return
+
   @Property({ columnType: "integer" })
   @VersionIndex.MikroORMIndex()
   version: number
 
+  @Enum({ items: () => OrderChangeType, nullable: true })
+  @OrderChangeTypeIndex.MikroORMIndex()
+  change_type: OrderChangeType | null = null
+
   @OneToMany(() => OrderChangeAction, (action) => action.order_change, {
     cascade: [Cascade.PERSIST, "sotf-remove" as Cascade],
   })
@@ -142,6 +183,10 @@ export default class OrderChange {
   })
   updated_at: Date
 
+  @Property({ columnType: "timestamptz", nullable: true })
+  @DeletedAtIndex.MikroORMIndex()
+  deleted_at: Date | null = null
+
   @BeforeCreate()
   onCreate() {
     this.id = generateEntityId(this.id, "ordch")

packages/modules/order/src/models/order-item.ts

@@ -14,6 +14,7 @@ import {
   PrimaryKey,
   Property,
 } from "@mikro-orm/core"
+import { Return } from "@models"
 import LineItem from "./line-item"
 import Order from "./order"
 
@@ -25,6 +26,12 @@ const OrderIdIndex = createPsqlIndexStatementHelper({
   where: "deleted_at IS NOT NULL",
 })
 
+const ReturnIdIndex = createPsqlIndexStatementHelper({
+  tableName: "order_item",
+  columns: "return_id",
+  where: "return_id IS NOT NULL AND deleted_at IS NOT NULL",
+})
+
 const OrderVersionIndex = createPsqlIndexStatementHelper({
   tableName: "order_item",
   columns: ["version"],
@@ -59,15 +66,30 @@ export default class OrderItem {
   @OrderIdIndex.MikroORMIndex()
   order_id: string
 
-  @Property({ columnType: "integer" })
-  @OrderVersionIndex.MikroORMIndex()
-  version: number
-
   @ManyToOne(() => Order, {
     persist: false,
   })
   order: Order
 
+  @ManyToOne({
+    entity: () => Return,
+    mapToPk: true,
+    fieldName: "return_id",
+    columnType: "text",
+    nullable: true,
+  })
+  @ReturnIdIndex.MikroORMIndex()
+  return_id: string | null = null
+
+  @ManyToOne(() => Return, {
+    persist: false,
+  })
+  return: Return
+
+  @Property({ columnType: "integer" })
+  @OrderVersionIndex.MikroORMIndex()
+  version: number
+
   @ManyToOne({
     entity: () => LineItem,
     fieldName: "item_id",

packages/modules/order/src/models/order-shipping-method.ts

@@ -12,6 +12,7 @@ import {
   PrimaryKey,
   Property,
 } from "@mikro-orm/core"
+import { Return } from "@models"
 import Order from "./order"
 import ShippingMethod from "./shipping-method"
 
@@ -23,6 +24,12 @@ const OrderIdIndex = createPsqlIndexStatementHelper({
   where: "deleted_at IS NOT NULL",
 })
 
+const ReturnIdIndex = createPsqlIndexStatementHelper({
+  tableName: "order_shipping",
+  columns: "return_id",
+  where: "return_id IS NOT NULL AND deleted_at IS NOT NULL",
+})
+
 const OrderVersionIndex = createPsqlIndexStatementHelper({
   tableName: "order_shipping",
   columns: ["version"],
@@ -57,15 +64,30 @@ export default class OrderShippingMethod {
   @OrderIdIndex.MikroORMIndex()
   order_id: string
 
-  @Property({ columnType: "integer" })
-  @OrderVersionIndex.MikroORMIndex()
-  version: number
-
   @ManyToOne(() => Order, {
     persist: false,
   })
   order: Order
 
+  @ManyToOne({
+    entity: () => Return,
+    mapToPk: true,
+    fieldName: "return_id",
+    columnType: "text",
+    nullable: true,
+  })
+  @ReturnIdIndex.MikroORMIndex()
+  return_id: string | null = null
+
+  @ManyToOne(() => Return, {
+    persist: false,
+  })
+  return: Return
+
+  @Property({ columnType: "integer" })
+  @OrderVersionIndex.MikroORMIndex()
+  version: number
+
   @ManyToOne({
     entity: () => ShippingMethod,
     fieldName: "shipping_method_id",

packages/modules/order/src/models/return.ts

@@ -0,0 +1,184 @@
+import { BigNumberRawValue, DAL } from "@medusajs/types"
+import {
+  BigNumber,
+  MikroOrmBigNumberProperty,
+  ReturnStatus,
+  createPsqlIndexStatementHelper,
+  generateEntityId,
+} from "@medusajs/utils"
+import {
+  BeforeCreate,
+  Cascade,
+  Collection,
+  Entity,
+  Enum,
+  ManyToOne,
+  OnInit,
+  OneToMany,
+  OptionalProps,
+  PrimaryKey,
+  Property,
+} from "@mikro-orm/core"
+import { OrderItem, OrderShippingMethod } from "@models"
+import Order from "./order"
+
+type OptionalReturnProps = DAL.EntityDateColumns
+
+const DisplayIdIndex = createPsqlIndexStatementHelper({
+  tableName: "return",
+  columns: "display_id",
+  where: "deleted_at IS NOT NULL",
+})
+
+const ReturnDeletedAtIndex = createPsqlIndexStatementHelper({
+  tableName: "return",
+  columns: "deleted_at",
+  where: "deleted_at IS NOT NULL",
+})
+
+const OrderIdIndex = createPsqlIndexStatementHelper({
+  tableName: "return",
+  columns: ["order_id"],
+  where: "deleted_at IS NOT NULL",
+})
+
+const ClaimIdIndex = createPsqlIndexStatementHelper({
+  tableName: "return",
+  columns: ["claim_id"],
+  where: "claim_id IS NOT NULL AND deleted_at IS NOT NULL",
+})
+
+const ExchageIdIndex = createPsqlIndexStatementHelper({
+  tableName: "return",
+  columns: ["exchange_id"],
+  where: "exchange_id IS NOT NULL AND deleted_at IS NOT NULL",
+})
+
+@Entity({ tableName: "return" })
+export default class Return {
+  [OptionalProps]?: OptionalReturnProps
+
+  @PrimaryKey({ columnType: "text" })
+  id: string
+
+  @ManyToOne({
+    entity: () => Order,
+    mapToPk: true,
+    fieldName: "order_id",
+    columnType: "text",
+  })
+  @OrderIdIndex.MikroORMIndex()
+  order_id: string
+
+  @ManyToOne(() => Order, {
+    persist: false,
+  })
+  order: Order
+
+  /*
+  @ManyToOne({
+    entity: () => Claim,
+    mapToPk: true,
+    fieldName: "claim_id",
+    columnType: "text",
+    nullable: true,
+  })
+  @ClaimIdIndex.MikroORMIndex()
+  claim_id: string | null
+
+  @ManyToOne(() => Claim, {
+    persist: false,
+  })
+  claim: Claim | null
+
+  @ManyToOne({
+    entity: () => Exchange,
+    mapToPk: true,
+    fieldName: "exchange_id",
+    columnType: "text",
+    nullable: true,
+  })
+  @ExchangeIdIndex.MikroORMIndex()
+  exchange_id: string | null
+
+  @ManyToOne(() => Exchange, {
+    persist: false,
+  })
+  exchange: Exchange | null
+  */
+
+  @Property({
+    columnType: "integer",
+  })
+  order_version: number
+
+  @Property({ autoincrement: true, primary: false })
+  @DisplayIdIndex.MikroORMIndex()
+  display_id: number
+
+  @Enum({ items: () => ReturnStatus, default: ReturnStatus.REQUESTED })
+  status: ReturnStatus = ReturnStatus.REQUESTED
+
+  @Property({ columnType: "boolean", nullable: true })
+  no_notification: boolean | null = null
+
+  @MikroOrmBigNumberProperty({
+    nullable: true,
+  })
+  refund_amount: BigNumber | number
+
+  @Property({ columnType: "jsonb", nullable: true })
+  raw_refund_amount: BigNumberRawValue
+
+  @OneToMany(() => OrderItem, (itemDetail) => itemDetail.return, {
+    cascade: [Cascade.PERSIST],
+  })
+  items = new Collection<OrderItem>(this)
+
+  @OneToMany(
+    () => OrderShippingMethod,
+    (shippingMethod) => shippingMethod.return,
+    {
+      cascade: [Cascade.PERSIST],
+    }
+  )
+  shipping_methods = new Collection<OrderShippingMethod>(this)
+
+  @Property({ columnType: "jsonb", nullable: true })
+  metadata: Record<string, unknown> | null = null
+
+  @Property({
+    onCreate: () => new Date(),
+    columnType: "timestamptz",
+    defaultRaw: "now()",
+  })
+  created_at: Date
+
+  @Property({
+    onCreate: () => new Date(),
+    onUpdate: () => new Date(),
+    columnType: "timestamptz",
+    defaultRaw: "now()",
+  })
+  updated_at: Date
+
+  @Property({ columnType: "timestamptz", nullable: true })
+  @ReturnDeletedAtIndex.MikroORMIndex()
+  deleted_at: Date | null = null
+
+  @Property({ columnType: "timestamptz", nullable: true })
+  received_at: Date | null = null
+
+  @Property({ columnType: "timestamptz", nullable: true })
+  canceled_at: Date | null = null
+
+  @BeforeCreate()
+  onCreate() {
+    this.id = generateEntityId(this.id, "return")
+  }
+
+  @OnInit()
+  onInit() {
+    this.id = generateEntityId(this.id, "return")
+  }
+}

packages/modules/order/src/models/transaction.ts

@@ -14,6 +14,7 @@ import {
   PrimaryKey,
   Property,
 } from "@mikro-orm/core"
+import { Return } from "@models"
 import Order from "./order"
 
 type OptionalLineItemProps = DAL.EntityDateColumns
@@ -21,16 +22,25 @@ type OptionalLineItemProps = DAL.EntityDateColumns
 const ReferenceIdIndex = createPsqlIndexStatementHelper({
   tableName: "order_transaction",
   columns: "reference_id",
+  where: "deleted_at IS NOT NULL",
 })
 
 const OrderIdIndex = createPsqlIndexStatementHelper({
   tableName: "order_transaction",
   columns: "order_id",
+  where: "deleted_at IS NOT NULL",
+})
+
+const ReturnIdIndex = createPsqlIndexStatementHelper({
+  tableName: "order_transaction",
+  columns: "return_id",
+  where: "return_id IS NOT NULL AND deleted_at IS NOT NULL",
 })
 
 const CurrencyCodeIndex = createPsqlIndexStatementHelper({
   tableName: "order_transaction",
   columns: "currency_code",
+  where: "deleted_at IS NOT NULL",
 })
 
 const DeletedAtIndex = createPsqlIndexStatementHelper({
@@ -68,6 +78,21 @@ export default class Transaction {
   })
   order: Order
 
+  @ManyToOne({
+    entity: () => Return,
+    mapToPk: true,
+    fieldName: "return_id",
+    columnType: "text",
+    nullable: true,
+  })
+  @ReturnIdIndex.MikroORMIndex()
+  return_id: string | null = null
+
+  @ManyToOne(() => Return, {
+    persist: false,
+  })
+  return: Return
+
   @Property({
     columnType: "integer",
     defaultRaw: "1",

packages/modules/order/src/repositories/index.ts

@@ -1,2 +1,3 @@
 export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils"
-export * from "./order"
+export { OrderRepository } from "./order"
+export { ReturnRepository } from "./return"

packages/modules/order/src/repositories/order.ts

@@ -1,121 +1,9 @@
-import { Context, DAL } from "@medusajs/types"
 import { DALUtils } from "@medusajs/utils"
-import { LoadStrategy } from "@mikro-orm/core"
-import { EntityManager } from "@mikro-orm/postgresql"
 import { Order } from "@models"
-import { mapRepositoryToOrderModel } from "../utils/transform-order"
+import { setFindMethods } from "../utils/base-repository-find"
 
 export class OrderRepository extends DALUtils.mikroOrmBaseRepositoryFactory<Order>(
   Order
-) {
+) {}
-  async find(
-    options?: DAL.FindOptions<Order>,
-    context?: Context
-  ): Promise<Order[]> {
-    const manager = this.getActiveManager<EntityManager>(context)
-    const knex = manager.getKnex()
 
-    const findOptions_ = { ...options } as any
+setFindMethods(OrderRepository, Order)
-    findOptions_.options ??= {}
-    findOptions_.where ??= {}
-
-    if (!("strategy" in findOptions_.options)) {
-      if (findOptions_.options.limit != null || findOptions_.options.offset) {
-        Object.assign(findOptions_.options, {
-          strategy: LoadStrategy.SELECT_IN,
-        })
-      } else {
-        Object.assign(findOptions_.options, {
-          strategy: LoadStrategy.JOINED,
-        })
-      }
-    }
-
-    const config = mapRepositoryToOrderModel(findOptions_)
-
-    let defaultVersion = knex.raw(`"o0"."version"`)
-    const strategy = config.options.strategy ?? LoadStrategy.JOINED
-    if (strategy === LoadStrategy.SELECT_IN) {
-      const sql = manager
-        .qb(Order, "_sub0")
-        .select("version")
-        .where({ id: knex.raw(`"o0"."order_id"`) })
-        .getKnexQuery()
-        .toString()
-
-      defaultVersion = knex.raw(`(${sql})`)
-    }
-
-    const version = config.where.version ?? defaultVersion
-    delete config.where?.version
-
-    config.options.populateWhere ??= {}
-
-    config.options.populateWhere.items ??= {}
-    config.options.populateWhere.items.version = version
-
-    config.options.populateWhere.summary ??= {}
-    config.options.populateWhere.summary.version = version
-
-    config.options.populateWhere.shipping_methods ??= {}
-    config.options.populateWhere.shipping_methods.version = version
-
-    if (!config.options.orderBy) {
-      config.options.orderBy = { id: "ASC" }
-    }
-
-    return await manager.find(Order, config.where, config.options)
-  }
-
-  async findAndCount(
-    findOptions: DAL.FindOptions<Order> = { where: {} },
-    context: Context = {}
-  ): Promise<[Order[], number]> {
-    const manager = this.getActiveManager<EntityManager>(context)
-    const knex = manager.getKnex()
-
-    const findOptions_ = { ...findOptions } as any
-    findOptions_.options ??= {}
-    findOptions_.where ??= {}
-
-    if (!("strategy" in findOptions_.options)) {
-      Object.assign(findOptions_.options, {
-        strategy: LoadStrategy.SELECT_IN,
-      })
-    }
-
-    const config = mapRepositoryToOrderModel(findOptions_)
-
-    let defaultVersion = knex.raw(`"o0"."version"`)
-    const strategy = config.options.strategy ?? LoadStrategy.JOINED
-    if (strategy === LoadStrategy.SELECT_IN) {
-      const sql = manager
-        .qb(Order, "_sub0")
-        .select("version")
-        .where({ id: knex.raw(`"o0"."order_id"`) })
-        .getKnexQuery()
-        .toString()
-
-      defaultVersion = knex.raw(`(${sql})`)
-    }
-
-    const version = config.where.version ?? defaultVersion
-    delete config.where.version
-
-    config.options.populateWhere ??= {}
-    config.options.populateWhere.items ??= {}
-    config.options.populateWhere.items.version = version
-
-    config.options.populateWhere.summary ??= {}
-    config.options.populateWhere.summary.version = version
-
-    config.options.populateWhere.shipping_methods ??= {}
-    config.options.populateWhere.shipping_methods.version = version
-
-    if (!config.options.orderBy) {
-      config.options.orderBy = { id: "ASC" }
-    }
-
-    return await manager.findAndCount(Order, config.where, config.options)
-  }
-}

packages/modules/order/src/repositories/return.ts

@@ -0,0 +1,9 @@
+import { DALUtils } from "@medusajs/utils"
+import { Return } from "@models"
+import { setFindMethods } from "../utils/base-repository-find"
+
+export class ReturnRepository extends DALUtils.mikroOrmBaseRepositoryFactory<Return>(
+  Return
+) {}
+
+setFindMethods(ReturnRepository, Return)

packages/modules/order/src/services/actions/cancel-fulfillment.ts

@@ -0,0 +1,38 @@
+import { Context, OrderTypes } from "@medusajs/types"
+import { ChangeActionType } from "../../utils"
+
+export async function cancelFulfillment(
+  this: any,
+  data: OrderTypes.CancelOrderFulfillmentDTO,
+  sharedContext?: Context
+): Promise<void> {
+  const items = data.items.map((item) => {
+    return {
+      action: ChangeActionType.CANCEL_ITEM_FULFILLMENT,
+      internal_note: item.internal_note,
+      reference: data.reference,
+      reference_id: data.reference_id,
+      claim_id: data.claim_id,
+      exchange_id: data.exchange_id,
+      details: {
+        reference_id: item.id,
+        quantity: item.quantity,
+        metadata: item.metadata,
+      },
+    }
+  })
+
+  const change = await this.createOrderChange_(
+    {
+      order_id: data.order_id,
+      description: data.description,
+      internal_note: data.internal_note,
+      created_by: data.created_by,
+      metadata: data.metadata,
+      actions: items,
+    },
+    sharedContext
+  )
+
+  await this.confirmOrderChange(change[0].id, sharedContext)
+}

packages/modules/order/src/services/actions/create-return.ts

@@ -0,0 +1,113 @@
+import {
+  Context,
+  CreateOrderChangeActionDTO,
+  OrderTypes,
+} from "@medusajs/types"
+import {
+  ReturnStatus,
+  getShippingMethodsTotals,
+  isString,
+} from "@medusajs/utils"
+import { OrderChangeType } from "@types"
+import { ChangeActionType } from "../../utils"
+
+export async function createReturn(
+  this: any,
+  data: OrderTypes.CreateOrderReturnDTO,
+  sharedContext?: Context
+) {
+  const order = await this.orderService_.retrieve(
+    data.order_id,
+    {
+      relations: ["items"],
+    },
+    sharedContext
+  )
+
+  const [returnRef] = await this.createReturns(
+    [
+      {
+        order_id: data.order_id,
+        order_version: order.version,
+        status: ReturnStatus.REQUESTED,
+        // refund_amount: data.refund_amount ?? null,
+      },
+    ],
+    sharedContext
+  )
+
+  let shippingMethodId
+
+  if (!isString(data.shipping_method)) {
+    const methods = await this.createShippingMethods(
+      [
+        {
+          order_id: data.order_id,
+          ...data.shipping_method,
+        },
+      ],
+      sharedContext
+    )
+    shippingMethodId = methods[0].id
+  } else {
+    shippingMethodId = data.shipping_method
+  }
+
+  const method = await this.retrieveShippingMethod(
+    shippingMethodId,
+    {
+      relations: ["tax_lines", "adjustments"],
+    },
+    sharedContext
+  )
+
+  const calculatedAmount = getShippingMethodsTotals([method as any], {})[
+    method.id
+  ]
+
+  const actions: CreateOrderChangeActionDTO[] = data.items.map((item) => {
+    return {
+      action: ChangeActionType.RETURN_ITEM,
+      return_id: returnRef.id,
+      internal_note: item.internal_note,
+      reference: "return",
+      reference_id: returnRef.id,
+      details: {
+        reference_id: item.id,
+        return_id: returnRef.id,
+        quantity: item.quantity,
+        metadata: item.metadata,
+      },
+    }
+  })
+
+  if (shippingMethodId) {
+    actions.push({
+      action: ChangeActionType.SHIPPING_ADD,
+      reference: "order_shipping_method",
+      reference_id: shippingMethodId,
+      return_id: returnRef.id,
+      amount: calculatedAmount.total,
+    })
+  }
+
+  const change = await this.createOrderChange_(
+    {
+      order_id: data.order_id,
+      return_id: returnRef.id,
+      change_type: OrderChangeType.RETURN,
+      reference: "return",
+      reference_id: returnRef.id,
+      description: data.description,
+      internal_note: data.internal_note,
+      created_by: data.created_by,
+      metadata: data.metadata,
+      actions,
+    },
+    sharedContext
+  )
+
+  await this.confirmOrderChange(change[0].id, sharedContext)
+
+  return returnRef
+}

packages/modules/order/src/services/actions/index.ts

@@ -0,0 +1,5 @@
+export * from "./cancel-fulfillment"
+export * from "./create-return"
+export * from "./receive-return"
+export * from "./register-fulfillment"
+export * from "./register-shipment"

packages/modules/order/src/services/actions/receive-return.ts

@@ -0,0 +1,73 @@
+import { Context, OrderTypes } from "@medusajs/types"
+import { MathBN, ReturnStatus } from "@medusajs/utils"
+import { ChangeActionType } from "../../utils"
+
+export async function receiveReturn(
+  this: any,
+  data: OrderTypes.ReceiveOrderReturnDTO,
+  sharedContext?: Context
+) {
+  const returnEntry = await this.retrieveReturn(
+    data.return_id,
+    {
+      select: ["id", "order_id"],
+      relations: ["items"],
+    },
+    sharedContext
+  )
+
+  const items = data.items.map((item) => {
+    return {
+      action: ChangeActionType.RECEIVE_RETURN_ITEM,
+      internal_note: item.internal_note,
+      reference: data.reference,
+      reference_id: data.reference_id,
+      details: {
+        reference_id: item.id,
+        quantity: item.quantity,
+        metadata: item.metadata,
+      },
+    }
+  })
+
+  const change = await this.createOrderChange_(
+    {
+      order_id: returnEntry.order_id,
+      reference: "return",
+      reference_id: returnEntry.id,
+      description: data.description,
+      internal_note: data.internal_note,
+      created_by: data.created_by,
+      metadata: data.metadata,
+      actions: items,
+    },
+    sharedContext
+  )
+
+  await this.confirmOrderChange(change[0].id, sharedContext)
+
+  const hasReceivedAllItems = returnEntry.items.every((item) => {
+    const retItem = items.find((dtItem) => {
+      return item.detail.item_id === dtItem.details.reference_id
+    })
+    const quantity = retItem ? retItem.details.quantity : 0
+    return MathBN.eq(
+      MathBN.sub(item.detail.return_requested_quantity, quantity),
+      0
+    )
+  })
+
+  const retData = hasReceivedAllItems
+    ? { status: ReturnStatus.RECEIVED, received_at: new Date() }
+    : { status: ReturnStatus.PARTIALLY_RECEIVED }
+
+  const returnRef = await this.updateReturns(
+    {
+      selector: { id: returnEntry.id },
+      data: retData,
+    },
+    sharedContext
+  )
+
+  return returnRef
+}

packages/modules/order/src/services/actions/register-fulfillment.ts

@@ -0,0 +1,36 @@
+import { Context, OrderTypes } from "@medusajs/types"
+import { ChangeActionType } from "../../utils"
+
+export async function registerFulfillment(
+  this: any,
+  data: OrderTypes.RegisterOrderFulfillmentDTO,
+  sharedContext?: Context
+): Promise<void> {
+  const items = data.items.map((item) => {
+    return {
+      action: ChangeActionType.FULFILL_ITEM,
+      internal_note: item.internal_note,
+      reference: data.reference,
+      reference_id: data.reference_id,
+      details: {
+        reference_id: item.id,
+        quantity: item.quantity,
+        metadata: item.metadata,
+      },
+    }
+  })
+
+  const change = await this.createOrderChange_(
+    {
+      order_id: data.order_id,
+      description: data.description,
+      internal_note: data.internal_note,
+      created_by: data.created_by,
+      metadata: data.metadata,
+      actions: items,
+    },
+    sharedContext
+  )
+
+  await this.confirmOrderChange(change[0].id, sharedContext)
+}

packages/modules/order/src/services/actions/register-shipment.ts

@@ -0,0 +1,50 @@
+import {
+  Context,
+  CreateOrderChangeActionDTO,
+  OrderTypes,
+} from "@medusajs/types"
+import { ChangeActionType } from "../../utils"
+
+export async function registerShipment(
+  this: any,
+  data: OrderTypes.RegisterOrderShipmentDTO,
+  sharedContext?: Context
+): Promise<void> {
+  let shippingMethodId
+
+  const actions: CreateOrderChangeActionDTO[] = data.items.map((item) => {
+    return {
+      action: ChangeActionType.SHIP_ITEM,
+      internal_note: item.internal_note,
+      reference: data.reference,
+      reference_id: data.reference_id,
+      details: {
+        reference_id: item.id,
+        quantity: item.quantity,
+        metadata: item.metadata,
+      },
+    }
+  })
+
+  if (shippingMethodId) {
+    actions.push({
+      action: ChangeActionType.SHIPPING_ADD,
+      reference: data.reference,
+      reference_id: shippingMethodId,
+    })
+  }
+
+  const change = await this.createOrderChange_(
+    {
+      order_id: data.order_id,
+      description: data.description,
+      internal_note: data.internal_note,
+      created_by: data.created_by,
+      metadata: data.metadata,
+      actions,
+    },
+    sharedContext
+  )
+
+  await this.confirmOrderChange(change[0].id, sharedContext)
+}

packages/modules/order/src/services/order-change-service.ts

@@ -11,10 +11,10 @@ import {
   MedusaContext,
   MedusaError,
   ModulesSdkUtils,
-  OrderChangeStatus,
   deduplicate,
 } from "@medusajs/utils"
 import { OrderChange } from "@models"
+import { OrderChangeStatus } from "@types"
 
 type InjectedDependencies = {
   orderChangeRepository: DAL.RepositoryService

packages/modules/order/src/services/order-module-service.ts

@@ -1,7 +1,6 @@
 import {
   BigNumberInput,
   Context,
-  CreateOrderChangeActionDTO,
   DAL,
   FindConfig,
   InternalModuleDeclaration,
@@ -20,7 +19,6 @@ import {
   createRawPropertiesFromBigNumber,
   decorateCartTotals,
   deduplicate,
-  getShippingMethodsTotals,
   InjectManager,
   InjectTransactionManager,
   isObject,
@@ -29,7 +27,6 @@ import {
   MedusaContext,
   MedusaError,
   ModulesSdkUtils,
-  OrderChangeStatus,
   OrderStatus,
   promiseAll,
   transformPropertiesToBigNumber,
@@ -45,6 +42,7 @@ import {
   OrderItem,
   OrderShippingMethod,
   OrderSummary,
+  Return,
   ReturnReason,
   ShippingMethod,
   ShippingMethodAdjustment,
@@ -52,19 +50,26 @@ import {
   Transaction,
 } from "@models"
 import {
+  CreateOrderChangeDTO,
   CreateOrderItemDTO,
   CreateOrderLineItemDTO,
   CreateOrderLineItemTaxLineDTO,
   CreateOrderShippingMethodDTO,
   CreateOrderShippingMethodTaxLineDTO,
+  OrderChangeStatus,
   UpdateOrderItemDTO,
   UpdateOrderLineItemDTO,
   UpdateOrderLineItemTaxLineDTO,
   UpdateOrderShippingMethodTaxLineDTO,
 } from "@types"
 import { entityNameToLinkableKeysMap, joinerConfig } from "../joiner-config"
-import { calculateOrderChange, ChangeActionType } from "../utils"
+import {
-import { formatOrder } from "../utils/transform-order"
+  applyChangesToOrder,
+  ApplyOrderChangeDTO,
+  calculateOrderChange,
+  formatOrder,
+} from "../utils"
+import * as BundledActions from "./actions"
 import OrderChangeService from "./order-change-service"
 import OrderService from "./order-service"
 
@@ -85,6 +90,7 @@ type InjectedDependencies = {
   orderSummaryService: ModulesSdkTypes.InternalModuleService<any>
   orderShippingMethodService: ModulesSdkTypes.InternalModuleService<any>
   returnReasonService: ModulesSdkTypes.InternalModuleService<any>
+  returnService: ModulesSdkTypes.InternalModuleService<any>
 }
 
 const generateMethodForModels = [
@@ -102,6 +108,7 @@ const generateMethodForModels = [
   OrderSummary,
   OrderShippingMethod,
   ReturnReason,
+  Return,
 ]
 
 export default class OrderModuleService<
@@ -119,7 +126,8 @@ export default class OrderModuleService<
     TOrderItem extends OrderItem = OrderItem,
     TOrderSummary extends OrderSummary = OrderSummary,
     TOrderShippingMethod extends OrderShippingMethod = OrderShippingMethod,
-    TReturnReason extends ReturnReason = ReturnReason
+    TReturnReason extends ReturnReason = ReturnReason,
+    TReturn extends Return = Return
   >
   extends ModulesSdkUtils.abstractModuleServiceFactory<
     InjectedDependencies,
@@ -141,6 +149,7 @@ export default class OrderModuleService<
       ReturnReason: { dto: OrderTypes.OrderReturnReasonDTO }
       OrderSummary: { dto: OrderTypes.OrderSummaryDTO }
       Transaction: { dto: OrderTypes.OrderTransactionDTO }
+      Return: { dto: any } // TODO: Add return dto
     }
   >(Order, generateMethodForModels, entityNameToLinkableKeysMap)
   implements IOrderModuleService
@@ -161,6 +170,7 @@ export default class OrderModuleService<
   protected orderSummaryService_: ModulesSdkTypes.InternalModuleService<TOrderSummary>
   protected orderShippingMethodService_: ModulesSdkTypes.InternalModuleService<TOrderShippingMethod>
   protected returnReasonService_: ModulesSdkTypes.InternalModuleService<TReturnReason>
+  protected returnService_: ModulesSdkTypes.InternalModuleService<TReturn>
 
   constructor(
     {
@@ -180,6 +190,7 @@ export default class OrderModuleService<
       orderSummaryService,
       orderShippingMethodService,
       returnReasonService,
+      returnService,
     }: InjectedDependencies,
     protected readonly moduleDeclaration: InternalModuleDeclaration
   ) {
@@ -202,6 +213,7 @@ export default class OrderModuleService<
     this.orderSummaryService_ = orderSummaryService
     this.orderShippingMethodService_ = orderShippingMethodService
     this.returnReasonService_ = returnReasonService
+    this.returnService_ = returnService
   }
 
   __joinerConfig(): ModuleJoinerConfig {
@@ -271,7 +283,7 @@ export default class OrderModuleService<
   async retrieve(
     id: string,
     config?: FindConfig<any> | undefined,
-    sharedContext?: Context | undefined
+    @MedusaContext() sharedContext?: Context | undefined
   ): Promise<OrderTypes.OrderDTO> {
     config ??= {}
     const includeTotals = this.shouldIncludeTotals(config)
@@ -284,7 +296,7 @@ export default class OrderModuleService<
   async list(
     filters?: any,
     config?: FindConfig<any> | undefined,
-    sharedContext?: Context | undefined
+    @MedusaContext() sharedContext?: Context | undefined
   ): Promise<OrderTypes.OrderDTO[]> {
     config ??= {}
     const includeTotals = this.shouldIncludeTotals(config)
@@ -299,7 +311,7 @@ export default class OrderModuleService<
   async listAndCount(
     filters?: any,
     config?: FindConfig<any> | undefined,
-    sharedContext?: Context | undefined
+    @MedusaContext() sharedContext?: Context | undefined
   ): Promise<[OrderTypes.OrderDTO[], number]> {
     config ??= {}
     const includeTotals = this.shouldIncludeTotals(config)
@@ -316,6 +328,57 @@ export default class OrderModuleService<
     ]
   }
 
+  // @ts-ignore
+  async retrieveReturn(
+    id: string,
+    config?: FindConfig<any> | undefined,
+    @MedusaContext() sharedContext?: Context | undefined
+  ): Promise<OrderTypes.ReturnDTO> {
+    config ??= {}
+    const includeTotals = this.shouldIncludeTotals(config)
+
+    const returnOrder = await super.retrieveReturn(id, config, sharedContext)
+
+    return formatOrder(returnOrder, { includeTotals }) as OrderTypes.ReturnDTO
+  }
+
+  // @ts-ignore
+  async listReturns(
+    filters?: any,
+    config?: FindConfig<any> | undefined,
+    @MedusaContext() sharedContext?: Context | undefined
+  ): Promise<OrderTypes.ReturnDTO[]> {
+    config ??= {}
+    const includeTotals = this.shouldIncludeTotals(config)
+
+    const returnOrders = await super.listReturns(filters, config, sharedContext)
+
+    return formatOrder(returnOrders, {
+      includeTotals,
+    }) as OrderTypes.ReturnDTO[]
+  }
+
+  // @ts-ignore
+  async listAndCountReturns(
+    filters?: any,
+    config?: FindConfig<any> | undefined,
+    @MedusaContext() sharedContext?: Context | undefined
+  ): Promise<[OrderTypes.ReturnDTO[], number]> {
+    config ??= {}
+    const includeTotals = this.shouldIncludeTotals(config)
+
+    const [returnOrders, count] = await super.listAndCountReturns(
+      filters,
+      config,
+      sharedContext
+    )
+
+    return [
+      formatOrder(returnOrders, { includeTotals }) as OrderTypes.ReturnDTO[],
+      count,
+    ]
+  }
+
   async create(
     data: OrderTypes.CreateOrderDTO[],
     sharedContext?: Context
@@ -1460,19 +1523,19 @@ export default class OrderModuleService<
   }
 
   async createOrderChange(
-    data: OrderTypes.CreateOrderChangeDTO,
+    data: CreateOrderChangeDTO,
     sharedContext?: Context
   ): Promise<OrderTypes.OrderChangeDTO>
 
   async createOrderChange(
-    data: OrderTypes.CreateOrderChangeDTO[],
+    data: CreateOrderChangeDTO[],
     sharedContext?: Context
   ): Promise<OrderTypes.OrderChangeDTO[]>
 
   @InjectManager("baseRepository_")
   async createOrderChange(
-    data: OrderTypes.CreateOrderChangeDTO | OrderTypes.CreateOrderChangeDTO[],
+    data: CreateOrderChangeDTO | CreateOrderChangeDTO[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<OrderTypes.OrderChangeDTO | OrderTypes.OrderChangeDTO[]> {
     const changes = await this.createOrderChange_(data, sharedContext)
 
@@ -1486,8 +1549,8 @@ export default class OrderModuleService<
 
   @InjectTransactionManager("baseRepository_")
   protected async createOrderChange_(
-    data: OrderTypes.CreateOrderChangeDTO | OrderTypes.CreateOrderChangeDTO[],
+    data: CreateOrderChangeDTO | CreateOrderChangeDTO[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<OrderChange[]> {
     const dataArr = Array.isArray(data) ? data : [data]
 
@@ -1554,7 +1617,7 @@ export default class OrderModuleService<
       | string[]
       | OrderTypes.CancelOrderChangeDTO
       | OrderTypes.CancelOrderChangeDTO[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<void> {
     const data = Array.isArray(orderChangeIdOrData)
       ? orderChangeIdOrData
@@ -1604,7 +1667,7 @@ export default class OrderModuleService<
       | string[]
       | OrderTypes.ConfirmOrderChangeDTO
       | OrderTypes.ConfirmOrderChangeDTO[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<void> {
     const data = Array.isArray(orderChangeIdOrData)
       ? orderChangeIdOrData
@@ -1636,6 +1699,9 @@ export default class OrderModuleService<
           ...action,
           version: change.version,
           order_id: change.order_id,
+          return_id: change.return_id,
+          claim_id: change.claim_id,
+          exchange_id: change.exchange_id,
         }
       })
       return change.actions
@@ -1671,7 +1737,7 @@ export default class OrderModuleService<
       | string[]
       | OrderTypes.DeclineOrderChangeDTO
       | OrderTypes.DeclineOrderChangeDTO[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<void> {
     const data = Array.isArray(orderChangeIdOrData)
       ? orderChangeIdOrData
@@ -1697,7 +1763,7 @@ export default class OrderModuleService<
   @InjectManager("baseRepository_")
   async applyPendingOrderActions(
     orderId: string | string[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<void> {
     const orderIds = Array.isArray(orderId) ? orderId : [orderId]
 
@@ -1737,11 +1803,17 @@ export default class OrderModuleService<
       sharedContext
     )
 
-    await this.applyOrderChanges_(changes, sharedContext)
+    await this.applyOrderChanges_(
+      changes as ApplyOrderChangeDTO[],
+      sharedContext
+    )
   }
 
   @InjectManager("baseRepository_")
-  async revertLastVersion(orderId: string, sharedContext?: Context) {
+  async revertLastVersion(
+    orderId: string,
+    @MedusaContext() sharedContext?: Context
+  ) {
     const order = await super.retrieve(
       orderId,
       {
@@ -1852,6 +1924,15 @@ export default class OrderModuleService<
       },
       sharedContext
     )
+
+    // Returns
+    await this.returnService_.delete(
+      {
+        order_id: order.id,
+        order_version: currentVersion,
+      },
+      sharedContext
+    )
   }
 
   private async getAndValidateOrderChange_(
@@ -1927,7 +2008,7 @@ export default class OrderModuleService<
     data:
       | OrderTypes.CreateOrderChangeActionDTO
       | OrderTypes.CreateOrderChangeActionDTO[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<
     OrderTypes.OrderChangeActionDTO | OrderTypes.OrderChangeActionDTO[]
   > {
@@ -1968,22 +2049,14 @@ export default class OrderModuleService<
   }
 
   private async applyOrderChanges_(
-    changeActions: any[],
+    changeActions: ApplyOrderChangeDTO[],
     sharedContext?: Context
   ): Promise<void> {
-    type ApplyOrderChangeDTO = {
-      id: string
-      order_id: string
-      version: number
-      actions: OrderChangeAction[]
-      applied: boolean
-    }
-
     const actionsMap: Record<string, any[]> = {}
     const ordersIds: string[] = []
     const usedActions: any[] = []
 
-    for (const action of changeActions as ApplyOrderChangeDTO[]) {
+    for (const action of changeActions) {
       if (action.applied) {
         continue
       }
@@ -2023,68 +2096,12 @@ export default class OrderModuleService<
       sharedContext
     )
 
-    const itemsToUpsert: OrderItem[] = []
+    const {
-    const shippingMethodsToInsert: OrderShippingMethod[] = []
+      itemsToUpsert,
-    const summariesToUpsert: any[] = []
+      shippingMethodsToInsert,
-    const orderToUpdate: any[] = []
+      summariesToUpsert,
-
+      orderToUpdate,
-    for (const order of orders) {
+    } = applyChangesToOrder(orders, actionsMap)
-      const calculated = calculateOrderChange({
-        order: order as any,
-        actions: actionsMap[order.id],
-        transactions: order.transactions,
-      })
-
-      createRawPropertiesFromBigNumber(calculated)
-
-      const version = actionsMap[order.id][0].version!
-
-      for (const item of calculated.order.items) {
-        const orderItem = item.detail as any
-        itemsToUpsert.push({
-          id: orderItem.version === version ? orderItem.id : undefined,
-          item_id: item.id,
-          order_id: order.id,
-          version,
-          quantity: item.detail.quantity,
-          fulfilled_quantity: item.detail.fulfilled_quantity,
-          shipped_quantity: item.detail.shipped_quantity,
-          return_requested_quantity: item.detail.return_requested_quantity,
-          return_received_quantity: item.detail.return_received_quantity,
-          return_dismissed_quantity: item.detail.return_dismissed_quantity,
-          written_off_quantity: item.detail.written_off_quantity,
-          metadata: item.detail.metadata,
-        } as any)
-      }
-
-      const orderSummary = order.summary as any
-      summariesToUpsert.push({
-        id: orderSummary.version === version ? orderSummary.id : undefined,
-        order_id: order.id,
-        version,
-        totals: calculated.summary,
-      })
-
-      if (version > order.version) {
-        for (const shippingMethod of order.shipping_methods ?? []) {
-          const sm = {
-            ...(shippingMethod as any).detail,
-            version,
-          }
-          delete sm.id
-          shippingMethodsToInsert.push(sm)
-        }
-
-        orderToUpdate.push({
-          selector: {
-            id: order.id,
-          },
-          data: {
-            version,
-          },
-        })
-      }
-    }
 
     await promiseAll([
       orderToUpdate.length
@@ -2108,186 +2125,6 @@ export default class OrderModuleService<
     ])
   }
 
-  @InjectTransactionManager("baseRepository_")
-  async registerFulfillment(
-    data: OrderTypes.RegisterOrderFulfillmentDTO,
-    sharedContext?: Context
-  ): Promise<void> {
-    const items = data.items.map((item) => {
-      return {
-        action: ChangeActionType.FULFILL_ITEM,
-        internal_note: item.internal_note,
-        reference: data.reference,
-        reference_id: data.reference_id,
-        details: {
-          reference_id: item.id,
-          quantity: item.quantity,
-          metadata: item.metadata,
-        },
-      }
-    })
-
-    const change = await this.createOrderChange_(
-      {
-        order_id: data.order_id,
-        description: data.description,
-        internal_note: data.internal_note,
-        created_by: data.created_by,
-        metadata: data.metadata,
-        actions: items,
-      },
-      sharedContext
-    )
-
-    await this.confirmOrderChange(change[0].id, sharedContext)
-  }
-
-  @InjectTransactionManager("baseRepository_")
-  async cancelFulfillment(
-    data: OrderTypes.CancelOrderFulfillmentDTO,
-    sharedContext?: Context
-  ): Promise<void> {
-    const items = data.items.map((item) => {
-      return {
-        action: ChangeActionType.CANCEL_ITEM_FULFILLMENT,
-        internal_note: item.internal_note,
-        reference: data.reference,
-        reference_id: data.reference_id,
-        details: {
-          reference_id: item.id,
-          quantity: item.quantity,
-          metadata: item.metadata,
-        },
-      }
-    })
-
-    const change = await this.createOrderChange_(
-      {
-        order_id: data.order_id,
-        description: data.description,
-        internal_note: data.internal_note,
-        created_by: data.created_by,
-        metadata: data.metadata,
-        actions: items,
-      },
-      sharedContext
-    )
-
-    await this.confirmOrderChange(change[0].id, sharedContext)
-  }
-
-  @InjectTransactionManager("baseRepository_")
-  async registerShipment(
-    data: OrderTypes.RegisterOrderShipmentDTO,
-    sharedContext?: Context
-  ): Promise<void> {
-    let shippingMethodId
-
-    const actions: CreateOrderChangeActionDTO[] = data.items.map((item) => {
-      return {
-        action: ChangeActionType.SHIP_ITEM,
-        internal_note: item.internal_note,
-        reference: data.reference,
-        reference_id: data.reference_id,
-        details: {
-          reference_id: item.id,
-          quantity: item.quantity,
-          metadata: item.metadata,
-        },
-      }
-    })
-
-    if (shippingMethodId) {
-      actions.push({
-        action: ChangeActionType.SHIPPING_ADD,
-        reference: data.reference,
-        reference_id: shippingMethodId,
-      })
-    }
-
-    const change = await this.createOrderChange_(
-      {
-        order_id: data.order_id,
-        description: data.description,
-        internal_note: data.internal_note,
-        created_by: data.created_by,
-        metadata: data.metadata,
-        actions,
-      },
-      sharedContext
-    )
-
-    await this.confirmOrderChange(change[0].id, sharedContext)
-  }
-
-  @InjectTransactionManager("baseRepository_")
-  async createReturn(
-    data: OrderTypes.CreateOrderReturnDTO,
-    sharedContext?: Context
-  ): Promise<void> {
-    let shippingMethodId
-
-    if (!isString(data.shipping_method)) {
-      const methods = await this.createShippingMethods(
-        data.order_id,
-        [{ order_id: data.order_id, ...data.shipping_method }],
-        sharedContext
-      )
-      shippingMethodId = methods[0].id
-    } else {
-      shippingMethodId = data.shipping_method
-    }
-
-    const method = await this.shippingMethodService_.retrieve(
-      shippingMethodId,
-      {
-        relations: ["tax_lines", "adjustments"],
-      },
-      sharedContext
-    )
-
-    const calculatedAmount = getShippingMethodsTotals([method as any], {})[
-      method.id
-    ]
-
-    const actions: CreateOrderChangeActionDTO[] = data.items.map((item) => {
-      return {
-        action: ChangeActionType.RETURN_ITEM,
-        internal_note: item.internal_note,
-        reference: data.reference ?? "fulfillment",
-        reference_id: data.reference_id ?? shippingMethodId,
-        details: {
-          reference_id: item.id,
-          quantity: item.quantity,
-          metadata: item.metadata,
-        },
-      }
-    })
-
-    if (shippingMethodId) {
-      actions.push({
-        action: ChangeActionType.SHIPPING_ADD,
-        reference: data.reference ?? "fulfillment",
-        reference_id: data.reference_id ?? shippingMethodId,
-        amount: calculatedAmount.total,
-      })
-    }
-
-    const change = await this.createOrderChange_(
-      {
-        order_id: data.order_id,
-        description: data.description,
-        internal_note: data.internal_note,
-        created_by: data.created_by,
-        metadata: data.metadata,
-        actions,
-      },
-      sharedContext
-    )
-
-    await this.confirmOrderChange(change[0].id, sharedContext)
-  }
-
   async addTransactions(
     transactionData: OrderTypes.CreateOrderTransactionDTO,
     sharedContext?: Context
@@ -2303,7 +2140,7 @@ export default class OrderModuleService<
     transactionData:
       | OrderTypes.CreateOrderTransactionDTO
       | OrderTypes.CreateOrderTransactionDTO[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<
     OrderTypes.OrderTransactionDTO | OrderTypes.OrderTransactionDTO[]
   > {
@@ -2346,7 +2183,7 @@ export default class OrderModuleService<
   // @ts-ignore
   async deleteTransactions(
     transactionIds: string | object | string[] | object[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<void> {
     const data = Array.isArray(transactionIds)
       ? transactionIds
@@ -2376,7 +2213,7 @@ export default class OrderModuleService<
   async softDeleteTransactions<TReturnableLinkableKeys extends string>(
     transactionIds: string | object | string[] | object[],
     config?: SoftDeleteReturn<TReturnableLinkableKeys>,
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<Record<string, string[]> | void> {
     const transactions = await super.listTransactions(
       {
@@ -2408,7 +2245,7 @@ export default class OrderModuleService<
   async restoreTransactions<TReturnableLinkableKeys extends string>(
     transactionIds: string | object | string[] | object[],
     config?: RestoreReturn<TReturnableLinkableKeys>,
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<Record<string, string[]> | void> {
     const transactions = await super.listTransactions(
       {
@@ -2497,7 +2334,7 @@ export default class OrderModuleService<
     returnReasonData:
       | OrderTypes.CreateOrderReturnReasonDTO
       | OrderTypes.CreateOrderReturnReasonDTO[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<
     OrderTypes.OrderReturnReasonDTO | OrderTypes.OrderReturnReasonDTO[]
   > {
@@ -2620,40 +2457,6 @@ export default class OrderModuleService<
     return await this.returnReasonService_.update(toUpdate, sharedContext)
   }
 
-  @InjectTransactionManager("baseRepository_")
-  async receiveReturn(
-    data: OrderTypes.ReceiveOrderReturnDTO,
-    sharedContext?: Context
-  ): Promise<void> {
-    const items = data.items.map((item) => {
-      return {
-        action: ChangeActionType.RECEIVE_RETURN_ITEM,
-        internal_note: item.internal_note,
-        reference: data.reference,
-        reference_id: data.reference_id,
-        details: {
-          reference_id: item.id,
-          quantity: item.quantity,
-          metadata: item.metadata,
-        },
-      }
-    })
-
-    const change = await this.createOrderChange_(
-      {
-        order_id: data.order_id,
-        description: data.description,
-        internal_note: data.internal_note,
-        created_by: data.created_by,
-        metadata: data.metadata,
-        actions: items,
-      },
-      sharedContext
-    )
-
-    await this.confirmOrderChange(change[0].id, sharedContext)
-  }
-
   async archive(
     orderId: string,
     sharedContext?: Context
@@ -2667,7 +2470,7 @@ export default class OrderModuleService<
   @InjectTransactionManager("baseRepository_")
   async archive(
     orderId: string | string[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<OrderTypes.OrderDTO | OrderTypes.OrderDTO[]> {
     const orderIds = Array.isArray(orderId) ? orderId : [orderId]
     const orders = await this.list(
@@ -2725,7 +2528,7 @@ export default class OrderModuleService<
   @InjectTransactionManager("baseRepository_")
   async completeOrder(
     orderId: string | string[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<OrderTypes.OrderDTO | OrderTypes.OrderDTO[]> {
     const orderIds = Array.isArray(orderId) ? orderId : [orderId]
     const orders = await this.list(
@@ -2777,7 +2580,7 @@ export default class OrderModuleService<
   @InjectTransactionManager("baseRepository_")
   async cancel(
     orderId: string | string[],
-    sharedContext?: Context
+    @MedusaContext() sharedContext?: Context
   ): Promise<OrderTypes.OrderDTO | OrderTypes.OrderDTO[]> {
     const orderIds = Array.isArray(orderId) ? orderId : [orderId]
     const orders = await this.list(
@@ -2807,4 +2610,76 @@ export default class OrderModuleService<
 
     return Array.isArray(orderId) ? orders : orders[0]
   }
+
+  // ------------------- Bundled Order Actions
+
+  @InjectTransactionManager("baseRepository_")
+  async createReturn(
+    data: OrderTypes.CreateOrderReturnDTO,
+    @MedusaContext() sharedContext?: Context
+  ): Promise<any> {
+    // TODO: type ReturnDTO
+    const ret = await BundledActions.createReturn.bind(this)(
+      data,
+      sharedContext
+    )
+
+    return await this.retrieveReturn(
+      ret.id,
+      {
+        relations: ["items"],
+      },
+      sharedContext
+    )
+  }
+
+  @InjectManager("baseRepository_")
+  async receiveReturn(
+    data: OrderTypes.ReceiveOrderReturnDTO,
+    @MedusaContext() sharedContext?: Context
+  ): Promise<any> {
+    const ret = await this.receiveReturn_(data, sharedContext)
+
+    return await this.retrieveReturn(ret.id, {
+      relations: ["items"],
+    })
+  }
+
+  @InjectTransactionManager("baseRepository_")
+  private async receiveReturn_(
+    data: OrderTypes.ReceiveOrderReturnDTO,
+    @MedusaContext() sharedContext?: Context
+  ): Promise<any> {
+    return await BundledActions.receiveReturn.bind(this)(data, sharedContext)
+  }
+
+  @InjectTransactionManager("baseRepository_")
+  async registerFulfillment(
+    data: OrderTypes.RegisterOrderFulfillmentDTO,
+    @MedusaContext() sharedContext?: Context
+  ): Promise<void> {
+    return await BundledActions.registerFulfillment.bind(this)(
+      data,
+      sharedContext
+    )
+  }
+
+  @InjectTransactionManager("baseRepository_")
+  async cancelFulfillment(
+    data: OrderTypes.CancelOrderFulfillmentDTO,
+    @MedusaContext() sharedContext?: Context
+  ): Promise<void> {
+    return await BundledActions.cancelFulfillment.bind(this)(
+      data,
+      sharedContext
+    )
+  }
+
+  @InjectTransactionManager("baseRepository_")
+  async registerShipment(
+    data: OrderTypes.RegisterOrderShipmentDTO,
+    @MedusaContext() sharedContext?: Context
+  ): Promise<void> {
+    return await BundledActions.registerShipment.bind(this)(data, sharedContext)
+  }
 }

packages/modules/order/src/types/index.ts

@@ -5,6 +5,7 @@ export * from "./line-item"
 export * from "./line-item-adjustment"
 export * from "./line-item-tax-line"
 export * from "./order"
+export * from "./order-change"
 export * from "./order-detail"
 export * from "./shipping-method"
 export * from "./shipping-method-adjustment"

packages/modules/order/src/types/order-change.ts

@@ -0,0 +1,35 @@
+import { OrderTypes } from "@medusajs/types"
+
+export enum OrderChangeStatus {
+  /**
+   * The order change is confirmed.
+   */
+  CONFIRMED = "confirmed",
+  /**
+   * The order change is declined.
+   */
+  DECLINED = "declined",
+  /**
+   * The order change is requested.
+   */
+  REQUESTED = "requested",
+  /**
+   * The order change is pending.
+   */
+  PENDING = "pending",
+  /**
+   * The order change is canceled.
+   */
+  CANCELED = "canceled",
+}
+
+export enum OrderChangeType {
+  RETURN = "return",
+  EXCHANGE = "exchange",
+  CLAIM = "claim",
+  EDIT = "edit",
+}
+
+export interface CreateOrderChangeDTO extends OrderTypes.CreateOrderChangeDTO {
+  change_type?: OrderChangeType
+}

packages/modules/order/src/types/utils/index.ts

@@ -1,13 +1,25 @@
 import { BigNumberInput } from "@medusajs/types"
 
 export type VirtualOrder = {
+  id: string
+
   items: {
     id: string
+    order_id: string
+    return_id?: string
+    claim_id?: string
+    exchange_id?: string
+
     unit_price: BigNumberInput
     quantity: BigNumberInput
 
     detail: {
       id?: string
+      order_id: string
+      return_id?: string
+      claim_id?: string
+      exchange_id?: string
+
       quantity: BigNumberInput
       shipped_quantity: BigNumberInput
       fulfilled_quantity: BigNumberInput
@@ -20,12 +32,26 @@ export type VirtualOrder = {
   }[]
 
   shipping_methods: {
-    id: string
+    shipping_method_id: string
+    order_id: string
+    return_id?: string
+    claim_id?: string
+    exchange_id?: string
+
+    detail?: {
+      id?: string
+      order_id: string
+      return_id?: string
+      claim_id?: string
+      exchange_id?: string
+    }
+
     price: BigNumberInput
   }[]
 
   total: BigNumberInput
 
+  transactions?: OrderTransaction[]
   metadata?: Record<string, unknown>
 }
 
@@ -59,6 +85,10 @@ export interface OrderChangeEvent {
   reference?: string
   reference_id?: string
 
+  return_id?: string
+  claim_id?: string
+  exchange_id?: string
+
   group_id?: string
 
   evaluationOnly?: boolean

packages/modules/order/src/utils/actions/cancel-item-fulfillment.ts

@@ -1,6 +1,7 @@
 import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
 import { ChangeActionType } from "../action-key"
 import { OrderChangeProcessing } from "../calculate-order-change"
+import { setActionReference } from "../set-action-reference"
 
 OrderChangeProcessing.registerActionType(
   ChangeActionType.CANCEL_ITEM_FULFILLMENT,
@@ -16,6 +17,8 @@ OrderChangeProcessing.registerActionType(
         existing.detail.fulfilled_quantity,
         action.details.quantity
       )
+
+      setActionReference(existing, action)
     },
     revert({ action, currentOrder }) {
       const existing = currentOrder.items.find(

packages/modules/order/src/utils/actions/cancel-return.ts

@@ -1,6 +1,7 @@
 import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
 import { ChangeActionType } from "../action-key"
 import { OrderChangeProcessing } from "../calculate-order-change"
+import { setActionReference } from "../set-action-reference"
 
 OrderChangeProcessing.registerActionType(ChangeActionType.CANCEL_RETURN, {
   operation({ action, currentOrder }) {
@@ -15,6 +16,8 @@ OrderChangeProcessing.registerActionType(ChangeActionType.CANCEL_RETURN, {
       action.details.quantity
     )
 
+    setActionReference(existing, action)
+
     return action.details.unit_price * action.details.quantity
   },
   revert({ action, currentOrder }) {

packages/modules/order/src/utils/actions/fulfill-item.ts

@@ -1,6 +1,7 @@
 import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
 import { ChangeActionType } from "../action-key"
 import { OrderChangeProcessing } from "../calculate-order-change"
+import { setActionReference } from "../set-action-reference"
 
 OrderChangeProcessing.registerActionType(ChangeActionType.FULFILL_ITEM, {
   operation({ action, currentOrder }) {
@@ -14,6 +15,8 @@ OrderChangeProcessing.registerActionType(ChangeActionType.FULFILL_ITEM, {
       existing.detail.fulfilled_quantity,
       action.details.quantity
     )
+
+    setActionReference(existing, action)
   },
   revert({ action, currentOrder }) {
     const existing = currentOrder.items.find(

packages/modules/order/src/utils/actions/item-add.ts

@@ -2,6 +2,7 @@ import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
 import { VirtualOrder } from "@types"
 import { ChangeActionType } from "../action-key"
 import { OrderChangeProcessing } from "../calculate-order-change"
+import { setActionReference } from "../set-action-reference"
 
 OrderChangeProcessing.registerActionType(ChangeActionType.ITEM_ADD, {
   operation({ action, currentOrder }) {
@@ -18,9 +19,16 @@ OrderChangeProcessing.registerActionType(ChangeActionType.ITEM_ADD, {
         existing.detail.quantity,
         action.details.quantity
       )
+
+      setActionReference(existing, action)
     } else {
       currentOrder.items.push({
         id: action.reference_id!,
+        order_id: currentOrder.id,
+        return_id: action.details.return_id,
+        claim_id: action.details.claim_id,
+        exchange_id: action.details.exchange_id,
+
         unit_price: action.details.unit_price,
         quantity: action.details.quantity,
       } as VirtualOrder["items"][0])

packages/modules/order/src/utils/actions/item-remove.ts

@@ -2,6 +2,7 @@ import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
 import { VirtualOrder } from "@types"
 import { ChangeActionType } from "../action-key"
 import { OrderChangeProcessing } from "../calculate-order-change"
+import { setActionReference } from "../set-action-reference"
 
 OrderChangeProcessing.registerActionType(ChangeActionType.ITEM_REMOVE, {
   isDeduction: true,
@@ -20,6 +21,8 @@ OrderChangeProcessing.registerActionType(ChangeActionType.ITEM_REMOVE, {
       action.details.quantity
     )
 
+    setActionReference(existing, action)
+
     if (MathBN.lte(existing.quantity, 0)) {
       currentOrder.items.splice(existingIndex, 1)
     }

packages/modules/order/src/utils/actions/receive-damaged-return-item.ts

@@ -2,6 +2,7 @@ import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
 import { EVENT_STATUS } from "@types"
 import { ChangeActionType } from "../action-key"
 import { OrderChangeProcessing } from "../calculate-order-change"
+import { setActionReference } from "../set-action-reference"
 
 OrderChangeProcessing.registerActionType(
   ChangeActionType.RECEIVE_DAMAGED_RETURN_ITEM,
@@ -27,6 +28,8 @@ OrderChangeProcessing.registerActionType(
         toReturn
       )
 
+      setActionReference(existing, action)
+
       if (previousEvents) {
         for (const previousEvent of previousEvents) {
           previousEvent.original_ = JSON.parse(JSON.stringify(previousEvent))

packages/modules/order/src/utils/actions/receive-return-item.ts

@@ -7,6 +7,7 @@ import {
 import { EVENT_STATUS } from "@types"
 import { ChangeActionType } from "../action-key"
 import { OrderChangeProcessing } from "../calculate-order-change"
+import { setActionReference } from "../set-action-reference"
 
 OrderChangeProcessing.registerActionType(ChangeActionType.RECEIVE_RETURN_ITEM, {
   isDeduction: true,
@@ -30,6 +31,8 @@ OrderChangeProcessing.registerActionType(ChangeActionType.RECEIVE_RETURN_ITEM, {
       toReturn
     )
 
+    setActionReference(existing, action)
+
     if (previousEvents) {
       for (const previousEvent of previousEvents) {
         previousEvent.original_ = JSON.parse(JSON.stringify(previousEvent))

packages/modules/order/src/utils/actions/return-item.ts

@@ -1,6 +1,7 @@
 import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
 import { ChangeActionType } from "../action-key"
 import { OrderChangeProcessing } from "../calculate-order-change"
+import { setActionReference } from "../set-action-reference"
 
 OrderChangeProcessing.registerActionType(ChangeActionType.RETURN_ITEM, {
   isDeduction: true,
@@ -16,6 +17,8 @@ OrderChangeProcessing.registerActionType(ChangeActionType.RETURN_ITEM, {
       action.details.quantity
     )
 
+    setActionReference(existing, action)
+
     return MathBN.mult(existing.unit_price, action.details.quantity)
   },
   revert({ action, currentOrder }) {

packages/modules/order/src/utils/actions/ship-item.ts

@@ -1,6 +1,7 @@
 import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
 import { ChangeActionType } from "../action-key"
 import { OrderChangeProcessing } from "../calculate-order-change"
+import { setActionReference } from "../set-action-reference"
 
 OrderChangeProcessing.registerActionType(ChangeActionType.SHIP_ITEM, {
   operation({ action, currentOrder }) {
@@ -14,6 +15,8 @@ OrderChangeProcessing.registerActionType(ChangeActionType.SHIP_ITEM, {
       existing.detail.shipped_quantity,
       action.details.quantity
     )
+
+    setActionReference(existing, action)
   },
   revert({ action, currentOrder }) {
     const existing = currentOrder.items.find(

packages/modules/order/src/utils/actions/shipping-add.ts

@@ -9,7 +9,12 @@ OrderChangeProcessing.registerActionType(ChangeActionType.SHIPPING_ADD, {
       : [currentOrder.shipping_methods]
 
     shipping.push({
-      id: action.reference_id!,
+      shipping_method_id: action.reference_id!,
+      order_id: currentOrder.id,
+      return_id: action.return_id,
+      claim_id: action.claim_id,
+      exchange_id: action.exchange_id,
+
       price: action.amount as number,
     })
 
@@ -21,7 +26,7 @@ OrderChangeProcessing.registerActionType(ChangeActionType.SHIPPING_ADD, {
       : [currentOrder.shipping_methods]
 
     const existingIndex = shipping.findIndex(
-      (item) => item.id === action.reference_id
+      (item) => item.shipping_method_id === action.reference_id
     )
 
     if (existingIndex > -1) {

packages/modules/order/src/utils/actions/write-off-item.ts

@@ -1,6 +1,7 @@
 import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
 import { ChangeActionType } from "../action-key"
 import { OrderChangeProcessing } from "../calculate-order-change"
+import { setActionReference } from "../set-action-reference"
 
 OrderChangeProcessing.registerActionType(ChangeActionType.WRITE_OFF_ITEM, {
   operation({ action, currentOrder }) {
@@ -13,6 +14,8 @@ OrderChangeProcessing.registerActionType(ChangeActionType.WRITE_OFF_ITEM, {
       existing.detail.written_off_quantity,
       action.details.quantity
     )
+
+    setActionReference(existing, action)
   },
   revert({ action, currentOrder }) {
     const existing = currentOrder.items.find(

packages/modules/order/src/utils/apply-order-changes.ts

@@ -0,0 +1,89 @@
+import { OrderChangeActionDTO } from "@medusajs/types"
+import { createRawPropertiesFromBigNumber } from "@medusajs/utils"
+import { OrderItem, OrderShippingMethod } from "@models"
+import { calculateOrderChange } from "./calculate-order-change"
+
+export interface ApplyOrderChangeDTO extends OrderChangeActionDTO {
+  id: string
+  order_id: string
+  version: number
+  applied: boolean
+}
+
+export function applyChangesToOrder(
+  orders: any[],
+  actionsMap: Record<string, any[]>
+) {
+  const itemsToUpsert: OrderItem[] = []
+  const shippingMethodsToInsert: OrderShippingMethod[] = []
+  const summariesToUpsert: any[] = []
+  const orderToUpdate: any[] = []
+
+  for (const order of orders) {
+    const calculated = calculateOrderChange({
+      order: order as any,
+      actions: actionsMap[order.id],
+      transactions: order.transactions ?? [],
+    })
+
+    createRawPropertiesFromBigNumber(calculated)
+
+    const version = actionsMap[order.id][0].version ?? 1
+
+    for (const item of calculated.order.items) {
+      const orderItem = item.detail as any
+      itemsToUpsert.push({
+        id: orderItem.version === version ? orderItem.id : undefined,
+        item_id: item.id,
+        order_id: order.id,
+        version,
+        return_id: item.detail.return_id,
+        claim_id: item.detail.claim_id,
+        exchange_id: item.detail.exchange_id,
+        quantity: item.detail.quantity,
+        fulfilled_quantity: item.detail.fulfilled_quantity,
+        shipped_quantity: item.detail.shipped_quantity,
+        return_requested_quantity: item.detail.return_requested_quantity,
+        return_received_quantity: item.detail.return_received_quantity,
+        return_dismissed_quantity: item.detail.return_dismissed_quantity,
+        written_off_quantity: item.detail.written_off_quantity,
+        metadata: item.detail.metadata,
+      } as any)
+    }
+
+    const orderSummary = order.summary as any
+    summariesToUpsert.push({
+      id: orderSummary?.version === version ? orderSummary.id : undefined,
+      order_id: order.id,
+      version,
+      totals: calculated.summary,
+    })
+
+    if (version > order.version) {
+      for (const shippingMethod of calculated.order.shipping_methods ?? []) {
+        const sm = {
+          ...((shippingMethod as any).detail ?? shippingMethod),
+          version,
+        }
+        delete sm.id
+        shippingMethodsToInsert.push(sm)
+      }
+
+      orderToUpdate.push({
+        selector: {
+          id: order.id,
+        },
+        data: {
+          version,
+        },
+      })
+    }
+  }
+
+  return {
+    itemsToUpsert,
+    shippingMethodsToInsert,
+    summariesToUpsert,
+    orderToUpdate,
+  }
+}

packages/modules/order/src/utils/base-repository-find.ts

@@ -0,0 +1,151 @@
+import { Constructor, Context, DAL } from "@medusajs/types"
+import { LoadStrategy } from "@mikro-orm/core"
+import { Order } from "@models"
+import { mapRepositoryToOrderModel } from "."
+
+export function setFindMethods<T>(klass: Constructor<T>, entity: any) {
+  klass.prototype.find = async function find(
+    this: any,
+    options?: DAL.FindOptions<T>,
+    context?: Context
+  ): Promise<T[]> {
+    const manager = this.getActiveManager(context)
+    const knex = manager.getKnex()
+
+    const findOptions_ = { ...options } as any
+    findOptions_.options ??= {}
+    findOptions_.where ??= {}
+    findOptions_.populate ??= []
+
+    if (!("strategy" in findOptions_.options)) {
+      if (findOptions_.options.limit != null || findOptions_.options.offset) {
+        Object.assign(findOptions_.options, {
+          strategy: LoadStrategy.SELECT_IN,
+        })
+      } else {
+        Object.assign(findOptions_.options, {
+          strategy: LoadStrategy.JOINED,
+        })
+      }
+    }
+
+    const config = mapRepositoryToOrderModel(findOptions_)
+
+    let orderAlias = "o0"
+    if (entity !== Order) {
+      // first relation is always order if entity is not Order
+      config.options.populate.unshift("order")
+      orderAlias = "o1"
+    }
+
+    let defaultVersion = knex.raw(`"${orderAlias}"."version"`)
+    const strategy = config.options.strategy ?? LoadStrategy.JOINED
+    if (strategy === LoadStrategy.SELECT_IN) {
+      const sql = manager
+        .qb(Order, "_sub0")
+        .select("version")
+        .where({ id: knex.raw(`"o0"."order_id"`) })
+        .getKnexQuery()
+        .toString()
+
+      defaultVersion = knex.raw(`(${sql})`)
+    }
+
+    const version = config.where.version ?? defaultVersion
+    delete config.where?.version
+
+    config.options.populateWhere ??= {}
+
+    if (entity !== Order) {
+      config.options.populateWhere.order ??= {}
+      config.options.populateWhere.order.version = version
+
+      config.options.populateWhere.order.summary ??= {}
+      config.options.populateWhere.order.summary.version = version
+    } else {
+      config.options.populateWhere.summary ??= {}
+      config.options.populateWhere.summary.version = version
+    }
+
+    config.options.populateWhere.items ??= {}
+    config.options.populateWhere.items.version = version
+
+    config.options.populateWhere.shipping_methods ??= {}
+    config.options.populateWhere.shipping_methods.version = version
+
+    if (!config.options.orderBy) {
+      config.options.orderBy = { id: "ASC" }
+    }
+
+    return await manager.find(entity, config.where, config.options)
+  }
+
+  klass.prototype.findAndCount = async function findAndCount(
+    this: any,
+    findOptions: DAL.FindOptions<T> = { where: {} },
+    context: Context = {}
+  ): Promise<[T[], number]> {
+    const manager = this.getActiveManager(context)
+    const knex = manager.getKnex()
+
+    const findOptions_ = { ...findOptions } as any
+    findOptions_.options ??= {}
+    findOptions_.where ??= {}
+
+    if (!("strategy" in findOptions_.options)) {
+      Object.assign(findOptions_.options, {
+        strategy: LoadStrategy.SELECT_IN,
+      })
+    }
+
+    const config = mapRepositoryToOrderModel(findOptions_)
+
+    let orderAlias = "o0"
+    if (entity !== Order) {
+      // first relation is always order if entity is not Order
+      config.options.populate.unshift("order")
+      orderAlias = "o1"
+    }
+
+    let defaultVersion = knex.raw(`"${orderAlias}"."version"`)
+    const strategy = config.options.strategy ?? LoadStrategy.JOINED
+    if (strategy === LoadStrategy.SELECT_IN) {
+      const sql = manager
+        .qb(Order, "_sub0")
+        .select("version")
+        .where({ id: knex.raw(`"o0"."order_id"`) })
+        .getKnexQuery()
+        .toString()
+
+      defaultVersion = knex.raw(`(${sql})`)
+    }
+
+    const version = config.where.version ?? defaultVersion
+    delete config.where.version
+
+    config.options.populateWhere ??= {}
+
+    if (entity !== Order) {
+      config.options.populateWhere.order ??= {}
+      config.options.populateWhere.order.version = version
+
+      config.options.populateWhere.order.summary ??= {}
+      config.options.populateWhere.order.summary.version = version
+    } else {
+      config.options.populateWhere.summary ??= {}
+      config.options.populateWhere.summary.version = version
+    }
+
+    config.options.populateWhere.items ??= {}
+    config.options.populateWhere.items.version = version
+
+    config.options.populateWhere.shipping_methods ??= {}
+    config.options.populateWhere.shipping_methods.version = version
+
+    if (!config.options.orderBy) {
+      config.options.orderBy = { id: "ASC" }
+    }
+
+    return await manager.findAndCount(entity, config.where, config.options)
+  }
+}

packages/modules/order/src/utils/index.ts

@@ -1,3 +1,6 @@
 export * from "./action-key"
 export * from "./actions"
+export * from "./apply-order-changes"
 export * from "./calculate-order-change"
+export * from "./set-action-reference"
+export * from "./transform-order"

packages/modules/order/src/utils/set-action-reference.ts

@@ -0,0 +1,6 @@
+export function setActionReference(existing, action) {
+  existing.detail.order_id ??= action.order_id
+  existing.detail.return_id ??= action.return_id
+  existing.detail.claim_id ??= action.claim_id
+  existing.detail.exchange_id ??= action.exchange_id
+}