refactor(core): Add generated types

packages/core/src/api/api-internal-modules.ts

@@ -45,7 +45,10 @@ import {
 } from './resolvers/entity/fulfillment-entity.resolver';
 import { OrderAdminEntityResolver, OrderEntityResolver } from './resolvers/entity/order-entity.resolver';
 import { OrderLineEntityResolver } from './resolvers/entity/order-line-entity.resolver';
-import { PaymentEntityResolver } from './resolvers/entity/payment-entity.resolver';
+import {
+    PaymentAdminEntityResolver,
+    PaymentEntityResolver,
+} from './resolvers/entity/payment-entity.resolver';
 import { PaymentMethodEntityResolver } from './resolvers/entity/payment-method-entity.resolver';
 import {
     ProductAdminEntityResolver,
@@ -124,6 +127,7 @@ export const adminEntityResolvers = [
     CustomerAdminEntityResolver,
     OrderAdminEntityResolver,
     FulfillmentAdminEntityResolver,
+    PaymentAdminEntityResolver,
     ProductVariantAdminEntityResolver,
     ProductAdminEntityResolver,
 ];

packages/core/src/api/resolvers/admin/order.resolver.ts

@@ -12,6 +12,7 @@ import {
     MutationSettleRefundArgs,
     MutationTransitionFulfillmentToStateArgs,
     MutationTransitionOrderToStateArgs,
+    MutationTransitionPaymentToStateArgs,
     MutationUpdateOrderNoteArgs,
     Permission,
     QueryOrderArgs,
@@ -28,6 +29,7 @@ import { Payment } from '../../../entity/payment/payment.entity';
 import { Refund } from '../../../entity/refund/refund.entity';
 import { FulfillmentState } from '../../../service/helpers/fulfillment-state-machine/fulfillment-state';
 import { OrderState } from '../../../service/helpers/order-state-machine/order-state';
+import { PaymentState } from '../../../service/helpers/payment-state-machine/payment-state';
 import { OrderService } from '../../../service/services/order.service';
 import { ShippingMethodService } from '../../../service/services/shipping-method.service';
 import { RequestContext } from '../../common/request-context';
@@ -145,4 +147,14 @@ export class OrderResolver {
     ) {
         return this.orderService.transitionFulfillmentToState(ctx, args.id, args.state as FulfillmentState);
     }
+
+    @Transaction()
+    @Mutation()
+    @Allow(Permission.UpdateOrder)
+    async transitionPaymentToState(
+        @Ctx() ctx: RequestContext,
+        @Args() args: MutationTransitionPaymentToStateArgs,
+    ) {
+        return this.orderService.transitionPaymentToState(ctx, args.id, args.state as PaymentState);
+    }
 }

packages/core/src/api/resolvers/entity/payment-entity.resolver.ts

@@ -4,6 +4,7 @@ import { pick } from '@vendure/common/lib/pick';
 import { PaymentMetadata } from '../../../common/types/common-types';
 import { Payment } from '../../../entity/payment/payment.entity';
 import { Refund } from '../../../entity/refund/refund.entity';
+import { PaymentService } from '../../../service';
 import { OrderService } from '../../../service/services/order.service';
 import { ApiType } from '../../common/get-api-type';
 import { RequestContext } from '../../common/request-context';
@@ -28,3 +29,13 @@ export class PaymentEntityResolver {
         return apiType === 'admin' ? payment.metadata : pick(payment.metadata, ['public']);
     }
 }
+
+@Resolver('Payment')
+export class PaymentAdminEntityResolver {
+    constructor(private paymentService: PaymentService) {}
+
+    @ResolveField()
+    async nextStates(@Parent() payment: Payment) {
+        return this.paymentService.getNextStates(payment);
+    }
+}

packages/core/src/api/schema/admin-api/order.api.graphql

@@ -14,6 +14,7 @@ type Mutation {
     deleteOrderNote(id: ID!): DeletionResponse!
     transitionOrderToState(id: ID!, state: String!): TransitionOrderToStateResult
     transitionFulfillmentToState(id: ID!, state: String!): TransitionFulfillmentToStateResult!
+    transitionPaymentToState(id: ID!, state: String!): TransitionPaymentToStateResult!
     setOrderCustomFields(input: UpdateOrderInput!): Order
 }
 

packages/core/src/api/schema/admin-api/payment.api.graphql

@@ -0,0 +1,3 @@
+type Payment {
+    nextStates: [String!]!
+}

packages/core/src/service/index.ts

@@ -20,6 +20,7 @@ export * from './services/facet-value.service';
 export * from './services/fulfillment.service';
 export * from './services/global-settings.service';
 export * from './services/order.service';
+export * from './services/payment.service';
 export * from './services/payment-method.service';
 export * from './services/product.service';
 export * from './services/collection.service';

packages/core/src/service/service.module.ts

@@ -43,6 +43,7 @@ import { HistoryService } from './services/history.service';
 import { OrderTestingService } from './services/order-testing.service';
 import { OrderService } from './services/order.service';
 import { PaymentMethodService } from './services/payment-method.service';
+import { PaymentService } from './services/payment.service';
 import { ProductOptionGroupService } from './services/product-option-group.service';
 import { ProductOptionService } from './services/product-option.service';
 import { ProductVariantService } from './services/product-variant.service';
@@ -75,6 +76,7 @@ const services = [
     HistoryService,
     OrderService,
     OrderTestingService,
+    PaymentService,
     PaymentMethodService,
     ProductOptionGroupService,
     ProductOptionService,

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

@@ -82,6 +82,7 @@ import { OrderCalculator } from '../helpers/order-calculator/order-calculator';
 import { OrderMerger } from '../helpers/order-merger/order-merger';
 import { OrderState } from '../helpers/order-state-machine/order-state';
 import { OrderStateMachine } from '../helpers/order-state-machine/order-state-machine';
+import { PaymentState } from '../helpers/payment-state-machine/payment-state';
 import { PaymentStateMachine } from '../helpers/payment-state-machine/payment-state-machine';
 import { RefundStateMachine } from '../helpers/refund-state-machine/refund-state-machine';
 import { ShippingCalculator } from '../helpers/shipping-calculator/shipping-calculator';
@@ -101,6 +102,7 @@ import { CustomerService } from './customer.service';
 import { FulfillmentService } from './fulfillment.service';
 import { HistoryService } from './history.service';
 import { PaymentMethodService } from './payment-method.service';
+import { PaymentService } from './payment.service';
 import { ProductVariantService } from './product-variant.service';
 import { PromotionService } from './promotion.service';
 import { StockMovementService } from './stock-movement.service';
@@ -117,6 +119,7 @@ export class OrderService {
         private shippingCalculator: ShippingCalculator,
         private orderStateMachine: OrderStateMachine,
         private orderMerger: OrderMerger,
+        private paymentService: PaymentService,
         private paymentStateMachine: PaymentStateMachine,
         private paymentMethodService: PaymentMethodService,
         private fulfillmentService: FulfillmentService,
@@ -611,6 +614,20 @@ export class OrderService {
         }
     }
 
+    async transitionPaymentToState(
+        ctx: RequestContext,
+        paymentId: ID,
+        state: PaymentState,
+    ): Promise<Payment> {
+        const payment = await this.paymentService.transitionToState(ctx, paymentId, state);
+
+        const order = payment.order;
+
+        await this.transitionOrderIfTotalIsCovered(ctx, order);
+
+        return payment;
+    }
+
     async addPaymentToOrder(
         ctx: RequestContext,
         orderId: ID,
@@ -638,6 +655,14 @@ export class OrderService {
             return new PaymentDeclinedError(payment.errorMessage || '');
         }
 
+        return this.transitionOrderIfTotalIsCovered(ctx, order);
+    }
+
+    private async transitionOrderIfTotalIsCovered(
+        ctx: RequestContext,
+        order: Order,
+    ): Promise<Order | OrderStateTransitionError> {
+        const orderId = order.id;
         if (orderTotalIsCovered(order, 'Settled')) {
             return this.transitionToState(ctx, orderId, 'PaymentSettled');
         }

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

@@ -0,0 +1,48 @@
+import { Injectable } from '@nestjs/common';
+import { DeepPartial, ID } from '@vendure/common/lib/shared-types';
+
+import { RequestContext } from '../../api/common/request-context';
+import { Payment } from '../../entity/payment/payment.entity';
+import { EventBus } from '../../event-bus/event-bus';
+import { PaymentStateTransitionEvent } from '../../event-bus/events/payment-state-transition-event';
+import { PaymentState } from '../helpers/payment-state-machine/payment-state';
+import { PaymentStateMachine } from '../helpers/payment-state-machine/payment-state-machine';
+import { TransactionalConnection } from '../transaction/transactional-connection';
+
+@Injectable()
+export class PaymentService {
+    constructor(
+        private connection: TransactionalConnection,
+        private paymentStateMachine: PaymentStateMachine,
+        private eventBus: EventBus,
+    ) {}
+
+    async create(ctx: RequestContext, input: DeepPartial<Payment>): Promise<Payment> {
+        const newPayment = new Payment({
+            ...input,
+            state: this.paymentStateMachine.getInitialState(),
+        });
+        return this.connection.getRepository(ctx, Payment).save(newPayment);
+    }
+
+    async findOneOrThrow(ctx: RequestContext, id: ID, relations: string[] = ['order']): Promise<Payment> {
+        return await this.connection.getEntityOrThrow(ctx, Payment, id, {
+            relations,
+        });
+    }
+
+    async transitionToState(ctx: RequestContext, paymentId: ID, state: PaymentState): Promise<Payment> {
+        const payment = await this.findOneOrThrow(ctx, paymentId);
+        const fromState = payment.state;
+
+        await this.paymentStateMachine.transition(ctx, payment.order, payment, state);
+        await this.connection.getRepository(ctx, Payment).save(payment, { reload: false });
+        this.eventBus.publish(new PaymentStateTransitionEvent(fromState, state, ctx, payment, payment.order));
+
+        return payment;
+    }
+
+    getNextStates(payment: Payment): ReadonlyArray<PaymentState> {
+        return this.paymentStateMachine.getNextStates(payment);
+    }
+}