feat(server): Implement addPaymentToOrder mutation

Relates to #36

server/src/api/resolvers/order.resolver.ts

@@ -1,6 +1,7 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
     AddItemToOrderMutationArgs,
+    AddPaymentToOrderMutationArgs,
     AdjustItemQuantityMutationArgs,
     OrderQueryArgs,
     OrdersQueryArgs,
@@ -158,6 +159,27 @@ export class OrderResolver {
         return this.orderService.removeItemFromOrder(ctx, order.id, args.orderItemId);
     }
 
+    @Mutation()
+    @Allow(Permission.UpdateOrder, Permission.Owner)
+    async addPaymentToOrder(@Ctx() ctx: RequestContext, @Args() args: AddPaymentToOrderMutationArgs) {
+        if (ctx.authorizedAsOwnerOnly) {
+            const sessionOrder = await this.getOrderFromContext(ctx);
+            if (sessionOrder) {
+                const order = await this.orderService.addPaymentToOrder(ctx, sessionOrder.id, args.input);
+
+                if (
+                    order.active === false &&
+                    ctx.session &&
+                    ctx.session.activeOrder &&
+                    ctx.session.activeOrder.id === sessionOrder.id
+                ) {
+                    await this.authService.unsetActiveOrder(ctx.session);
+                }
+                return order;
+            }
+        }
+    }
+
     private async getOrderFromContext(ctx: RequestContext): Promise<Order | undefined>;
     private async getOrderFromContext(ctx: RequestContext, createIfNotExists: true): Promise<Order>;
     private async getOrderFromContext(
@@ -170,7 +192,7 @@ export class OrderResolver {
         let order = ctx.session.activeOrder;
         if (!order) {
             if (ctx.activeUserId) {
-                order = await this.orderService.getActiveOrderForUser(ctx, ctx.activeUserId);
+                order = (await this.orderService.getActiveOrderForUser(ctx, ctx.activeUserId)) || null;
             }
 
             if (!order && createIfNotExists) {
@@ -181,6 +203,6 @@ export class OrderResolver {
                 await this.authService.setActiveOrder(ctx.session, order);
             }
         }
-        return order;
+        return order || undefined;
     }
 }

server/src/api/resolvers/shipping-method.resolver.ts

@@ -1,5 +1,4 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
-import { ShippingMethod } from 'entity/shipping-method/shipping-method.entity';
 import {
     AdjustmentOperation,
     CreateShippingMethodMutationArgs,
@@ -10,6 +9,7 @@ import {
 } from 'shared/generated-types';
 import { PaginatedList } from 'shared/shared-types';
 
+import { ShippingMethod } from '../../entity/shipping-method/shipping-method.entity';
 import { ShippingMethodService } from '../../service/services/shipping-method.service';
 import { Allow } from '../decorators/allow.decorator';
 

server/src/api/types/order.api.graphql

@@ -13,6 +13,7 @@ type Mutation {
     transitionOrderToState(state: String!): Order
     setOrderShippingAddress(input: CreateAddressInput!): Order
     setOrderShippingMethod(shippingMethodId: ID!): Order
+    addPaymentToOrder(input: PaymentInput!): Order
 }
 
 type OrderList implements PaginatedList {
@@ -26,6 +27,11 @@ type ShippingMethodQuote {
     description: String!
 }
 
+input PaymentInput {
+    method: String!
+    metadata: JSON!
+}
+
 input OrderListOptions {
     take: Int
     skip: Int

server/src/config/payment-method/fakepal-payment-method-config.ts

@@ -1,8 +1,7 @@
-import { Payment, PaymentMetadata } from 'entity/payment/payment.entity';
-
 import { Order } from '../../entity/order/order.entity';
+import { PaymentMetadata } from '../../entity/payment/payment.entity';
 
-import { PaymentMethodHandler } from './payment-method-handler';
+import { PaymentConfig, PaymentMethodHandler } from './payment-method-handler';
 
 /**
  * An example of a simple client-side payment method, where the payment authorization & settlement is
@@ -12,12 +11,12 @@ export const fakePalPaymentHandler = new PaymentMethodHandler({
     code: 'fakepal',
     name: 'FakePal Checkout',
     args: {},
-    createPayment: (order: Order, metadata: PaymentMetadata = {}): Payment => {
-        return new Payment({
+    createPayment: (order: Order, metadata: PaymentMetadata = {}): PaymentConfig => {
+        return {
             amount: order.total,
             state: 'Settled',
             transactionId: metadata.transactionId.toString(),
             metadata,
-        });
+        };
     },
 });

server/src/config/payment-method/gripe-payment-method-config.ts

@@ -1,8 +1,4 @@
-import { PaymentMetadata } from 'entity/payment/payment.entity';
-
-import { Order } from '../../entity/order/order.entity';
-
-import { PaymentMethodHandler } from './payment-method-handler';
+import { PaymentConfig, PaymentMethodHandler } from './payment-method-handler';
 
 const gripeSDK = {
     charges: {
@@ -26,7 +22,7 @@ export const gripePaymentHandler = new PaymentMethodHandler({
     args: {
         apiKey: 'string',
     },
-    createPayment: async (order, args, metadata) => {
+    createPayment: async (order, args, metadata): Promise<PaymentConfig> => {
         try {
             const result = await gripeSDK.charges.create({
                 apiKey: args.apiKey,

server/src/config/payment-method/payment-method-handler.ts

@@ -1,8 +1,8 @@
-import { Payment, PaymentMetadata } from 'entity/payment/payment.entity';
 import { ConfigArg } from 'shared/generated-types';
 
 import { StateMachineConfig } from '../../common/finite-state-machine';
 import { Order } from '../../entity/order/order.entity';
+import { PaymentMetadata } from '../../entity/payment/payment.entity';
 import {
     PaymentState,
     PaymentTransitionData,
@@ -64,10 +64,10 @@ export class PaymentMethodHandler<T extends PaymentMethodArgs = {}> {
 
     async createPayment(order: Order, args: ConfigArg[], metadata: PaymentMetadata) {
         const paymentConfig = await this.createPaymentFn(order, argsArrayToHash(args), metadata);
-        return new Payment({
+        return {
             method: this.code,
             ...paymentConfig,
-        });
+        };
     }
 
     onStateTransitionStart(

server/src/entity/order/order.entity.ts

@@ -8,6 +8,7 @@ import { VendureEntity } from '../base/base.entity';
 import { Customer } from '../customer/customer.entity';
 import { OrderItem } from '../order-item/order-item.entity';
 import { OrderLine } from '../order-line/order-line.entity';
+import { Payment } from '../payment/payment.entity';
 
 @Entity()
 export class Order extends VendureEntity {
@@ -32,6 +33,9 @@ export class Order extends VendureEntity {
 
     @Column('simple-json') shippingAddress: ShippingAddress;
 
+    @OneToMany(type => Payment, payment => payment.order)
+    payments: Payment[];
+
     @Column() subTotalBeforeTax: number;
 
     @Column() subTotal: number;

server/src/entity/order/order.graphql

@@ -4,10 +4,12 @@ type Order implements Node {
     updatedAt: DateTime!
     code: String!
     state: String!
+    active: Boolean!
     customer: Customer
     shippingAddress: ShippingAddress
     lines: [OrderLine!]!
     adjustments: [Adjustment!]!
+    payments: [Payment!]
     subTotalBeforeTax: Int!
     subTotal: Int!
     shipping: Int!

server/src/entity/payment-method/payment-method.entity.ts

@@ -2,7 +2,12 @@ import { ConfigArg } from 'shared/generated-types';
 import { DeepPartial } from 'shared/shared-types';
 import { Column, Entity } from 'typeorm';
 
+import { PaymentMethodHandler } from '../../config/payment-method/payment-method-handler';
+import { getConfig } from '../../config/vendure-config';
+import { I18nError } from '../../i18n/i18n-error';
 import { VendureEntity } from '../base/base.entity';
+import { Order } from '../order/order.entity';
+import { Payment, PaymentMetadata } from '../payment/payment.entity';
 
 @Entity()
 export class PaymentMethod extends VendureEntity {
@@ -15,4 +20,13 @@ export class PaymentMethod extends VendureEntity {
     @Column() enabled: boolean;
 
     @Column('simple-json') configArgs: ConfigArg[];
+
+    async createPayment(order: Order, metadata: PaymentMetadata) {
+        const handler = getConfig().paymentOptions.paymentMethodHandlers.find(h => h.code === this.code);
+        if (!handler) {
+            throw new I18nError(`error.no-payment-handler-with-code`, { code: this.code });
+        }
+        const result = await handler.createPayment(order, this.configArgs, metadata);
+        return new Payment(result);
+    }
 }

server/src/entity/payment/payment.entity.ts

@@ -1,8 +1,9 @@
 import { DeepPartial } from 'shared/shared-types';
-import { Column, Entity } from 'typeorm';
+import { Column, Entity, ManyToOne } from 'typeorm';
 
 import { PaymentState } from '../../service/helpers/payment-state-machine/payment-state';
 import { VendureEntity } from '../base/base.entity';
+import { Order } from '../order/order.entity';
 
 export type PaymentMetadata = { [key: string]: string | number | boolean };
 
@@ -22,4 +23,7 @@ export class Payment extends VendureEntity {
     transactionId: string;
 
     @Column('simple-json') metadata: PaymentMetadata;
+
+    @ManyToOne(type => Order, order => order.payments)
+    order: Order;
 }

server/src/entity/session/session.entity.ts

@@ -18,5 +18,5 @@ export abstract class Session extends VendureEntity {
     @Column() invalidated: boolean;
 
     @ManyToOne(type => Order)
-    activeOrder?: Order;
+    activeOrder: Order | null;
 }

server/src/service/helpers/order-state-machine/order-state-machine.ts

@@ -42,6 +42,15 @@ export class OrderStateMachine {
         }
     }
 
+    /**
+     * Specific business logic to be executed after Order state transition completes.
+     */
+    private onTransitionEnd(fromState: OrderState, toState: OrderState, data: OrderTransitionData) {
+        if (toState === 'PaymentAuthorized' || toState === 'PaymentSettled') {
+            data.order.active = false;
+        }
+    }
+
     private initConfig(): StateMachineConfig<OrderState, OrderTransitionData> {
         const {
             transtitions,
@@ -68,6 +77,7 @@ export class OrderStateMachine {
                 if (typeof onTransitionEnd === 'function') {
                     return onTransitionEnd(fromState, toState, data);
                 }
+                return this.onTransitionEnd(fromState, toState, data);
             },
             onError: (fromState, toState, message) => {
                 if (typeof onError === 'function') {

server/src/service/helpers/order-state-machine/order-state.ts

@@ -5,14 +5,26 @@ import { Order } from '../../../entity/order/order.entity';
  * These are the default states of the Order process. They can be augmented via
  * the orderProcessOptions property in VendureConfig.
  */
-export type OrderState = 'AddingItems' | 'ArrangingPayment' | 'OrderComplete' | 'Cancelled';
+export type OrderState =
+    | 'AddingItems'
+    | 'ArrangingPayment'
+    | 'PaymentAuthorized'
+    | 'PaymentSettled'
+    | 'OrderComplete'
+    | 'Cancelled';
 
 export const orderStateTransitions: Transitions<OrderState> = {
     AddingItems: {
         to: ['ArrangingPayment'],
     },
     ArrangingPayment: {
-        to: ['OrderComplete', 'AddingItems'],
+        to: ['PaymentAuthorized', 'PaymentSettled', 'AddingItems'],
+    },
+    PaymentAuthorized: {
+        to: ['PaymentSettled'],
+    },
+    PaymentSettled: {
+        to: ['OrderComplete'],
     },
     OrderComplete: {
         to: ['Cancelled'],

server/src/service/helpers/payment-state-machine/payment-state.ts

@@ -1,7 +1,6 @@
-import { Payment } from 'entity/payment/payment.entity';
-
 import { Transitions } from '../../../common/finite-state-machine';
 import { Order } from '../../../entity/order/order.entity';
+import { Payment } from '../../../entity/payment/payment.entity';
 
 /**
  * These are the default states of the Order process. They can be augmented via

server/src/service/services/auth.service.ts

@@ -89,6 +89,14 @@ export class AuthService {
         return this.connection.getRepository(Session).save(session);
     }
 
+    async unsetActiveOrder<T extends Session>(session: T): Promise<T> {
+        if (session.activeOrder) {
+            session.activeOrder = null;
+            return this.connection.getRepository(Session).save(session);
+        }
+        return session;
+    }
+
     /**
      * Deletes all existing sessions for the given user.
      */

server/src/service/services/order.service.ts

@@ -1,5 +1,5 @@
 import { InjectConnection } from '@nestjs/typeorm';
-import { CreateAddressInput, ShippingMethodQuote } from 'shared/generated-types';
+import { CreateAddressInput, PaymentInput, ShippingMethodQuote } from 'shared/generated-types';
 import { ID, PaginatedList } from 'shared/shared-types';
 import { Connection } from 'typeorm';
 
@@ -23,6 +23,7 @@ import { ShippingCalculator } from '../helpers/shipping-calculator/shipping-calc
 import { translateDeep } from '../helpers/utils/translate-entity';
 
 import { CustomerService } from './customer.service';
+import { PaymentMethodService } from './payment-method.service';
 import { ProductVariantService } from './product-variant.service';
 
 export class OrderService {
@@ -34,6 +35,7 @@ export class OrderService {
         private shippingCalculator: ShippingCalculator,
         private orderStateMachine: OrderStateMachine,
         private orderMerger: OrderMerger,
+        private paymentMethodService: PaymentMethodService,
         private listQueryBuilder: ListQueryBuilder,
     ) {}
 
@@ -201,6 +203,25 @@ export class OrderService {
         return order;
     }
 
+    async addPaymentToOrder(ctx: RequestContext, orderId: ID, input: PaymentInput): Promise<Order> {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const payment = await this.paymentMethodService.createPayment(order, input.method, input.metadata);
+        if (order.payments) {
+            order.payments.push(payment);
+        } else {
+            order.payments = [payment];
+        }
+        await this.connection.getRepository(Order).save(order);
+        const orderTotalCovered = order.payments.reduce((sum, p) => sum + p.amount, 0) === order.total;
+        if (orderTotalCovered && order.payments.every(p => p.state === 'Settled')) {
+            return this.transitionToState(ctx, orderId, 'PaymentSettled');
+        }
+        if (orderTotalCovered && order.payments.every(p => p.state === 'Authorized')) {
+            return this.transitionToState(ctx, orderId, 'PaymentAuthorized');
+        }
+        return order;
+    }
+
     /**
      * When a guest user with an anonymous Order signs in and has an existing Order associated with that Customer,
      * we need to reconcile the contents of the two orders.

server/src/service/services/payment-method.service.ts

@@ -13,7 +13,10 @@ import {
     PaymentMethodArgType,
     PaymentMethodHandler,
 } from '../../config/payment-method/payment-method-handler';
+import { Order } from '../../entity/order/order.entity';
 import { PaymentMethod } from '../../entity/payment-method/payment-method.entity';
+import { Payment, PaymentMetadata } from '../../entity/payment/payment.entity';
+import { I18nError } from '../../i18n/i18n-error';
 import { ListQueryBuilder } from '../helpers/list-query-builder/list-query-builder';
 import { getEntityOrThrow } from '../helpers/utils/get-entity-or-throw';
 import { patchEntity } from '../helpers/utils/patch-entity';
@@ -62,6 +65,20 @@ export class PaymentMethodService {
         return this.connection.getRepository(PaymentMethod).save(updatedPaymentMethod);
     }
 
+    async createPayment(order: Order, method: string, metadata: PaymentMetadata): Promise<Payment> {
+        const paymentMethod = await this.connection.getRepository(PaymentMethod).findOne({
+            where: {
+                code: method,
+                enabled: true,
+            },
+        });
+        if (!paymentMethod) {
+            throw new I18nError(`error.payment-method-not-found`, { method });
+        }
+        const payment = await paymentMethod.createPayment(order, metadata);
+        return this.connection.getRepository(Payment).save(payment);
+    }
+
     private async ensurePaymentMethodsExist() {
         const paymentMethodHandlers: Array<PaymentMethodHandler<PaymentMethodArgs>> = this.configService
             .paymentOptions.paymentMethodHandlers;

shared/generated-types.ts

@@ -295,10 +295,12 @@ export interface Order extends Node {
     updatedAt: DateTime;
     code: string;
     state: string;
+    active: boolean;
     customer?: Customer | null;
     shippingAddress?: ShippingAddress | null;
     lines: OrderLine[];
     adjustments: Adjustment[];
+    payments?: Payment[] | null;
     subTotalBeforeTax: number;
     subTotal: number;
     shipping: number;
@@ -416,6 +418,17 @@ export interface Adjustment {
     amount: number;
 }
 
+export interface Payment extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    method: string;
+    amount: number;
+    state: string;
+    transactionId?: string | null;
+    metadata?: Json | null;
+}
+
 export interface OrderList extends PaginatedList {
     items: Order[];
     totalItems: number;
@@ -603,6 +616,7 @@ export interface Mutation {
     transitionOrderToState?: Order | null;
     setOrderShippingAddress?: Order | null;
     setOrderShippingMethod?: Order | null;
+    addPaymentToOrder?: Order | null;
     updatePaymentMethod: PaymentMethod;
     createProductOptionGroup: ProductOptionGroup;
     updateProductOptionGroup: ProductOptionGroup;
@@ -638,17 +652,6 @@ export interface LoginResult {
     user: CurrentUser;
 }
 
-export interface Payment extends Node {
-    id: string;
-    createdAt: DateTime;
-    updatedAt: DateTime;
-    method: string;
-    amount: number;
-    state: string;
-    transactionId?: string | null;
-    metadata?: Json | null;
-}
-
 export interface AdministratorListOptions {
     take?: number | null;
     skip?: number | null;
@@ -1134,6 +1137,11 @@ export interface UpdateFacetValueCustomFieldsInput {
     available?: boolean | null;
 }
 
+export interface PaymentInput {
+    method: string;
+    metadata: Json;
+}
+
 export interface UpdatePaymentMethodInput {
     id: string;
     code?: string | null;
@@ -1528,6 +1536,9 @@ export interface SetOrderShippingAddressMutationArgs {
 export interface SetOrderShippingMethodMutationArgs {
     shippingMethodId: string;
 }
+export interface AddPaymentToOrderMutationArgs {
+    input: PaymentInput;
+}
 export interface UpdatePaymentMethodMutationArgs {
     input: UpdatePaymentMethodInput;
 }
@@ -2843,10 +2854,12 @@ export namespace OrderResolvers {
         updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
         code?: CodeResolver<string, any, Context>;
         state?: StateResolver<string, any, Context>;
+        active?: ActiveResolver<boolean, any, Context>;
         customer?: CustomerResolver<Customer | null, any, Context>;
         shippingAddress?: ShippingAddressResolver<ShippingAddress | null, any, Context>;
         lines?: LinesResolver<OrderLine[], any, Context>;
         adjustments?: AdjustmentsResolver<Adjustment[], any, Context>;
+        payments?: PaymentsResolver<Payment[] | null, any, Context>;
         subTotalBeforeTax?: SubTotalBeforeTaxResolver<number, any, Context>;
         subTotal?: SubTotalResolver<number, any, Context>;
         shipping?: ShippingResolver<number, any, Context>;
@@ -2860,6 +2873,7 @@ export namespace OrderResolvers {
     export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
     export type CodeResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
     export type StateResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type ActiveResolver<R = boolean, Parent = any, Context = any> = Resolver<R, Parent, Context>;
     export type CustomerResolver<R = Customer | null, Parent = any, Context = any> = Resolver<
         R,
         Parent,
@@ -2876,6 +2890,11 @@ export namespace OrderResolvers {
         Parent,
         Context
     >;
+    export type PaymentsResolver<R = Payment[] | null, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context
+    >;
     export type SubTotalBeforeTaxResolver<R = number, Parent = any, Context = any> = Resolver<
         R,
         Parent,
@@ -3234,6 +3253,32 @@ export namespace AdjustmentResolvers {
     export type AmountResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
 }
 
+export namespace PaymentResolvers {
+    export interface Resolvers<Context = any> {
+        id?: IdResolver<string, any, Context>;
+        createdAt?: CreatedAtResolver<DateTime, any, Context>;
+        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
+        method?: MethodResolver<string, any, Context>;
+        amount?: AmountResolver<number, any, Context>;
+        state?: StateResolver<string, any, Context>;
+        transactionId?: TransactionIdResolver<string | null, any, Context>;
+        metadata?: MetadataResolver<Json | null, any, Context>;
+    }
+
+    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type MethodResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type AmountResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type StateResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type TransactionIdResolver<R = string | null, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context
+    >;
+    export type MetadataResolver<R = Json | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+}
+
 export namespace OrderListResolvers {
     export interface Resolvers<Context = any> {
         items?: ItemsResolver<Order[], any, Context>;
@@ -3696,6 +3741,7 @@ export namespace MutationResolvers {
         transitionOrderToState?: TransitionOrderToStateResolver<Order | null, any, Context>;
         setOrderShippingAddress?: SetOrderShippingAddressResolver<Order | null, any, Context>;
         setOrderShippingMethod?: SetOrderShippingMethodResolver<Order | null, any, Context>;
+        addPaymentToOrder?: AddPaymentToOrderResolver<Order | null, any, Context>;
         updatePaymentMethod?: UpdatePaymentMethodResolver<PaymentMethod, any, Context>;
         createProductOptionGroup?: CreateProductOptionGroupResolver<ProductOptionGroup, any, Context>;
         updateProductOptionGroup?: UpdateProductOptionGroupResolver<ProductOptionGroup, any, Context>;
@@ -4011,6 +4057,16 @@ export namespace MutationResolvers {
         shippingMethodId: string;
     }
 
+    export type AddPaymentToOrderResolver<R = Order | null, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context,
+        AddPaymentToOrderArgs
+    >;
+    export interface AddPaymentToOrderArgs {
+        input: PaymentInput;
+    }
+
     export type UpdatePaymentMethodResolver<R = PaymentMethod, Parent = any, Context = any> = Resolver<
         R,
         Parent,
@@ -4300,32 +4356,6 @@ export namespace LoginResultResolvers {
     export type UserResolver<R = CurrentUser, Parent = any, Context = any> = Resolver<R, Parent, Context>;
 }
 
-export namespace PaymentResolvers {
-    export interface Resolvers<Context = any> {
-        id?: IdResolver<string, any, Context>;
-        createdAt?: CreatedAtResolver<DateTime, any, Context>;
-        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
-        method?: MethodResolver<string, any, Context>;
-        amount?: AmountResolver<number, any, Context>;
-        state?: StateResolver<string, any, Context>;
-        transactionId?: TransactionIdResolver<string | null, any, Context>;
-        metadata?: MetadataResolver<Json | null, any, Context>;
-    }
-
-    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type MethodResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type AmountResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type StateResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-    export type TransactionIdResolver<R = string | null, Parent = any, Context = any> = Resolver<
-        R,
-        Parent,
-        Context
-    >;
-    export type MetadataResolver<R = Json | null, Parent = any, Context = any> = Resolver<R, Parent, Context>;
-}
-
 export namespace GetAdministrators {
     export type Variables = {
         options?: AdministratorListOptions | null;
@@ -5752,6 +5782,7 @@ export namespace OrderWithLines {
         updatedAt: DateTime;
         code: string;
         state: string;
+        active: boolean;
         customer?: Customer | null;
         lines: Lines[];
         adjustments: Adjustments[];