feat(core): Add Order history entry for modifications

Relates to #314

packages/asset-server-plugin/e2e/graphql/generated-e2e-asset-server-plugin-types.ts

@@ -3114,6 +3114,7 @@ export enum HistoryEntryType {
     ORDER_NOTE = 'ORDER_NOTE',
     ORDER_COUPON_APPLIED = 'ORDER_COUPON_APPLIED',
     ORDER_COUPON_REMOVED = 'ORDER_COUPON_REMOVED',
+    ORDER_MODIFIED = 'ORDER_MODIFIED',
 }
 
 export type HistoryEntryList = PaginatedList & {

packages/common/src/generated-shop-types.ts

@@ -1371,6 +1371,7 @@ export enum HistoryEntryType {
     ORDER_NOTE = 'ORDER_NOTE',
     ORDER_COUPON_APPLIED = 'ORDER_COUPON_APPLIED',
     ORDER_COUPON_REMOVED = 'ORDER_COUPON_REMOVED',
+    ORDER_MODIFIED = 'ORDER_MODIFIED',
 }
 
 export type HistoryEntryList = PaginatedList & {

packages/common/src/generated-types.ts

@@ -3313,7 +3313,8 @@ export enum HistoryEntryType {
   ORDER_FULFILLMENT_TRANSITION = 'ORDER_FULFILLMENT_TRANSITION',
   ORDER_NOTE = 'ORDER_NOTE',
   ORDER_COUPON_APPLIED = 'ORDER_COUPON_APPLIED',
-  ORDER_COUPON_REMOVED = 'ORDER_COUPON_REMOVED'
+  ORDER_COUPON_REMOVED = 'ORDER_COUPON_REMOVED',
+  ORDER_MODIFIED = 'ORDER_MODIFIED'
 }
 
 export type HistoryEntryList = PaginatedList & {

packages/core/e2e/graphql/generated-e2e-admin-types.ts

@@ -3114,6 +3114,7 @@ export enum HistoryEntryType {
     ORDER_NOTE = 'ORDER_NOTE',
     ORDER_COUPON_APPLIED = 'ORDER_COUPON_APPLIED',
     ORDER_COUPON_REMOVED = 'ORDER_COUPON_REMOVED',
+    ORDER_MODIFIED = 'ORDER_MODIFIED',
 }
 
 export type HistoryEntryList = PaginatedList & {
@@ -5651,6 +5652,25 @@ export type SettlePaymentMutation = {
 
 export type PaymentFragment = Pick<Payment, 'id' | 'state' | 'metadata'>;
 
+export type GetOrderHistoryQueryVariables = Exact<{
+    id: Scalars['ID'];
+    options?: Maybe<HistoryEntryListOptions>;
+}>;
+
+export type GetOrderHistoryQuery = {
+    order?: Maybe<
+        Pick<Order, 'id'> & {
+            history: Pick<HistoryEntryList, 'totalItems'> & {
+                items: Array<
+                    Pick<HistoryEntry, 'id' | 'type' | 'data'> & {
+                        administrator?: Maybe<Pick<Administrator, 'id'>>;
+                    }
+                >;
+            };
+        }
+    >;
+};
+
 export type UpdateOptionGroupMutationVariables = Exact<{
     input: UpdateProductOptionGroupInput;
 }>;
@@ -5698,6 +5718,12 @@ export type OrderWithModificationsFragment = Pick<Order, 'id' | 'state' | 'total
     >;
 };
 
+export type GetOrderWithModificationsQueryVariables = Exact<{
+    id: Scalars['ID'];
+}>;
+
+export type GetOrderWithModificationsQuery = { order?: Maybe<OrderWithModificationsFragment> };
+
 export type ModifyOrderMutationVariables = Exact<{
     input: ModifyOrderInput;
 }>;
@@ -5778,25 +5804,6 @@ export type SettleRefundMutation = {
     settleRefund: RefundFragment | Pick<RefundStateTransitionError, 'errorCode' | 'message'>;
 };
 
-export type GetOrderHistoryQueryVariables = Exact<{
-    id: Scalars['ID'];
-    options?: Maybe<HistoryEntryListOptions>;
-}>;
-
-export type GetOrderHistoryQuery = {
-    order?: Maybe<
-        Pick<Order, 'id'> & {
-            history: Pick<HistoryEntryList, 'totalItems'> & {
-                items: Array<
-                    Pick<HistoryEntry, 'id' | 'type' | 'data'> & {
-                        administrator?: Maybe<Pick<Administrator, 'id'>>;
-                    }
-                >;
-            };
-        }
-    >;
-};
-
 export type AddNoteToOrderMutationVariables = Exact<{
     input: AddNoteToOrderInput;
 }>;
@@ -7626,6 +7633,21 @@ export namespace Payment {
     export type Fragment = PaymentFragment;
 }
 
+export namespace GetOrderHistory {
+    export type Variables = GetOrderHistoryQueryVariables;
+    export type Query = GetOrderHistoryQuery;
+    export type Order = NonNullable<GetOrderHistoryQuery['order']>;
+    export type History = NonNullable<NonNullable<GetOrderHistoryQuery['order']>['history']>;
+    export type Items = NonNullable<
+        NonNullable<NonNullable<NonNullable<GetOrderHistoryQuery['order']>['history']>['items']>[number]
+    >;
+    export type Administrator = NonNullable<
+        NonNullable<
+            NonNullable<NonNullable<NonNullable<GetOrderHistoryQuery['order']>['history']>['items']>[number]
+        >['administrator']
+    >;
+}
+
 export namespace UpdateOptionGroup {
     export type Variables = UpdateOptionGroupMutationVariables;
     export type Mutation = UpdateOptionGroupMutation;
@@ -7686,6 +7708,12 @@ export namespace OrderWithModifications {
     export type BillingAddress = NonNullable<OrderWithModificationsFragment['billingAddress']>;
 }
 
+export namespace GetOrderWithModifications {
+    export type Variables = GetOrderWithModificationsQueryVariables;
+    export type Query = GetOrderWithModificationsQuery;
+    export type Order = NonNullable<GetOrderWithModificationsQuery['order']>;
+}
+
 export namespace ModifyOrder {
     export type Variables = ModifyOrderMutationVariables;
     export type Mutation = ModifyOrderMutation;
@@ -7761,21 +7789,6 @@ export namespace SettleRefund {
     >;
 }
 
-export namespace GetOrderHistory {
-    export type Variables = GetOrderHistoryQueryVariables;
-    export type Query = GetOrderHistoryQuery;
-    export type Order = NonNullable<GetOrderHistoryQuery['order']>;
-    export type History = NonNullable<NonNullable<GetOrderHistoryQuery['order']>['history']>;
-    export type Items = NonNullable<
-        NonNullable<NonNullable<NonNullable<GetOrderHistoryQuery['order']>['history']>['items']>[number]
-    >;
-    export type Administrator = NonNullable<
-        NonNullable<
-            NonNullable<NonNullable<NonNullable<GetOrderHistoryQuery['order']>['history']>['items']>[number]
-        >['administrator']
-    >;
-}
-
 export namespace AddNoteToOrder {
     export type Variables = AddNoteToOrderMutationVariables;
     export type Mutation = AddNoteToOrderMutation;

packages/core/e2e/graphql/generated-e2e-shop-types.ts

@@ -1322,6 +1322,7 @@ export enum HistoryEntryType {
     ORDER_NOTE = 'ORDER_NOTE',
     ORDER_COUPON_APPLIED = 'ORDER_COUPON_APPLIED',
     ORDER_COUPON_REMOVED = 'ORDER_COUPON_REMOVED',
+    ORDER_MODIFIED = 'ORDER_MODIFIED',
 }
 
 export type HistoryEntryList = PaginatedList & {

packages/core/e2e/graphql/shared-definitions.ts

@@ -794,3 +794,22 @@ export const SETTLE_PAYMENT = gql`
         metadata
     }
 `;
+
+export const GET_ORDER_HISTORY = gql`
+    query GetOrderHistory($id: ID!, $options: HistoryEntryListOptions) {
+        order(id: $id) {
+            id
+            history(options: $options) {
+                totalItems
+                items {
+                    id
+                    type
+                    administrator {
+                        id
+                    }
+                    data
+                }
+            }
+        }
+    }
+`;

packages/core/e2e/order-modification.e2e-spec.ts

@@ -23,7 +23,10 @@ import {
     CreateShippingMethod,
     ErrorCode,
     GetOrder,
+    GetOrderHistory,
+    GetOrderWithModifications,
     GlobalFlag,
+    HistoryEntryType,
     LanguageCode,
     ModifyOrder,
     OrderFragment,
@@ -44,6 +47,7 @@ import {
     ADMIN_TRANSITION_TO_STATE,
     CREATE_SHIPPING_METHOD,
     GET_ORDER,
+    GET_ORDER_HISTORY,
     UPDATE_PRODUCT_VARIANTS,
 } from './graphql/shared-definitions';
 import {
@@ -529,6 +533,34 @@ describe('Order modification', () => {
             ]);
             await assertOrderIsUnchanged(order!);
         });
+
+        it('does not add a history entry', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: orderId,
+            });
+            const { modifyOrder } = await adminClient.query<ModifyOrder.Mutation, ModifyOrder.Variables>(
+                MODIFY_ORDER,
+                {
+                    input: {
+                        dryRun: true,
+                        orderId,
+                        addItems: [{ productVariantId: 'T_5', quantity: 1 }],
+                    },
+                },
+            );
+            orderGuard.assertSuccess(modifyOrder);
+
+            const { order: history } = await adminClient.query<
+                GetOrderHistory.Query,
+                GetOrderHistory.Variables
+            >(GET_ORDER_HISTORY, {
+                id: orderId,
+                options: { filter: { type: { eq: HistoryEntryType.ORDER_MODIFIED } } },
+            });
+            orderGuard.assertSuccess(history);
+
+            expect(history.history.totalItems).toBe(0);
+        });
     });
 
     describe('wet run', () => {
@@ -816,6 +848,37 @@ describe('Order modification', () => {
             expect(modifyOrder.modifications[0].priceChange).toBe(priceDelta);
             await assertModifiedOrderIsPersisted(modifyOrder);
         });
+
+        it('adds a history entry', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: orderId,
+            });
+            const { modifyOrder } = await adminClient.query<ModifyOrder.Mutation, ModifyOrder.Variables>(
+                MODIFY_ORDER,
+                {
+                    input: {
+                        dryRun: false,
+                        orderId: order!.id,
+                        addItems: [{ productVariantId: 'T_5', quantity: 1 }],
+                    },
+                },
+            );
+            orderGuard.assertSuccess(modifyOrder);
+
+            const { order: history } = await adminClient.query<
+                GetOrderHistory.Query,
+                GetOrderHistory.Variables
+            >(GET_ORDER_HISTORY, {
+                id: orderId,
+                options: { filter: { type: { eq: HistoryEntryType.ORDER_MODIFIED } } },
+            });
+            orderGuard.assertSuccess(history);
+
+            expect(history.history.totalItems).toBe(1);
+            expect(history.history.items[0].data).toEqual({
+                modificationId: 'T_8',
+            });
+        });
     });
 
     describe('additional payment handling', () => {
@@ -921,6 +984,10 @@ describe('Order modification', () => {
                 },
                 refunds: [],
             });
+            expect(addManualPaymentToOrder.modifications[0].isSettled).toBe(true);
+            expect(addManualPaymentToOrder.modifications[0].payment?.id).toBe(
+                addManualPaymentToOrder.payments![1].id,
+            );
         });
 
         it('transition back to original state', async () => {
@@ -974,6 +1041,16 @@ describe('Order modification', () => {
             orderId3 = modifyOrder.id;
         });
 
+        it('modification is settled', async () => {
+            const { order } = await adminClient.query<
+                GetOrderWithModifications.Query,
+                GetOrderWithModifications.Variables
+            >(GET_ORDER_WITH_MODIFICATIONS, { id: orderId3 });
+
+            expect(order?.modifications.length).toBe(1);
+            expect(order?.modifications[0].isSettled).toBe(true);
+        });
+
         it('cannot transition to ArrangingAdditionalPayment state if no payment is needed', async () => {
             const { transitionOrderToState } = await adminClient.query<
                 AdminTransition.Mutation,
@@ -1153,6 +1230,15 @@ export const ORDER_WITH_MODIFICATION_FRAGMENT = gql`
     }
 `;
 
+export const GET_ORDER_WITH_MODIFICATIONS = gql`
+    query GetOrderWithModifications($id: ID!) {
+        order(id: $id) {
+            ...OrderWithModifications
+        }
+    }
+    ${ORDER_WITH_MODIFICATION_FRAGMENT}
+`;
+
 export const MODIFY_ORDER = gql`
     mutation ModifyOrder($input: ModifyOrderInput!) {
         modifyOrder(input: $input) {

packages/core/e2e/order.e2e-spec.ts

@@ -67,6 +67,7 @@ import {
     GET_ORDER,
     GET_ORDERS_LIST,
     GET_ORDER_FULFILLMENTS,
+    GET_ORDER_HISTORY,
     GET_PRODUCT_WITH_VARIANTS,
     GET_STOCK_MOVEMENT,
     SETTLE_PAYMENT,
@@ -1743,25 +1744,6 @@ export const SETTLE_REFUND = gql`
     ${REFUND_FRAGMENT}
 `;
 
-export const GET_ORDER_HISTORY = gql`
-    query GetOrderHistory($id: ID!, $options: HistoryEntryListOptions) {
-        order(id: $id) {
-            id
-            history(options: $options) {
-                totalItems
-                items {
-                    id
-                    type
-                    administrator {
-                        id
-                    }
-                    data
-                }
-            }
-        }
-    }
-`;
-
 export const ADD_NOTE_TO_ORDER = gql`
     mutation AddNoteToOrder($input: AddNoteToOrderInput!) {
         addNoteToOrder(input: $input) {

packages/core/src/api/middleware/id-codec-plugin.ts

@@ -44,6 +44,7 @@ export class IdCodecPlugin implements ApolloServerPlugin {
                     'promotionId',
                     'refundId',
                     'groupId',
+                    'modificationId',
                 ]);
             }
             return isIdType ? this.idCodecService.encode(value) : value;

packages/core/src/api/schema/common/history-entry.type.graphql

@@ -30,6 +30,7 @@ enum HistoryEntryType {
     ORDER_NOTE
     ORDER_COUPON_APPLIED
     ORDER_COUPON_REMOVED
+    ORDER_MODIFIED
 }
 
 type HistoryEntryList implements PaginatedList {

packages/core/src/i18n/messages/en.json

@@ -56,6 +56,7 @@
     "INVALID_CREDENTIALS_ERROR": "The provided credentials are invalid",
     "ITEMS_ALREADY_FULFILLED_ERROR": "One or more OrderItems are already part of a Fulfillment",
     "LANGUAGE_NOT_AVAILABLE_ERROR": "Language \"{languageCode}\" is not available. First enable it via GlobalSettings and try again",
+    "MANUAL_PAYMENT_STATE_ERROR": "A manual payment may only be added when in the \"ArrangingAdditionalPayment\" state",
     "MIME_TYPE_ERROR": "The MIME type '{ mimeType }' is not permitted.",
     "MISSING_CONDITIONS_ERROR": "A Promotion must have either at least one condition or a coupon code set",
     "MISSING_PASSWORD_ERROR": "A password must be provided.",

packages/core/src/service/helpers/order-modifier/order-modifier.ts

@@ -4,7 +4,7 @@ import { ID } from '@vendure/common/lib/shared-types';
 import { summate } from '@vendure/common/lib/shared-utils';
 
 import { RequestContext } from '../../../api/common/request-context';
-import { ErrorResultUnion, isGraphQlErrorResult } from '../../../common/error/error-result';
+import { ErrorResultUnion, isGraphQlErrorResult, JustErrorResults } from '../../../common/error/error-result';
 import { EntityNotFoundError, InternalServerError, UserInputError } from '../../../common/error/errors';
 import {
     NoChangesSpecifiedError,
@@ -32,6 +32,7 @@ import { ProductVariantService } from '../../services/product-variant.service';
 import { StockMovementService } from '../../services/stock-movement.service';
 import { TransactionalConnection } from '../../transaction/transactional-connection';
 import { OrderCalculator } from '../order-calculator/order-calculator';
+import { translateDeep } from '../utils/translate-entity';
 
 /**
  * @description
@@ -107,9 +108,9 @@ export class OrderModifier {
                 'productVariant.taxCategory',
             ],
         });
-        lineWithRelations.productVariant = this.productVariantService.applyChannelPriceAndTax(
-            lineWithRelations.productVariant,
-            ctx,
+        lineWithRelations.productVariant = translateDeep(
+            this.productVariantService.applyChannelPriceAndTax(lineWithRelations.productVariant, ctx),
+            ctx.languageCode,
         );
         order.lines.push(lineWithRelations);
         await this.connection.getRepository(ctx, Order).save(order, { reload: false });
@@ -180,10 +181,8 @@ export class OrderModifier {
     async modifyOrder(
         ctx: RequestContext,
         input: ModifyOrderInput,
-        getOrderFn: (ctx: RequestContext, orderId: ID) => Promise<Order>,
-    ): Promise<ErrorResultUnion<ModifyOrderResult, Order>> {
-        await this.connection.startTransaction(ctx);
-        const order = await getOrderFn(ctx, input.orderId);
+        order: Order,
+    ): Promise<JustErrorResults<ModifyOrderResult> | { order: Order; modification: OrderModification }> {
         const { dryRun } = input;
         const modification = new OrderModification({
             order,
@@ -227,7 +226,6 @@ export class OrderModifier {
                 currentItemsCount += correctedQuantity;
             }
             if (correctedQuantity < quantity) {
-                await this.connection.rollBackTransaction(ctx);
                 return new InsufficientStockError(correctedQuantity, order);
             }
             updatedOrderLineIds.push(orderLine.id);
@@ -256,7 +254,6 @@ export class OrderModifier {
                 currentItemsCount += correctedQuantity;
             }
             if (correctedQuantity < quantity) {
-                await this.connection.rollBackTransaction(ctx);
                 return new InsufficientStockError(correctedQuantity, order);
             } else {
                 const initialLineQuantity = orderLine.quantity;
@@ -342,20 +339,20 @@ export class OrderModifier {
             modification.billingAddressChange = input.updateBillingAddress;
         }
 
-        const resultingOrder = await getOrderFn(ctx, order.id);
-        const updatedOrderLines = resultingOrder.lines.filter(l => updatedOrderLineIds.includes(l.id));
-        await this.orderCalculator.applyPriceAdjustments(ctx, resultingOrder, [], updatedOrderLines, {
+        const updatedOrderLines = order.lines.filter(l => updatedOrderLineIds.includes(l.id));
+        await this.orderCalculator.applyPriceAdjustments(ctx, order, [], updatedOrderLines, {
             recalculateShipping: input.options?.recalculateShipping,
         });
-        const newTotalWithTax = resultingOrder.totalWithTax;
-        const delta = newTotalWithTax - initialTotalWithTax;
+
         if (dryRun) {
-            await this.connection.rollBackTransaction(ctx);
-            return resultingOrder;
+            return { order, modification };
         }
+
+        // Create the actual modification and commit all changes
+        const newTotalWithTax = order.totalWithTax;
+        const delta = newTotalWithTax - initialTotalWithTax;
         if (delta < 0) {
             if (!input.refund) {
-                await this.connection.rollBackTransaction(ctx);
                 return new RefundPaymentIdMissingError();
             }
             const existingPayments = await this.getOrderPayments(ctx, order.id);
@@ -380,11 +377,10 @@ export class OrderModifier {
         const createdModification = await this.connection
             .getRepository(ctx, OrderModification)
             .save(modification);
-        await this.connection.getRepository(ctx, Order).save(resultingOrder);
+        await this.connection.getRepository(ctx, Order).save(order);
         await this.connection.getRepository(ctx, OrderItem).save(modification.orderItems, { reload: false });
         await this.connection.getRepository(ctx, ShippingLine).save(order.shippingLines, { reload: false });
-        await this.connection.commitOpenTransaction(ctx);
-        return getOrderFn(ctx, order.id);
+        return { order, modification: createdModification };
     }
 
     private noChangesSpecified(input: ModifyOrderInput): boolean {

packages/core/src/service/services/history.service.ts

@@ -102,6 +102,9 @@ export type OrderHistoryEntryData = {
     [HistoryEntryType.ORDER_COUPON_REMOVED]: {
         couponCode: string;
     };
+    [HistoryEntryType.ORDER_MODIFIED]: {
+        modificationId: ID;
+    };
 };
 
 export interface CreateCustomerHistoryEntryArgs<T extends keyof CustomerHistoryEntryData> {

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

@@ -36,7 +36,7 @@ import { unique } from '@vendure/common/lib/unique';
 
 import { RequestContext } from '../../api/common/request-context';
 import { ErrorResultUnion, isGraphQlErrorResult } from '../../common/error/error-result';
-import { EntityNotFoundError, UserInputError } from '../../common/error/errors';
+import { EntityNotFoundError, InternalServerError, UserInputError } from '../../common/error/errors';
 import {
     AlreadyRefundedError,
     CancelActiveOrderError,
@@ -653,9 +653,27 @@ export class OrderService {
         ctx: RequestContext,
         input: ModifyOrderInput,
     ): Promise<ErrorResultUnion<ModifyOrderResult, Order>> {
-        return this.orderModifier.modifyOrder(ctx, input, (ctx1, orderId) =>
-            this.getOrderOrThrow(ctx1, orderId),
-        );
+        await this.connection.startTransaction(ctx);
+        const order = await this.getOrderOrThrow(ctx, input.orderId);
+        const result = await this.orderModifier.modifyOrder(ctx, input, order);
+        if (input.dryRun) {
+            await this.connection.rollBackTransaction(ctx);
+            return isGraphQlErrorResult(result) ? result : result.order;
+        }
+        if (isGraphQlErrorResult(result)) {
+            await this.connection.rollBackTransaction(ctx);
+            return result;
+        }
+        await this.historyService.createHistoryEntryForOrder({
+            ctx,
+            orderId: input.orderId,
+            type: HistoryEntryType.ORDER_MODIFIED,
+            data: {
+                modificationId: result.modification.id,
+            },
+        });
+        await this.connection.commitOpenTransaction(ctx);
+        return this.getOrderOrThrow(ctx, input.orderId);
     }
 
     private async handleFulfillmentStateTransitByOrder(
@@ -735,9 +753,22 @@ export class OrderService {
         const existingPayments = await this.getOrderPayments(ctx, order.id);
         order.payments = existingPayments;
         const amount = order.totalWithTax - totalCoveredByPayments(order);
+        const modifications = await this.getOrderModifications(ctx, order.id);
+        const unsettledModifications = modifications.filter(m => !m.isSettled);
+        const outstandingModificationsTotal = summate(unsettledModifications, 'priceChange');
+        if (outstandingModificationsTotal !== amount) {
+            throw new InternalServerError(
+                `The outstanding order amount (${amount}) should equal the unsettled OrderModifications total (${outstandingModificationsTotal})`,
+            );
+        }
+
         const payment = await this.paymentMethodService.createManualPayment(ctx, order, amount, input);
         order.payments.push(payment);
         await this.connection.getRepository(ctx, Order).save(order, { reload: false });
+        for (const modification of unsettledModifications) {
+            modification.payment = payment;
+            await this.connection.getRepository(ctx, OrderModification).save(modification);
+        }
         return order;
     }
 
@@ -884,7 +915,10 @@ export class OrderService {
             });
         }
         const items = lines.reduce((acc, l) => [...acc, ...l.items], [] as OrderItem[]);
-        const fulfillments = items.reduce((acc, i) => [...acc, ...i.fulfillments], [] as Fulfillment[]);
+        const fulfillments = items.reduce(
+            (acc, i) => [...acc, ...(i.fulfillments || [])],
+            [] as Fulfillment[],
+        );
         return unique(fulfillments, 'id');
     }
 

packages/elasticsearch-plugin/e2e/graphql/generated-e2e-elasticsearch-plugin-types.ts

@@ -3114,6 +3114,7 @@ export enum HistoryEntryType {
     ORDER_NOTE = 'ORDER_NOTE',
     ORDER_COUPON_APPLIED = 'ORDER_COUPON_APPLIED',
     ORDER_COUPON_REMOVED = 'ORDER_COUPON_REMOVED',
+    ORDER_MODIFIED = 'ORDER_MODIFIED',
 }
 
 export type HistoryEntryList = PaginatedList & {