Merge branch 'improved-errors' into next

.prettierignore

@@ -1,3 +1,5 @@
 generated-types.ts
 lazy-extensions.module.ts
 shared-extensions.module.ts
+generated-graphql-shop-errors.ts
+generated-graphql-admin-errors.ts

package.json

@@ -13,7 +13,7 @@
     "docs:watch": "concurrently --restart-tries 5 -n docgen,hugo,webpack -c green,blue,cyan \"yarn generate-graphql-docs && yarn generate-typescript-docs -w\" \"cd docs && hugo server\" \"cd docs && yarn webpack -w\"",
     "docs:build": "yarn generate-graphql-docs && yarn generate-typescript-docs && cd docs && yarn webpack --prod && node build.js && hugo",
     "docs:deploy": "cd docs && yarn && cd .. && yarn docs:build",
-    "codegen": "ts-node scripts/codegen/generate-graphql-types.ts",
+    "codegen": "tsc -p scripts/codegen/plugins && ts-node scripts/codegen/generate-graphql-types.ts",
     "generate-typescript-docs": "ts-node scripts/docs/generate-typescript-docs.ts",
     "generate-graphql-docs": "ts-node scripts/docs/generate-graphql-docs.ts --api=shop && ts-node scripts/docs/generate-graphql-docs.ts --api=admin",
     "version": "yarn check-imports && yarn build && yarn generate-changelog && git add CHANGELOG.md && git add */version.ts",
@@ -29,12 +29,12 @@
   "devDependencies": {
     "@commitlint/cli": "^8.2.0",
     "@commitlint/config-conventional": "^8.2.0",
-    "@graphql-codegen/add": "1.13.1",
-    "@graphql-codegen/cli": "1.13.1",
-    "@graphql-codegen/fragment-matcher": "1.13.1",
-    "@graphql-codegen/typescript": "1.13.1",
-    "@graphql-codegen/typescript-compatibility": "1.13.1",
-    "@graphql-codegen/typescript-operations": "1.13.1",
+    "@graphql-codegen/add": "2.0.1",
+    "@graphql-codegen/cli": "1.17.8",
+    "@graphql-codegen/fragment-matcher": "1.17.8",
+    "@graphql-codegen/typescript": "1.17.9",
+    "@graphql-codegen/typescript-compatibility": "2.0.0",
+    "@graphql-codegen/typescript-operations": "1.17.8",
     "@types/graphql": "^14.0.5",
     "@types/jest": "^25.1.4",
     "@types/klaw-sync": "^6.0.0",

packages/admin-ui/src/lib/core/src/common/introspection-result.ts

@@ -278,6 +278,339 @@ const result: IntrospectionResultData = {
                     },
                 ],
             },
+            {
+                kind: 'UNION',
+                name: 'AddFulfillmentToOrderResult',
+                possibleTypes: [
+                    {
+                        name: 'Fulfillment',
+                    },
+                    {
+                        name: 'EmptyOrderLineSelectionError',
+                    },
+                    {
+                        name: 'ItemsAlreadyFulfilledError',
+                    },
+                ],
+            },
+            {
+                kind: 'INTERFACE',
+                name: 'ErrorResult',
+                possibleTypes: [
+                    {
+                        name: 'EmptyOrderLineSelectionError',
+                    },
+                    {
+                        name: 'ItemsAlreadyFulfilledError',
+                    },
+                    {
+                        name: 'InvalidCredentialsError',
+                    },
+                    {
+                        name: 'QuantityTooGreatError',
+                    },
+                    {
+                        name: 'MultipleOrderError',
+                    },
+                    {
+                        name: 'CancelActiveOrderError',
+                    },
+                    {
+                        name: 'OrderStateTransitionError',
+                    },
+                    {
+                        name: 'MimeTypeError',
+                    },
+                    {
+                        name: 'LanguageNotAvailableError',
+                    },
+                    {
+                        name: 'EmailAddressConflictError',
+                    },
+                    {
+                        name: 'MissingConditionsError',
+                    },
+                    {
+                        name: 'NativeAuthStrategyError',
+                    },
+                    {
+                        name: 'NothingToRefundError',
+                    },
+                    {
+                        name: 'PaymentOrderMismatchError',
+                    },
+                    {
+                        name: 'RefundOrderStateError',
+                    },
+                    {
+                        name: 'AlreadyRefundedError',
+                    },
+                    {
+                        name: 'RefundStateTransitionError',
+                    },
+                    {
+                        name: 'ProductOptionInUseError',
+                    },
+                    {
+                        name: 'SettlePaymentError',
+                    },
+                    {
+                        name: 'PaymentStateTransitionError',
+                    },
+                    {
+                        name: 'FulfillmentStateTransitionError',
+                    },
+                    {
+                        name: 'ChannelDefaultLanguageError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'AuthenticationResult',
+                possibleTypes: [
+                    {
+                        name: 'CurrentUser',
+                    },
+                    {
+                        name: 'InvalidCredentialsError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'CancelOrderResult',
+                possibleTypes: [
+                    {
+                        name: 'Order',
+                    },
+                    {
+                        name: 'EmptyOrderLineSelectionError',
+                    },
+                    {
+                        name: 'QuantityTooGreatError',
+                    },
+                    {
+                        name: 'MultipleOrderError',
+                    },
+                    {
+                        name: 'CancelActiveOrderError',
+                    },
+                    {
+                        name: 'OrderStateTransitionError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'CreateAssetResult',
+                possibleTypes: [
+                    {
+                        name: 'Asset',
+                    },
+                    {
+                        name: 'MimeTypeError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'CreateChannelResult',
+                possibleTypes: [
+                    {
+                        name: 'Channel',
+                    },
+                    {
+                        name: 'LanguageNotAvailableError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'CreateCustomerResult',
+                possibleTypes: [
+                    {
+                        name: 'Customer',
+                    },
+                    {
+                        name: 'EmailAddressConflictError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'CreatePromotionResult',
+                possibleTypes: [
+                    {
+                        name: 'Promotion',
+                    },
+                    {
+                        name: 'MissingConditionsError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'NativeAuthenticationResult',
+                possibleTypes: [
+                    {
+                        name: 'CurrentUser',
+                    },
+                    {
+                        name: 'InvalidCredentialsError',
+                    },
+                    {
+                        name: 'NativeAuthStrategyError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'RefundOrderResult',
+                possibleTypes: [
+                    {
+                        name: 'Refund',
+                    },
+                    {
+                        name: 'QuantityTooGreatError',
+                    },
+                    {
+                        name: 'NothingToRefundError',
+                    },
+                    {
+                        name: 'OrderStateTransitionError',
+                    },
+                    {
+                        name: 'MultipleOrderError',
+                    },
+                    {
+                        name: 'PaymentOrderMismatchError',
+                    },
+                    {
+                        name: 'RefundOrderStateError',
+                    },
+                    {
+                        name: 'AlreadyRefundedError',
+                    },
+                    {
+                        name: 'RefundStateTransitionError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'RemoveOptionGroupFromProductResult',
+                possibleTypes: [
+                    {
+                        name: 'Product',
+                    },
+                    {
+                        name: 'ProductOptionInUseError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'SettlePaymentResult',
+                possibleTypes: [
+                    {
+                        name: 'Payment',
+                    },
+                    {
+                        name: 'SettlePaymentError',
+                    },
+                    {
+                        name: 'PaymentStateTransitionError',
+                    },
+                    {
+                        name: 'OrderStateTransitionError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'SettleRefundResult',
+                possibleTypes: [
+                    {
+                        name: 'Refund',
+                    },
+                    {
+                        name: 'RefundStateTransitionError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'TransitionFulfillmentToStateResult',
+                possibleTypes: [
+                    {
+                        name: 'Fulfillment',
+                    },
+                    {
+                        name: 'FulfillmentStateTransitionError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'TransitionOrderToStateResult',
+                possibleTypes: [
+                    {
+                        name: 'Order',
+                    },
+                    {
+                        name: 'OrderStateTransitionError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'UpdateChannelResult',
+                possibleTypes: [
+                    {
+                        name: 'Channel',
+                    },
+                    {
+                        name: 'LanguageNotAvailableError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'UpdateCustomerResult',
+                possibleTypes: [
+                    {
+                        name: 'Customer',
+                    },
+                    {
+                        name: 'EmailAddressConflictError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'UpdateGlobalSettingsResult',
+                possibleTypes: [
+                    {
+                        name: 'GlobalSettings',
+                    },
+                    {
+                        name: 'ChannelDefaultLanguageError',
+                    },
+                ],
+            },
+            {
+                kind: 'UNION',
+                name: 'UpdatePromotionResult',
+                possibleTypes: [
+                    {
+                        name: 'Promotion',
+                    },
+                    {
+                        name: 'MissingConditionsError',
+                    },
+                ],
+            },
         ],
     },
 };

packages/admin-ui/src/lib/core/src/data/definitions/auth-definitions.ts

@@ -1,5 +1,7 @@
 import gql from 'graphql-tag';
 
+import { ERROR_RESULT_FRAGMENT } from './shared-definitions';
+
 export const CURRENT_USER_FRAGMENT = gql`
     fragment CurrentUser on CurrentUser {
         id
@@ -16,17 +18,19 @@ export const CURRENT_USER_FRAGMENT = gql`
 export const ATTEMPT_LOGIN = gql`
     mutation AttemptLogin($username: String!, $password: String!, $rememberMe: Boolean!) {
         login(username: $username, password: $password, rememberMe: $rememberMe) {
-            user {
-                ...CurrentUser
-            }
+            ...CurrentUser
+            ...ErrorResult
         }
     }
     ${CURRENT_USER_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const LOG_OUT = gql`
     mutation LogOut {
-        logout
+        logout {
+            success
+        }
     }
 `;
 

packages/admin-ui/src/lib/core/src/data/definitions/customer-definitions.ts

@@ -1,5 +1,7 @@
 import gql from 'graphql-tag';
 
+import { ERROR_RESULT_FRAGMENT } from './shared-definitions';
+
 export const ADDRESS_FRAGMENT = gql`
     fragment Address on Address {
         id
@@ -95,18 +97,22 @@ export const CREATE_CUSTOMER = gql`
     mutation CreateCustomer($input: CreateCustomerInput!, $password: String) {
         createCustomer(input: $input, password: $password) {
             ...Customer
+            ...ErrorResult
         }
     }
     ${CUSTOMER_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const UPDATE_CUSTOMER = gql`
     mutation UpdateCustomer($input: UpdateCustomerInput!) {
         updateCustomer(input: $input) {
             ...Customer
+            ...ErrorResult
         }
     }
     ${CUSTOMER_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const DELETE_CUSTOMER = gql`

packages/admin-ui/src/lib/core/src/data/definitions/order-definitions.ts

@@ -1,5 +1,7 @@
 import gql from 'graphql-tag';
 
+import { ERROR_RESULT_FRAGMENT } from './shared-definitions';
+
 export const ADJUSTMENT_FRAGMENT = gql`
     fragment Adjustment on Adjustment {
         adjustmentSource
@@ -199,50 +201,71 @@ export const GET_ORDER = gql`
 export const SETTLE_PAYMENT = gql`
     mutation SettlePayment($id: ID!) {
         settlePayment(id: $id) {
-            id
-            transactionId
-            amount
-            method
-            state
-            metadata
+            ... on Payment {
+                id
+                transactionId
+                amount
+                method
+                state
+                metadata
+            }
+            ...ErrorResult
+            ... on SettlePaymentError {
+                paymentErrorMessage
+            }
+            ... on PaymentStateTransitionError {
+                transitionError
+            }
+            ... on OrderStateTransitionError {
+                transitionError
+            }
         }
     }
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const CREATE_FULFILLMENT = gql`
     mutation CreateFulfillment($input: FulfillOrderInput!) {
-        fulfillOrder(input: $input) {
+        addFulfillmentToOrder(input: $input) {
             ...Fulfillment
+            ...ErrorResult
         }
     }
     ${FULFILLMENT_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const CANCEL_ORDER = gql`
     mutation CancelOrder($input: CancelOrderInput!) {
         cancelOrder(input: $input) {
             ...OrderDetail
+            ...ErrorResult
         }
     }
     ${ORDER_DETAIL_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const REFUND_ORDER = gql`
     mutation RefundOrder($input: RefundOrderInput!) {
         refundOrder(input: $input) {
             ...Refund
+            ...ErrorResult
         }
     }
     ${REFUND_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const SETTLE_REFUND = gql`
     mutation SettleRefund($input: SettleRefundInput!) {
         settleRefund(input: $input) {
             ...Refund
+            ...ErrorResult
         }
     }
     ${REFUND_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const GET_ORDER_HISTORY = gql`
@@ -299,9 +322,14 @@ export const TRANSITION_ORDER_TO_STATE = gql`
     mutation TransitionOrderToState($id: ID!, $state: String!) {
         transitionOrderToState(id: $id, state: $state) {
             ...Order
+            ...ErrorResult
+            ... on OrderStateTransitionError {
+                transitionError
+            }
         }
     }
     ${ORDER_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const UPDATE_ORDER_CUSTOM_FIELDS = gql`
@@ -317,7 +345,12 @@ export const TRANSITION_FULFILLMENT_TO_STATE = gql`
     mutation TransitionFulfillmentToState($id: ID!, $state: String!) {
         transitionFulfillmentToState(id: $id, state: $state) {
             ...Fulfillment
+            ...ErrorResult
+            ... on FulfillmentStateTransitionError {
+                transitionError
+            }
         }
     }
     ${FULFILLMENT_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;

packages/admin-ui/src/lib/core/src/data/definitions/product-definitions.ts

@@ -1,5 +1,7 @@
 import gql from 'graphql-tag';
 
+import { ERROR_RESULT_FRAGMENT } from './shared-definitions';
+
 export const ASSET_FRAGMENT = gql`
     fragment Asset on Asset {
         id
@@ -274,23 +276,27 @@ export const ADD_OPTION_GROUP_TO_PRODUCT = gql`
 export const REMOVE_OPTION_GROUP_FROM_PRODUCT = gql`
     mutation RemoveOptionGroupFromProduct($productId: ID!, $optionGroupId: ID!) {
         removeOptionGroupFromProduct(productId: $productId, optionGroupId: $optionGroupId) {
-            id
-            createdAt
-            updatedAt
-            optionGroups {
+            ... on Product {
                 id
                 createdAt
                 updatedAt
-                code
-                options {
+                optionGroups {
                     id
                     createdAt
                     updatedAt
                     code
+                    options {
+                        id
+                        createdAt
+                        updatedAt
+                        code
+                    }
                 }
             }
+            ...ErrorResult
         }
     }
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const GET_PRODUCT_WITH_VARIANTS = gql`
@@ -371,6 +377,9 @@ export const CREATE_ASSETS = gql`
     mutation CreateAssets($input: [CreateAssetInput!]!) {
         createAssets(input: $input) {
             ...Asset
+            ... on ErrorResult {
+                message
+            }
         }
     }
     ${ASSET_FRAGMENT}

packages/admin-ui/src/lib/core/src/data/definitions/promotion-definitions.ts

@@ -1,6 +1,10 @@
 import gql from 'graphql-tag';
 
-import { CONFIGURABLE_OPERATION_DEF_FRAGMENT, CONFIGURABLE_OPERATION_FRAGMENT } from './shared-definitions';
+import {
+    CONFIGURABLE_OPERATION_DEF_FRAGMENT,
+    CONFIGURABLE_OPERATION_FRAGMENT,
+    ERROR_RESULT_FRAGMENT,
+} from './shared-definitions';
 
 export const PROMOTION_FRAGMENT = gql`
     fragment Promotion on Promotion {
@@ -60,9 +64,11 @@ export const CREATE_PROMOTION = gql`
     mutation CreatePromotion($input: CreatePromotionInput!) {
         createPromotion(input: $input) {
             ...Promotion
+            ...ErrorResult
         }
     }
     ${PROMOTION_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const UPDATE_PROMOTION = gql`

packages/admin-ui/src/lib/core/src/data/definitions/settings-definitions.ts

@@ -1,6 +1,6 @@
 import gql from 'graphql-tag';
 
-import { CONFIGURABLE_OPERATION_DEF_FRAGMENT } from './shared-definitions';
+import { CONFIGURABLE_OPERATION_DEF_FRAGMENT, ERROR_RESULT_FRAGMENT } from './shared-definitions';
 
 export const COUNTRY_FRAGMENT = gql`
     fragment Country on Country {
@@ -342,18 +342,22 @@ export const CREATE_CHANNEL = gql`
     mutation CreateChannel($input: CreateChannelInput!) {
         createChannel(input: $input) {
             ...Channel
+            ...ErrorResult
         }
     }
     ${CHANNEL_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const UPDATE_CHANNEL = gql`
     mutation UpdateChannel($input: UpdateChannelInput!) {
         updateChannel(input: $input) {
             ...Channel
+            ...ErrorResult
         }
     }
     ${CHANNEL_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const DELETE_CHANNEL = gql`
@@ -433,9 +437,11 @@ export const UPDATE_GLOBAL_SETTINGS = gql`
     mutation UpdateGlobalSettings($input: UpdateGlobalSettingsInput!) {
         updateGlobalSettings(input: $input) {
             ...GlobalSettings
+            ...ErrorResult
         }
     }
     ${GLOBAL_SETTINGS_FRAGMENT}
+    ${ERROR_RESULT_FRAGMENT}
 `;
 
 export const CUSTOM_FIELD_CONFIG_FRAGMENT = gql`

packages/admin-ui/src/lib/core/src/data/definitions/shared-definitions.ts

@@ -23,3 +23,10 @@ export const CONFIGURABLE_OPERATION_DEF_FRAGMENT = gql`
         description
     }
 `;
+
+export const ERROR_RESULT_FRAGMENT = gql`
+    fragment ErrorResult on ErrorResult {
+        errorCode
+        message
+    }
+`;

packages/admin-ui/src/lib/core/src/providers/auth/auth.service.ts

@@ -1,9 +1,14 @@
 import { Injectable } from '@angular/core';
 import { DEFAULT_CHANNEL_CODE } from '@vendure/common/lib/shared-constants';
 import { Observable, of } from 'rxjs';
-import { catchError, mapTo, mergeMap, switchMap } from 'rxjs/operators';
+import { catchError, map, mapTo, mergeMap, switchMap } from 'rxjs/operators';
 
-import { CurrentUserChannel, CurrentUserFragment, SetAsLoggedIn } from '../../common/generated-types';
+import {
+    AttemptLogin,
+    CurrentUserChannel,
+    CurrentUserFragment,
+    SetAsLoggedIn,
+} from '../../common/generated-types';
 import { DataService } from '../../data/providers/data.service';
 import { ServerConfigService } from '../../data/server-config';
 import { LocalStorageService } from '../local-storage/local-storage.service';
@@ -25,15 +30,22 @@ export class AuthService {
      * Attempts to log in via the REST login endpoint and updates the app
      * state on success.
      */
-    logIn(username: string, password: string, rememberMe: boolean): Observable<SetAsLoggedIn.Mutation> {
+    logIn(username: string, password: string, rememberMe: boolean): Observable<AttemptLogin.Login> {
         return this.dataService.auth.attemptLogin(username, password, rememberMe).pipe(
             switchMap(response => {
-                this.setChannelToken(response.login.user.channels);
-                return this.serverConfigService.getServerConfig().then(() => response.login.user);
+                if (response.login.__typename === 'CurrentUser') {
+                    this.setChannelToken(response.login.channels);
+                }
+                return this.serverConfigService.getServerConfig().then(() => response.login);
             }),
-            switchMap(user => {
-                const { id } = this.getActiveChannel(user.channels);
-                return this.dataService.client.loginSuccess(username, id, user.channels);
+            switchMap(login => {
+                if (login.__typename === 'CurrentUser') {
+                    const { id } = this.getActiveChannel(login.channels);
+                    return this.dataService.client
+                        .loginSuccess(username, id, login.channels)
+                        .pipe(map(() => login));
+                }
+                return of(login);
             }),
         );
     }

packages/admin-ui/src/lib/customer/src/components/customer-detail/customer-detail.component.ts

@@ -5,6 +5,8 @@ import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
 import {
     BaseDetailComponent,
     CreateAddressInput,
+    CreateCustomerAddress,
+    CreateCustomerAddressMutation,
     CreateCustomerInput,
     Customer,
     CustomFieldConfig,
@@ -19,7 +21,11 @@ import {
     NotificationService,
     ServerConfigService,
     SortOrder,
+    UpdateCustomer,
+    UpdateCustomerAddress,
+    UpdateCustomerAddressMutation,
     UpdateCustomerInput,
+    UpdateCustomerMutation,
 } from '@vendure/admin-ui/core';
 import { notNullOrUndefined } from '@vendure/common/lib/shared-utils';
 import { EMPTY, forkJoin, from, Observable, Subject } from 'rxjs';
@@ -183,30 +189,31 @@ export class CustomerDetailComponent extends BaseDetailComponent<CustomerWithOrd
             phoneNumber: formValue.phoneNumber,
             customFields,
         };
-        this.dataService.customer.createCustomer(customer, formValue.password).subscribe(
-            data => {
-                this.notificationService.success(_('common.notify-create-success'), {
-                    entity: 'Customer',
-                });
-                if (data.createCustomer.emailAddress && !formValue.password) {
-                    this.notificationService.notify({
-                        message: _('customer.email-verification-sent'),
-                        translationVars: { emailAddress: formValue.emailAddress },
-                        type: 'info',
-                        duration: 10000,
-                    });
+        this.dataService.customer
+            .createCustomer(customer, formValue.password)
+            .subscribe(({ createCustomer }) => {
+                switch (createCustomer.__typename) {
+                    case 'Customer':
+                        this.notificationService.success(_('common.notify-create-success'), {
+                            entity: 'Customer',
+                        });
+                        if (createCustomer.emailAddress && !formValue.password) {
+                            this.notificationService.notify({
+                                message: _('customer.email-verification-sent'),
+                                translationVars: { emailAddress: formValue.emailAddress },
+                                type: 'info',
+                                duration: 10000,
+                            });
+                        }
+                        this.detailForm.markAsPristine();
+                        this.addressDefaultsUpdated = false;
+                        this.changeDetector.markForCheck();
+                        this.router.navigate(['../', createCustomer.id], { relativeTo: this.route });
+                        break;
+                    case 'EmailAddressConflictError':
+                        this.notificationService.error(createCustomer.message);
                 }
-                this.detailForm.markAsPristine();
-                this.addressDefaultsUpdated = false;
-                this.changeDetector.markForCheck();
-                this.router.navigate(['../', data.createCustomer.id], { relativeTo: this.route });
-            },
-            err => {
-                this.notificationService.error(_('common.notify-create-error'), {
-                    entity: 'Customer',
-                });
-            },
-        );
+            });
     }
 
     save() {
@@ -214,7 +221,11 @@ export class CustomerDetailComponent extends BaseDetailComponent<CustomerWithOrd
             .pipe(
                 take(1),
                 mergeMap(({ id }) => {
-                    const saveOperations: Array<Observable<any>> = [];
+                    const saveOperations: Array<Observable<
+                        | UpdateCustomer.UpdateCustomer
+                        | CreateCustomerAddress.CreateCustomerAddress
+                        | UpdateCustomerAddress.UpdateCustomerAddress
+                    >> = [];
                     const customerForm = this.detailForm.get('customer');
                     if (customerForm && customerForm.dirty) {
                         const formValue = customerForm.value;
@@ -228,7 +239,11 @@ export class CustomerDetailComponent extends BaseDetailComponent<CustomerWithOrd
                             phoneNumber: formValue.phoneNumber,
                             customFields,
                         };
-                        saveOperations.push(this.dataService.customer.updateCustomer(customer));
+                        saveOperations.push(
+                            this.dataService.customer
+                                .updateCustomer(customer)
+                                .pipe(map(res => res.updateCustomer)),
+                        );
                     }
                     const addressFormArray = this.detailForm.get('addresses') as FormArray;
                     if ((addressFormArray && addressFormArray.dirty) || this.addressDefaultsUpdated) {
@@ -251,14 +266,18 @@ export class CustomerDetailComponent extends BaseDetailComponent<CustomerWithOrd
                                 };
                                 if (!address.id) {
                                     saveOperations.push(
-                                        this.dataService.customer.createCustomerAddress(id, input),
+                                        this.dataService.customer
+                                            .createCustomerAddress(id, input)
+                                            .pipe(map(res => res.createCustomerAddress)),
                                     );
                                 } else {
                                     saveOperations.push(
-                                        this.dataService.customer.updateCustomerAddress({
-                                            ...input,
-                                            id: address.id,
-                                        }),
+                                        this.dataService.customer
+                                            .updateCustomerAddress({
+                                                ...input,
+                                                id: address.id,
+                                            })
+                                            .pipe(map(res => res.updateCustomerAddress)),
                                     );
                                 }
                             }
@@ -269,13 +288,23 @@ export class CustomerDetailComponent extends BaseDetailComponent<CustomerWithOrd
             )
             .subscribe(
                 data => {
-                    this.notificationService.success(_('common.notify-update-success'), {
-                        entity: 'Customer',
-                    });
-                    this.detailForm.markAsPristine();
-                    this.addressDefaultsUpdated = false;
-                    this.changeDetector.markForCheck();
-                    this.fetchHistory.next();
+                    for (const result of data) {
+                        switch (result.__typename) {
+                            case 'Customer':
+                            case 'Address':
+                                this.notificationService.success(_('common.notify-update-success'), {
+                                    entity: 'Customer',
+                                });
+                                this.detailForm.markAsPristine();
+                                this.addressDefaultsUpdated = false;
+                                this.changeDetector.markForCheck();
+                                this.fetchHistory.next();
+                                break;
+                            case 'EmailAddressConflictError':
+                                this.notificationService.error(result.message);
+                                break;
+                        }
+                    }
                 },
                 err => {
                     this.notificationService.error(_('common.notify-update-error'), {

packages/admin-ui/src/lib/login/src/components/login/login.component.html

@@ -36,6 +36,13 @@
             >
                 {{ 'common.login' | translate }}
             </button>
+            <clr-alert [clrAlertType]="'danger'" *ngIf="errorMessage">
+                <clr-alert-item>
+                    <span class="alert-text">
+                        {{ errorMessage }}
+                    </span>
+                </clr-alert-item>
+            </clr-alert>
         </div>
         <div class="version">vendure {{ version }}</div>
     </form>

packages/admin-ui/src/lib/login/src/components/login/login.component.ts

@@ -12,23 +12,28 @@ export class LoginComponent {
     password = '';
     rememberMe = false;
     version = ADMIN_UI_VERSION;
+    errorMessage: string | undefined;
 
     constructor(private authService: AuthService, private router: Router) {}
 
     logIn(): void {
-        this.authService.logIn(this.username, this.password, this.rememberMe).subscribe(
-            () => {
-                const redirect = this.getRedirectRoute();
-                this.router.navigateByUrl(redirect ? redirect : '/');
-            },
-            err => {
-                /* error handled by http interceptor */
-            },
-        );
+        this.errorMessage = undefined;
+        this.authService.logIn(this.username, this.password, this.rememberMe).subscribe(result => {
+            switch (result.__typename) {
+                case 'CurrentUser':
+                    const redirect = this.getRedirectRoute();
+                    this.router.navigateByUrl(redirect ? redirect : '/');
+                    break;
+                case 'InvalidCredentialsError':
+                case 'NativeAuthStrategyError':
+                    this.errorMessage = result.message;
+                    break;
+            }
+        });
     }
 
     /**
-     * Attemps to read a redirect param from the current url and parse it into a
+     * Attempts to read a redirect param from the current url and parse it into a
      * route from which the user was redirected after a 401 error.
      */
     private getRedirectRoute(): string | undefined {

packages/admin-ui/src/lib/marketing/src/components/promotion-detail/promotion-detail.component.ts

@@ -138,11 +138,20 @@ export class PromotionDetailComponent extends BaseDetailComponent<Promotion.Frag
             actions: this.mapOperationsToInputs(this.actions, formValue.actions),
         };
         this.dataService.promotion.createPromotion(input).subscribe(
-            data => {
-                this.notificationService.success(_('common.notify-create-success'), { entity: 'Promotion' });
-                this.detailForm.markAsPristine();
-                this.changeDetector.markForCheck();
-                this.router.navigate(['../', data.createPromotion.id], { relativeTo: this.route });
+            ({ createPromotion }) => {
+                switch (createPromotion.__typename) {
+                    case 'Promotion':
+                        this.notificationService.success(_('common.notify-create-success'), {
+                            entity: 'Promotion',
+                        });
+                        this.detailForm.markAsPristine();
+                        this.changeDetector.markForCheck();
+                        this.router.navigate(['../', createPromotion.id], { relativeTo: this.route });
+                        break;
+                    case 'MissingConditionsError':
+                        this.notificationService.error(createPromotion.message);
+                        break;
+                }
             },
             err => {
                 this.notificationService.error(_('common.notify-create-error'), {

packages/admin-ui/src/lib/order/src/components/order-detail/order-detail.component.ts

@@ -9,6 +9,7 @@ import {
     DataService,
     EditNoteDialogComponent,
     GetOrderHistory,
+    GetOrderQuery,
     HistoryEntry,
     ModalService,
     NotificationService,
@@ -132,9 +133,15 @@ export class OrderDetailComponent extends BaseDetailComponent<OrderDetail.Fragme
     }
 
     transitionToState(state: string) {
-        this.dataService.order.transitionToState(this.id, state).subscribe(val => {
-            this.notificationService.success(_('order.transitioned-to-state-success'), { state });
-            this.fetchHistory.next();
+        this.dataService.order.transitionToState(this.id, state).subscribe(({ transitionOrderToState }) => {
+            switch (transitionOrderToState?.__typename) {
+                case 'Order':
+                    this.notificationService.success(_('order.transitioned-to-state-success'), { state });
+                    this.fetchHistory.next();
+                    break;
+                case 'OrderStateTransitionError':
+                    this.notificationService.error(transitionOrderToState.transitionError);
+            }
         });
     }
 
@@ -171,14 +178,20 @@ export class OrderDetailComponent extends BaseDetailComponent<OrderDetail.Fragme
 
     settlePayment(payment: OrderDetail.Payments) {
         this.dataService.order.settlePayment(payment.id).subscribe(({ settlePayment }) => {
-            if (settlePayment) {
-                if (settlePayment.state === 'Settled') {
-                    this.notificationService.success(_('order.settle-payment-success'));
-                } else {
-                    this.notificationService.error(_('order.settle-payment-error'));
-                }
-                this.dataService.order.getOrder(this.id).single$.subscribe();
-                this.fetchHistory.next();
+            switch (settlePayment.__typename) {
+                case 'Payment':
+                    if (settlePayment.state === 'Settled') {
+                        this.notificationService.success(_('order.settle-payment-success'));
+                    } else {
+                        this.notificationService.error(_('order.settle-payment-error'));
+                    }
+                    this.dataService.order.getOrder(this.id).single$.subscribe();
+                    this.fetchHistory.next();
+                    break;
+                case 'OrderStateTransitionError':
+                case 'PaymentStateTransitionError':
+                case 'SettlePaymentError':
+                    this.notificationService.error(settlePayment.message);
             }
         });
     }
@@ -362,15 +375,32 @@ export class OrderDetailComponent extends BaseDetailComponent<OrderDetail.Fragme
                 switchMap(input => {
                     if (input) {
                         return this.dataService.order.refundOrder(omit(input, ['cancel'])).pipe(
-                            switchMap(result => {
-                                if (input.cancel.length) {
-                                    return this.dataService.order.cancelOrder({
-                                        orderId: this.id,
-                                        lines: input.cancel,
-                                        reason: input.reason,
-                                    });
-                                } else {
-                                    return of(result);
+                            switchMap(({ refundOrder }) => {
+                                switch (refundOrder.__typename) {
+                                    case 'Refund':
+                                        if (input.cancel.length) {
+                                            return this.dataService.order
+                                                .cancelOrder({
+                                                    orderId: this.id,
+                                                    lines: input.cancel,
+                                                    reason: input.reason,
+                                                })
+                                                .pipe(map(({ cancelOrder }) => cancelOrder));
+                                        } else {
+                                            return of(refundOrder);
+                                        }
+                                    case 'AlreadyRefundedError':
+                                    case 'OrderStateTransitionError':
+                                    case 'MultipleOrderError':
+                                    case 'NothingToRefundError':
+                                    case 'PaymentOrderMismatchError':
+                                    case 'QuantityTooGreatError':
+                                    case 'RefundOrderStateError':
+                                    case 'RefundStateTransitionError':
+                                        this.notificationService.error(refundOrder.message);
+                                    // tslint:disable-next-line:no-switch-case-fall-through
+                                    default:
+                                        return of(undefined);
                                 }
                             }),
                         );
@@ -378,16 +408,27 @@ export class OrderDetailComponent extends BaseDetailComponent<OrderDetail.Fragme
                         return of(undefined);
                     }
                 }),
-                switchMap(result => this.refetchOrder(result)),
             )
             .subscribe(result => {
                 if (result) {
-                    this.notificationService.success(_('order.refund-order-success'));
+                    switch (result.__typename) {
+                        case 'Order':
+                        case 'Refund':
+                            this.refetchOrder(result).subscribe();
+                            this.notificationService.success(_('order.refund-order-success'));
+                            break;
+                        case 'QuantityTooGreatError':
+                        case 'MultipleOrderError':
+                        case 'OrderStateTransitionError':
+                        case 'CancelActiveOrderError':
+                        case 'EmptyOrderLineSelectionError':
+                            this.notificationService.error(result.message);
+                    }
                 }
             });
     }
 
-    private refetchOrder(result: object | undefined) {
+    private refetchOrder(result: object | undefined): Observable<GetOrderQuery | undefined> {
         this.fetchHistory.next();
         if (result) {
             return this.dataService.order.getOrder(this.id).single$;

packages/admin-ui/src/lib/order/src/public_api.ts

@@ -1,7 +1,9 @@
 // This file was generated by the build-public-api.ts script
 export * from './components/cancel-order-dialog/cancel-order-dialog.component';
 export * from './components/fulfill-order-dialog/fulfill-order-dialog.component';
+export * from './components/fulfillment-card/fulfillment-card.component';
 export * from './components/fulfillment-detail/fulfillment-detail.component';
+export * from './components/fulfillment-state-label/fulfillment-state-label.component';
 export * from './components/line-fulfillment/line-fulfillment.component';
 export * from './components/line-refunds/line-refunds.component';
 export * from './components/order-custom-fields-card/order-custom-fields-card.component';

packages/admin-ui/src/lib/settings/src/components/channel-detail/channel-detail.component.ts

@@ -54,7 +54,7 @@ export class ChannelDetailComponent extends BaseDetailComponent<Channel.Fragment
 
     ngOnInit() {
         this.init();
-        this.zones$ = this.dataService.settings.getZones().mapSingle((data) => data.zones);
+        this.zones$ = this.dataService.settings.getZones().mapSingle(data => data.zones);
         this.availableLanguageCodes$ = this.serverConfigService.getAvailableLanguages();
     }
 
@@ -96,21 +96,21 @@ export class ChannelDetailComponent extends BaseDetailComponent<Channel.Fragment
                     this.dataService.client.updateUserChannels(me!.channels).pipe(map(() => createChannel)),
                 ),
             )
-            .subscribe(
-                (data) => {
-                    this.notificationService.success(_('common.notify-create-success'), {
-                        entity: 'Channel',
-                    });
-                    this.detailForm.markAsPristine();
-                    this.changeDetector.markForCheck();
-                    this.router.navigate(['../', data.id], { relativeTo: this.route });
-                },
-                (err) => {
-                    this.notificationService.error(_('common.notify-create-error'), {
-                        entity: 'Channel',
-                    });
-                },
-            );
+            .subscribe(data => {
+                switch (data.__typename) {
+                    case 'Channel':
+                        this.notificationService.success(_('common.notify-create-success'), {
+                            entity: 'Channel',
+                        });
+                        this.detailForm.markAsPristine();
+                        this.changeDetector.markForCheck();
+                        this.router.navigate(['../', data.id], { relativeTo: this.route });
+                        break;
+                    case 'LanguageNotAvailableError':
+                        this.notificationService.error(data.message);
+                        break;
+                }
+            });
     }
 
     save() {
@@ -121,7 +121,7 @@ export class ChannelDetailComponent extends BaseDetailComponent<Channel.Fragment
         this.entity$
             .pipe(
                 take(1),
-                mergeMap((channel) => {
+                mergeMap(channel => {
                     const input = {
                         id: channel.id,
                         code: formValue.code,
@@ -134,20 +134,19 @@ export class ChannelDetailComponent extends BaseDetailComponent<Channel.Fragment
                     return this.dataService.settings.updateChannel(input);
                 }),
             )
-            .subscribe(
-                () => {
-                    this.notificationService.success(_('common.notify-update-success'), {
-                        entity: 'Channel',
-                    });
-                    this.detailForm.markAsPristine();
-                    this.changeDetector.markForCheck();
-                },
-                (err) => {
-                    this.notificationService.error(_('common.notify-update-error'), {
-                        entity: 'Channel',
-                    });
-                },
-            );
+            .subscribe(({ updateChannel }) => {
+                switch (updateChannel.__typename) {
+                    case 'Channel':
+                        this.notificationService.success(_('common.notify-update-success'), {
+                            entity: 'Channel',
+                        });
+                        this.detailForm.markAsPristine();
+                        this.changeDetector.markForCheck();
+                        break;
+                    case 'LanguageNotAvailableError':
+                        this.notificationService.error(updateChannel.message);
+                }
+            });
     }
 
     /**

packages/admin-ui/src/lib/settings/src/components/global-settings/global-settings.component.ts

@@ -7,7 +7,7 @@ import { CustomFieldConfig, GlobalSettings, LanguageCode, Permission } from '@ve
 import { NotificationService } from '@vendure/admin-ui/core';
 import { DataService } from '@vendure/admin-ui/core';
 import { ServerConfigService } from '@vendure/admin-ui/core';
-import { switchMap } from 'rxjs/operators';
+import { switchMap, tap } from 'rxjs/operators';
 
 @Component({
     selector: 'vdr-global-settings',
@@ -63,21 +63,23 @@ export class GlobalSettingsComponent extends BaseDetailComponent<GlobalSettings>
 
         this.dataService.settings
             .updateGlobalSettings(this.detailForm.value)
-            .pipe(switchMap(() => this.serverConfigService.refreshGlobalSettings()))
-            .subscribe(
-                () => {
-                    this.detailForm.markAsPristine();
-                    this.changeDetector.markForCheck();
-                    this.notificationService.success(_('common.notify-update-success'), {
-                        entity: 'Settings',
-                    });
-                },
-                (err) => {
-                    this.notificationService.error(_('common.notify-update-error'), {
-                        entity: 'Settings',
-                    });
-                },
-            );
+            .pipe(
+                tap(({ updateGlobalSettings }) => {
+                    switch (updateGlobalSettings.__typename) {
+                        case 'GlobalSettings':
+                            this.detailForm.markAsPristine();
+                            this.changeDetector.markForCheck();
+                            this.notificationService.success(_('common.notify-update-success'), {
+                                entity: 'Settings',
+                            });
+                            break;
+                        case 'ChannelDefaultLanguageError':
+                            this.notificationService.error(updateGlobalSettings.message);
+                    }
+                }),
+                switchMap(() => this.serverConfigService.refreshGlobalSettings()),
+            )
+            .subscribe();
     }
 
     protected setFormValues(entity: GlobalSettings, languageCode: LanguageCode): void {

packages/asset-server-plugin/e2e/asset-server-plugin.e2e-spec.ts

@@ -63,8 +63,8 @@ describe('AssetServerPlugin', () => {
         const { createAssets }: CreateAssets.Mutation = await adminClient.fileUploadMutation({
             mutation: CREATE_ASSETS,
             filePaths: filesToUpload,
-            mapVariables: (filePaths) => ({
-                input: filePaths.map((p) => ({ file: null })),
+            mapVariables: filePaths => ({
+                input: filePaths.map(p => ({ file: null })),
             }),
         });
 
@@ -188,7 +188,7 @@ describe('AssetServerPlugin', () => {
         let testImages: CreateAssets.CreateAssets[] = [];
 
         async function testMimeTypeOfAssetWithExt(ext: string, expectedMimeType: string) {
-            const testImage = testImages.find((i) => i.source.endsWith(ext))!;
+            const testImage = testImages.find(i => i.source.endsWith(ext))!;
             const result = await fetch(testImage.source);
             const contentType = result.headers.get('Content-Type');
 
@@ -198,12 +198,12 @@ describe('AssetServerPlugin', () => {
         beforeAll(async () => {
             const formats = ['gif', 'jpg', 'png', 'svg', 'tiff', 'webp'];
 
-            const filesToUpload = formats.map((ext) => path.join(__dirname, `fixtures/assets/test.${ext}`));
+            const filesToUpload = formats.map(ext => path.join(__dirname, `fixtures/assets/test.${ext}`));
             const { createAssets }: CreateAssets.Mutation = await adminClient.fileUploadMutation({
                 mutation: CREATE_ASSETS,
                 filePaths: filesToUpload,
-                mapVariables: (filePaths) => ({
-                    input: filePaths.map((p) => ({ file: null })),
+                mapVariables: filePaths => ({
+                    input: filePaths.map(p => ({ file: null })),
                 }),
             });
 
@@ -239,13 +239,15 @@ describe('AssetServerPlugin', () => {
 export const CREATE_ASSETS = gql`
     mutation CreateAssets($input: [CreateAssetInput!]!) {
         createAssets(input: $input) {
-            id
-            name
-            source
-            preview
-            focalPoint {
-                x
-                y
+            ... on Asset {
+                id
+                name
+                source
+                preview
+                focalPoint {
+                    x
+                    y
+                }
             }
         }
     }

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

@@ -1,6 +1,6 @@
 // tslint:disable
-export type Maybe<T> = T | null;
-
+export type Maybe<T> = T;
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
     ID: string | number;
@@ -8,11 +8,21 @@ export type Scalars = {
     Boolean: boolean;
     Int: number;
     Float: number;
+    /** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
     DateTime: any;
+    /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
     JSON: any;
+    /** The `Upload` scalar type represents a file upload. */
     Upload: any;
 };
 
+export type AddPaymentToOrderResult =
+    | Order
+    | OrderPaymentStateError
+    | PaymentFailedError
+    | PaymentDeclinedError
+    | OrderStateTransitionError;
+
 export type Address = Node & {
     __typename?: 'Address';
     id: Scalars['ID'];
@@ -67,6 +77,19 @@ export type AdministratorList = PaginatedList & {
     totalItems: Scalars['Int'];
 };
 
+/** Retured when attemting to set the Customer for an Order when already logged in. */
+export type AlreadyLoggedInError = ErrorResult & {
+    __typename?: 'AlreadyLoggedInError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
+export type ApplyCouponCodeResult =
+    | Order
+    | CouponCodeExpiredError
+    | CouponCodeInvalidError
+    | CouponCodeLimitError;
+
 export type Asset = Node & {
     __typename?: 'Asset';
     id: Scalars['ID'];
@@ -107,6 +130,8 @@ export type AuthenticationMethod = Node & {
     strategy: Scalars['String'];
 };
 
+export type AuthenticationResult = CurrentUser | InvalidCredentialsError;
+
 export type BooleanCustomFieldConfig = CustomField & {
     __typename?: 'BooleanCustomFieldConfig';
     name: Scalars['String'];
@@ -296,6 +321,31 @@ export type CountryTranslation = {
     name: Scalars['String'];
 };
 
+/** Returned if the provided coupon code is invalid */
+export type CouponCodeExpiredError = ErrorResult & {
+    __typename?: 'CouponCodeExpiredError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    couponCode: Scalars['String'];
+};
+
+/** Returned if the provided coupon code is invalid */
+export type CouponCodeInvalidError = ErrorResult & {
+    __typename?: 'CouponCodeInvalidError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    couponCode: Scalars['String'];
+};
+
+/** Returned if the provided coupon code is invalid */
+export type CouponCodeLimitError = ErrorResult & {
+    __typename?: 'CouponCodeLimitError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    couponCode: Scalars['String'];
+    limit: Scalars['Int'];
+};
+
 export type CreateAddressInput = {
     fullName?: Maybe<Scalars['String']>;
     company?: Maybe<Scalars['String']>;
@@ -804,6 +854,44 @@ export enum DeletionResult {
     NOT_DELETED = 'NOT_DELETED',
 }
 
+/** Retured when attemting to create a Customer with an email address already registered to an existing User. */
+export type EmailAddressConflictError = ErrorResult & {
+    __typename?: 'EmailAddressConflictError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
+export enum ErrorCode {
+    UNKNOWN_ERROR = 'UNKNOWN_ERROR',
+    ORDER_MODIFICATION_ERROR = 'ORDER_MODIFICATION_ERROR',
+    ORDER_LIMIT_ERROR = 'ORDER_LIMIT_ERROR',
+    NEGATIVE_QUANTITY_ERROR = 'NEGATIVE_QUANTITY_ERROR',
+    COUPON_CODE_EXPIRED_ERROR = 'COUPON_CODE_EXPIRED_ERROR',
+    COUPON_CODE_INVALID_ERROR = 'COUPON_CODE_INVALID_ERROR',
+    COUPON_CODE_LIMIT_ERROR = 'COUPON_CODE_LIMIT_ERROR',
+    ORDER_STATE_TRANSITION_ERROR = 'ORDER_STATE_TRANSITION_ERROR',
+    ORDER_PAYMENT_STATE_ERROR = 'ORDER_PAYMENT_STATE_ERROR',
+    PAYMENT_FAILED_ERROR = 'PAYMENT_FAILED_ERROR',
+    PAYMENT_DECLINED_ERROR = 'PAYMENT_DECLINED_ERROR',
+    ALREADY_LOGGED_IN_ERROR = 'ALREADY_LOGGED_IN_ERROR',
+    EMAIL_ADDRESS_CONFLICT_ERROR = 'EMAIL_ADDRESS_CONFLICT_ERROR',
+    INVALID_CREDENTIALS_ERROR = 'INVALID_CREDENTIALS_ERROR',
+    NATIVE_AUTH_STRATEGY_ERROR = 'NATIVE_AUTH_STRATEGY_ERROR',
+    MISSING_PASSWORD_ERROR = 'MISSING_PASSWORD_ERROR',
+    VERIFICATION_TOKEN_INVALID_ERROR = 'VERIFICATION_TOKEN_INVALID_ERROR',
+    VERIFICATION_TOKEN_EXPIRED_ERROR = 'VERIFICATION_TOKEN_EXPIRED_ERROR',
+    PASSWORD_ALREADY_SET_ERROR = 'PASSWORD_ALREADY_SET_ERROR',
+    IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR = 'IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR',
+    IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR = 'IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR',
+    PASSWORD_RESET_TOKEN_INVALID_ERROR = 'PASSWORD_RESET_TOKEN_INVALID_ERROR',
+    PASSWORD_RESET_TOKEN_EXPIRED_ERROR = 'PASSWORD_RESET_TOKEN_EXPIRED_ERROR',
+}
+
+export type ErrorResult = {
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
 export type Facet = Node & {
     __typename?: 'Facet';
     id: Scalars['ID'];
@@ -963,6 +1051,26 @@ export enum HistoryEntryType {
     ORDER_COUPON_REMOVED = 'ORDER_COUPON_REMOVED',
 }
 
+/**
+ * Retured if the token used to change a Customer's email address is valid, but has
+ * expired according to the `verificationTokenDuration` setting in the AuthOptions.
+ */
+export type IdentifierChangeTokenExpiredError = ErrorResult & {
+    __typename?: 'IdentifierChangeTokenExpiredError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
+/**
+ * Retured if the token used to change a Customer's email address is either
+ * invalid or does not match any expected tokens.
+ */
+export type IdentifierChangeTokenInvalidError = ErrorResult & {
+    __typename?: 'IdentifierChangeTokenInvalidError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
 export type ImportInfo = {
     __typename?: 'ImportInfo';
     errors?: Maybe<Array<Scalars['String']>>;
@@ -984,6 +1092,13 @@ export type IntCustomFieldConfig = CustomField & {
     step?: Maybe<Scalars['Int']>;
 };
 
+/** Returned if the user authentication credentials are not valid */
+export type InvalidCredentialsError = ErrorResult & {
+    __typename?: 'InvalidCredentialsError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
 /**
  * @description
  * Languages in the form of a ISO 639-1 language code with optional
@@ -1334,9 +1449,11 @@ export enum LogicalOperator {
     OR = 'OR',
 }
 
-export type LoginResult = {
-    __typename?: 'LoginResult';
-    user: CurrentUser;
+/** Retured when attemting to register or verify a customer account without a password, when one is required. */
+export type MissingPasswordError = ErrorResult & {
+    __typename?: 'MissingPasswordError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
 };
 
 export type Mutation = {
@@ -1345,22 +1462,22 @@ export type Mutation = {
      * Adds an item to the order. If custom fields are defined on the OrderLine
      * entity, a third argument 'customFields' will be available.
      */
-    addItemToOrder?: Maybe<Order>;
+    addItemToOrder: UpdateOrderItemsResult;
     /** Remove an OrderLine from the Order */
-    removeOrderLine?: Maybe<Order>;
+    removeOrderLine: RemoveOrderItemsResult;
     /** Remove all OrderLine from the Order */
-    removeAllOrderLines?: Maybe<Order>;
+    removeAllOrderLines: RemoveOrderItemsResult;
     /**
      * Adjusts an OrderLine. If custom fields are defined on the OrderLine entity, a
      * third argument 'customFields' of type `OrderLineCustomFieldsInput` will be available.
      */
-    adjustOrderLine?: Maybe<Order>;
+    adjustOrderLine: UpdateOrderItemsResult;
     /** Applies the given coupon code to the active Order */
-    applyCouponCode?: Maybe<Order>;
+    applyCouponCode: ApplyCouponCodeResult;
     /** Removes the given coupon code from the active Order */
     removeCouponCode?: Maybe<Order>;
     /** Transitions an Order to a new state. Valid next states can be found by querying `nextOrderStates` */
-    transitionOrderToState?: Maybe<Order>;
+    transitionOrderToState?: Maybe<TransitionOrderToStateResult>;
     /** Sets the shipping address for this order */
     setOrderShippingAddress?: Maybe<Order>;
     /** Sets the billing address for this order */
@@ -1368,25 +1485,20 @@ export type Mutation = {
     /** Allows any custom fields to be set for the active order */
     setOrderCustomFields?: Maybe<Order>;
     /** Sets the shipping method by id, which can be obtained with the `eligibleShippingMethods` query */
-    setOrderShippingMethod?: Maybe<Order>;
+    setOrderShippingMethod: SetOrderShippingMethodResult;
     /** Add a Payment to the Order */
-    addPaymentToOrder?: Maybe<Order>;
+    addPaymentToOrder?: Maybe<AddPaymentToOrderResult>;
     /** Set the Customer for the Order. Required only if the Customer is not currently logged in */
-    setCustomerForOrder?: Maybe<Order>;
+    setCustomerForOrder?: Maybe<SetCustomerForOrderResult>;
     /**
      * Authenticates the user using the native authentication strategy. This mutation
      * is an alias for `authenticate({ native: { ... }})`
      */
-    login: LoginResult;
+    login: NativeAuthenticationResult;
     /** Authenticates the user using a named authentication strategy */
-    authenticate: LoginResult;
+    authenticate: AuthenticationResult;
     /** End the current authenticated session */
-    logout: Scalars['Boolean'];
-    /**
-     * Regenerate and send a verification token for a new Customer registration. Only
-     * applicable if `authOptions.requireVerification` is set to true.
-     */
-    refreshCustomerVerification: Scalars['Boolean'];
+    logout: Success;
     /**
      * Register a Customer account with the given credentials. There are three possible registration flows:
      *
@@ -1408,7 +1520,12 @@ export type Mutation = {
      * 3. The Customer _must_ be registered _with_ a password. No further action is
      * needed - the Customer is able to authenticate immediately.
      */
-    registerCustomerAccount: Scalars['Boolean'];
+    registerCustomerAccount: RegisterCustomerAccountResult;
+    /**
+     * Regenerate and send a verification token for a new Customer registration. Only
+     * applicable if `authOptions.requireVerification` is set to true.
+     */
+    refreshCustomerVerification: RefreshCustomerVerificationResult;
     /** Update an existing Customer */
     updateCustomer: Customer;
     /** Create a new Customer Address */
@@ -1416,7 +1533,7 @@ export type Mutation = {
     /** Update an existing Address */
     updateCustomerAddress: Address;
     /** Delete an existing Address */
-    deleteCustomerAddress: Scalars['Boolean'];
+    deleteCustomerAddress: Success;
     /**
      * Verify a Customer email address with the token sent to that address. Only
      * applicable if `authOptions.requireVerification` is set to true.
@@ -1424,25 +1541,25 @@ export type Mutation = {
      * If the Customer was not registered with a password in the `registerCustomerAccount` mutation, the a password _must_ be
      * provided here.
      */
-    verifyCustomerAccount: LoginResult;
+    verifyCustomerAccount: VerifyCustomerAccountResult;
     /** Update the password of the active Customer */
-    updateCustomerPassword?: Maybe<Scalars['Boolean']>;
+    updateCustomerPassword: UpdateCustomerPasswordResult;
     /**
      * Request to update the emailAddress of the active Customer. If `authOptions.requireVerification` is enabled
      * (as is the default), then the `identifierChangeToken` will be assigned to the current User and
      * a IdentifierChangeRequestEvent will be raised. This can then be used e.g. by the EmailPlugin to email
      * that verification token to the Customer, which is then used to verify the change of email address.
      */
-    requestUpdateCustomerEmailAddress?: Maybe<Scalars['Boolean']>;
+    requestUpdateCustomerEmailAddress: RequestUpdateCustomerEmailAddressResult;
     /**
      * Confirm the update of the emailAddress with the provided token, which has been generated by the
      * `requestUpdateCustomerEmailAddress` mutation.
      */
-    updateCustomerEmailAddress?: Maybe<Scalars['Boolean']>;
+    updateCustomerEmailAddress: UpdateCustomerEmailAddressResult;
     /** Requests a password reset email to be sent */
-    requestPasswordReset?: Maybe<Scalars['Boolean']>;
+    requestPasswordReset?: Maybe<RequestPasswordResetResult>;
     /** Resets a Customer's password based on the provided token */
-    resetPassword: LoginResult;
+    resetPassword: ResetPasswordResult;
 };
 
 export type MutationAddItemToOrderArgs = {
@@ -1506,14 +1623,14 @@ export type MutationAuthenticateArgs = {
     rememberMe?: Maybe<Scalars['Boolean']>;
 };
 
-export type MutationRefreshCustomerVerificationArgs = {
-    emailAddress: Scalars['String'];
-};
-
 export type MutationRegisterCustomerAccountArgs = {
     input: RegisterCustomerInput;
 };
 
+export type MutationRefreshCustomerVerificationArgs = {
+    emailAddress: Scalars['String'];
+};
+
 export type MutationUpdateCustomerArgs = {
     input: UpdateCustomerInput;
 };
@@ -1558,11 +1675,27 @@ export type MutationResetPasswordArgs = {
     password: Scalars['String'];
 };
 
+export type NativeAuthenticationResult = CurrentUser | InvalidCredentialsError | NativeAuthStrategyError;
+
 export type NativeAuthInput = {
     username: Scalars['String'];
     password: Scalars['String'];
 };
 
+/** Retured when attempting an operation that relies on the NativeAuthStrategy, if that strategy is not configured. */
+export type NativeAuthStrategyError = ErrorResult & {
+    __typename?: 'NativeAuthStrategyError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
+/** Retured when attemting to set a negative OrderLine quantity. */
+export type NegativeQuantityError = ErrorResult & {
+    __typename?: 'NegativeQuantityError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
 export type Node = {
     id: Scalars['ID'];
 };
@@ -1663,6 +1796,14 @@ export type OrderItem = Node & {
     refundId?: Maybe<Scalars['ID']>;
 };
 
+/** Retured when the maximum order size limit has been reached. */
+export type OrderLimitError = ErrorResult & {
+    __typename?: 'OrderLimitError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    maxItems: Scalars['Int'];
+};
+
 export type OrderLine = Node & {
     __typename?: 'OrderLine';
     id: Scalars['ID'];
@@ -1693,6 +1834,20 @@ export type OrderListOptions = {
     filter?: Maybe<OrderFilterParameter>;
 };
 
+/** Returned when attempting to modify the contents of an Order that is not in the `AddingItems` state. */
+export type OrderModificationError = ErrorResult & {
+    __typename?: 'OrderModificationError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
+/** Returned when attempting to add a Payment to an Order that is not in the `ArrangingPayment` state. */
+export type OrderPaymentStateError = ErrorResult & {
+    __typename?: 'OrderPaymentStateError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
 export type OrderProcessState = {
     __typename?: 'OrderProcessState';
     name: Scalars['String'];
@@ -1713,11 +1868,48 @@ export type OrderSortParameter = {
     total?: Maybe<SortOrder>;
 };
 
+/** Returned if there is an error in transitioning the Order state */
+export type OrderStateTransitionError = ErrorResult & {
+    __typename?: 'OrderStateTransitionError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    transitionError: Scalars['String'];
+    fromState: Scalars['String'];
+    toState: Scalars['String'];
+};
+
 export type PaginatedList = {
     items: Array<Node>;
     totalItems: Scalars['Int'];
 };
 
+/** Retured when attemting to verify a customer account with a password, when a password has already been set. */
+export type PasswordAlreadySetError = ErrorResult & {
+    __typename?: 'PasswordAlreadySetError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
+/**
+ * Retured if the token used to reset a Customer's password is valid, but has
+ * expired according to the `verificationTokenDuration` setting in the AuthOptions.
+ */
+export type PasswordResetTokenExpiredError = ErrorResult & {
+    __typename?: 'PasswordResetTokenExpiredError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
+/**
+ * Retured if the token used to reset a Customer's password is either
+ * invalid or does not match any expected tokens.
+ */
+export type PasswordResetTokenInvalidError = ErrorResult & {
+    __typename?: 'PasswordResetTokenInvalidError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
 export type Payment = Node & {
     __typename?: 'Payment';
     id: Scalars['ID'];
@@ -1732,6 +1924,22 @@ export type Payment = Node & {
     metadata?: Maybe<Scalars['JSON']>;
 };
 
+/** Returned when a Payment is declined by the payment provider. */
+export type PaymentDeclinedError = ErrorResult & {
+    __typename?: 'PaymentDeclinedError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    paymentErrorMessage: Scalars['String'];
+};
+
+/** Returned when a Payment fails due to an error. */
+export type PaymentFailedError = ErrorResult & {
+    __typename?: 'PaymentFailedError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+    paymentErrorMessage: Scalars['String'];
+};
+
 /** Passed as input to the `addPaymentToOrder` mutation. */
 export type PaymentInput = {
     /** This field should correspond to the `code` property of a PaymentMethodHandler. */
@@ -2075,6 +2283,8 @@ export type QuerySearchArgs = {
     input: SearchInput;
 };
 
+export type RefreshCustomerVerificationResult = Success | NativeAuthStrategyError;
+
 export type Refund = Node & {
     __typename?: 'Refund';
     id: Scalars['ID'];
@@ -2093,6 +2303,8 @@ export type Refund = Node & {
     metadata?: Maybe<Scalars['JSON']>;
 };
 
+export type RegisterCustomerAccountResult = Success | MissingPasswordError | NativeAuthStrategyError;
+
 export type RegisterCustomerInput = {
     emailAddress: Scalars['String'];
     title?: Maybe<Scalars['String']>;
@@ -2102,6 +2314,22 @@ export type RegisterCustomerInput = {
     password?: Maybe<Scalars['String']>;
 };
 
+export type RemoveOrderItemsResult = Order | OrderModificationError;
+
+export type RequestPasswordResetResult = Success | NativeAuthStrategyError;
+
+export type RequestUpdateCustomerEmailAddressResult =
+    | Success
+    | InvalidCredentialsError
+    | EmailAddressConflictError
+    | NativeAuthStrategyError;
+
+export type ResetPasswordResult =
+    | CurrentUser
+    | PasswordResetTokenInvalidError
+    | PasswordResetTokenExpiredError
+    | NativeAuthStrategyError;
+
 export type Return = Node &
     StockMovement & {
         __typename?: 'Return';
@@ -2215,6 +2443,10 @@ export type ServerConfig = {
     customFieldConfig: CustomFields;
 };
 
+export type SetCustomerForOrderResult = Order | AlreadyLoggedInError | EmailAddressConflictError;
+
+export type SetOrderShippingMethodResult = Order | OrderModificationError;
+
 export type ShippingMethod = Node & {
     __typename?: 'ShippingMethod';
     id: Scalars['ID'];
@@ -2313,6 +2545,12 @@ export type StringOperators = {
     contains?: Maybe<Scalars['String']>;
 };
 
+/** Indicates that an operation succeeded, where we do not want to return any more specific information. */
+export type Success = {
+    __typename?: 'Success';
+    success: Scalars['Boolean'];
+};
+
 export type TaxCategory = Node & {
     __typename?: 'TaxCategory';
     id: Scalars['ID'];
@@ -2340,6 +2578,8 @@ export type TaxRateList = PaginatedList & {
     totalItems: Scalars['Int'];
 };
 
+export type TransitionOrderToStateResult = Order | OrderStateTransitionError;
+
 export type UpdateAddressInput = {
     id: Scalars['ID'];
     fullName?: Maybe<Scalars['String']>;
@@ -2356,6 +2596,12 @@ export type UpdateAddressInput = {
     customFields?: Maybe<Scalars['JSON']>;
 };
 
+export type UpdateCustomerEmailAddressResult =
+    | Success
+    | IdentifierChangeTokenInvalidError
+    | IdentifierChangeTokenExpiredError
+    | NativeAuthStrategyError;
+
 export type UpdateCustomerInput = {
     title?: Maybe<Scalars['String']>;
     firstName?: Maybe<Scalars['String']>;
@@ -2364,10 +2610,14 @@ export type UpdateCustomerInput = {
     customFields?: Maybe<Scalars['JSON']>;
 };
 
+export type UpdateCustomerPasswordResult = Success | InvalidCredentialsError | NativeAuthStrategyError;
+
 export type UpdateOrderInput = {
     customFields?: Maybe<Scalars['JSON']>;
 };
 
+export type UpdateOrderItemsResult = Order | OrderModificationError | OrderLimitError | NegativeQuantityError;
+
 export type User = Node & {
     __typename?: 'User';
     id: Scalars['ID'];
@@ -2381,6 +2631,34 @@ export type User = Node & {
     customFields?: Maybe<Scalars['JSON']>;
 };
 
+/**
+ * Returned if the verification token (used to verify a Customer's email address) is valid, but has
+ * expired according to the `verificationTokenDuration` setting in the AuthOptions.
+ */
+export type VerificationTokenExpiredError = ErrorResult & {
+    __typename?: 'VerificationTokenExpiredError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
+/**
+ * Retured if the verification token (used to verify a Customer's email address) is either
+ * invalid or does not match any expected tokens.
+ */
+export type VerificationTokenInvalidError = ErrorResult & {
+    __typename?: 'VerificationTokenInvalidError';
+    errorCode: ErrorCode;
+    message: Scalars['String'];
+};
+
+export type VerifyCustomerAccountResult =
+    | CurrentUser
+    | VerificationTokenInvalidError
+    | VerificationTokenExpiredError
+    | MissingPasswordError
+    | PasswordAlreadySetError
+    | NativeAuthStrategyError;
+
 export type Zone = Node & {
     __typename?: 'Zone';
     id: Scalars['ID'];

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

@@ -1,7 +1,7 @@
 /* tslint:disable:no-non-null-assertion */
 import { omit } from '@vendure/common/lib/omit';
 import { mergeConfig } from '@vendure/core';
-import { createTestEnvironment } from '@vendure/testing';
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
 import gql from 'graphql-tag';
 import path from 'path';
 
@@ -10,6 +10,7 @@ import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-conf
 
 import { ASSET_FRAGMENT } from './graphql/fragments';
 import {
+    AssetFragment,
     CreateAssets,
     DeleteAsset,
     DeletionResult,
@@ -26,7 +27,6 @@ import {
     GET_PRODUCT_WITH_VARIANTS,
     UPDATE_ASSET,
 } from './graphql/shared-definitions';
-import { assertThrowsWithMessage } from './utils/assert-throws-with-message';
 
 describe('Asset resolver', () => {
     const { server, adminClient } = createTestEnvironment(
@@ -137,6 +137,10 @@ describe('Asset resolver', () => {
     });
 
     describe('createAssets', () => {
+        function isAsset(input: CreateAssets.CreateAssets): input is AssetFragment {
+            return input.hasOwnProperty('name');
+        }
+
         it('permitted types by mime type', async () => {
             const filesToUpload = [
                 path.join(__dirname, 'fixtures/assets/pps1.jpg'),
@@ -150,30 +154,30 @@ describe('Asset resolver', () => {
                 }),
             });
 
-            expect(createAssets.map(a => omit(a, ['id'])).sort((a, b) => (a.name < b.name ? -1 : 1))).toEqual(
-                [
-                    {
-                        fileSize: 1680,
-                        focalPoint: null,
-                        mimeType: 'image/jpeg',
-                        name: 'pps1.jpg',
-                        preview: 'test-url/test-assets/pps1__preview.jpg',
-                        source: 'test-url/test-assets/pps1.jpg',
-                        type: 'IMAGE',
-                    },
-                    {
-                        fileSize: 1680,
-                        focalPoint: null,
-                        mimeType: 'image/jpeg',
-                        name: 'pps2.jpg',
-                        preview: 'test-url/test-assets/pps2__preview.jpg',
-                        source: 'test-url/test-assets/pps2.jpg',
-                        type: 'IMAGE',
-                    },
-                ],
-            );
+            expect(createAssets.length).toBe(2);
+            const results = createAssets.filter(isAsset);
+            expect(results.map(a => omit(a, ['id'])).sort((a, b) => (a.name < b.name ? -1 : 1))).toEqual([
+                {
+                    fileSize: 1680,
+                    focalPoint: null,
+                    mimeType: 'image/jpeg',
+                    name: 'pps1.jpg',
+                    preview: 'test-url/test-assets/pps1__preview.jpg',
+                    source: 'test-url/test-assets/pps1.jpg',
+                    type: 'IMAGE',
+                },
+                {
+                    fileSize: 1680,
+                    focalPoint: null,
+                    mimeType: 'image/jpeg',
+                    name: 'pps2.jpg',
+                    preview: 'test-url/test-assets/pps2__preview.jpg',
+                    source: 'test-url/test-assets/pps2.jpg',
+                    type: 'IMAGE',
+                },
+            ]);
 
-            createdAssetId = createAssets[0].id;
+            createdAssetId = results[0].id;
         });
 
         it('permitted type by file extension', async () => {
@@ -186,7 +190,9 @@ describe('Asset resolver', () => {
                 }),
             });
 
-            expect(createAssets.map(a => omit(a, ['id']))).toEqual([
+            expect(createAssets.length).toBe(1);
+            const results = createAssets.filter(isAsset);
+            expect(results.map(a => omit(a, ['id']))).toEqual([
                 {
                     fileSize: 1680,
                     focalPoint: null,
@@ -199,19 +205,23 @@ describe('Asset resolver', () => {
             ]);
         });
 
-        it(
-            'not permitted type',
-            assertThrowsWithMessage(async () => {
-                const filesToUpload = [path.join(__dirname, 'fixtures/assets/dummy.txt')];
-                const { createAssets }: CreateAssets.Mutation = await adminClient.fileUploadMutation({
-                    mutation: CREATE_ASSETS,
-                    filePaths: filesToUpload,
-                    mapVariables: filePaths => ({
-                        input: filePaths.map(p => ({ file: null })),
-                    }),
-                });
-            }, `The MIME type 'text/plain' is not permitted.`),
-        );
+        it('not permitted type', async () => {
+            const filesToUpload = [path.join(__dirname, 'fixtures/assets/dummy.txt')];
+            const { createAssets }: CreateAssets.Mutation = await adminClient.fileUploadMutation({
+                mutation: CREATE_ASSETS,
+                filePaths: filesToUpload,
+                mapVariables: filePaths => ({
+                    input: filePaths.map(p => ({ file: null })),
+                }),
+            });
+
+            expect(createAssets.length).toBe(1);
+            expect(createAssets[0]).toEqual({
+                message: `The MIME type 'text/plain' is not permitted.`,
+                mimeType: 'text/plain',
+                fileName: 'dummy.txt',
+            });
+        });
     });
 
     describe('updateAsset', () => {
@@ -375,9 +385,16 @@ export const CREATE_ASSETS = gql`
     mutation CreateAssets($input: [CreateAssetInput!]!) {
         createAssets(input: $input) {
             ...Asset
-            focalPoint {
-                x
-                y
+            ... on Asset {
+                focalPoint {
+                    x
+                    y
+                }
+            }
+            ... on MimeTypeError {
+                message
+                fileName
+                mimeType
             }
         }
     }

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

@@ -11,6 +11,7 @@ import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-conf
 import {
     CreateAdministrator,
     CreateRole,
+    ErrorCode,
     GetCustomerList,
     Me,
     MutationCreateProductArgs,
@@ -76,12 +77,11 @@ describe('Authorization & permissions', () => {
                 customerEmailAddress = customers.items[0].emailAddress;
             });
 
-            it(
-                'cannot login',
-                assertThrowsWithMessage(async () => {
-                    await adminClient.asUserWithCredentials(customerEmailAddress, 'test');
-                }, 'The credentials did not match. Please check and try again'),
-            );
+            it('cannot login', async () => {
+                const result = await adminClient.asUserWithCredentials(customerEmailAddress, 'test');
+
+                expect(result.errorCode).toBe(ErrorCode.INVALID_CREDENTIALS_ERROR);
+            });
         });
 
         describe('ReadCatalog permission', () => {
@@ -153,7 +153,9 @@ describe('Authorization & permissions', () => {
                     gql`
                         mutation CanCreateCustomer($input: CreateCustomerInput!) {
                             createCustomer(input: $input) {
-                                id
+                                ... on Customer {
+                                    id
+                                }
                             }
                         }
                     `,
@@ -214,9 +216,7 @@ describe('Authorization & permissions', () => {
 
         const role = roleResult.createRole;
 
-        const identifier = `${code}@${Math.random()
-            .toString(16)
-            .substr(2, 8)}`;
+        const identifier = `${code}@${Math.random().toString(16).substr(2, 8)}`;
         const password = `test`;
 
         const adminResult = await adminClient.query<

packages/core/e2e/authentication-strategy.e2e-spec.ts

@@ -1,6 +1,7 @@
+import { ErrorCode } from '@vendure/common/lib/generated-shop-types';
 import { pick } from '@vendure/common/lib/pick';
 import { mergeConfig } from '@vendure/core';
-import { createTestEnvironment } from '@vendure/testing';
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
 import gql from 'graphql-tag';
 import path from 'path';
 
@@ -10,8 +11,11 @@ import { NativeAuthenticationStrategy } from '../src/config/auth/native-authenti
 import { DefaultLogger } from '../src/config/logger/default-logger';
 
 import { TestAuthenticationStrategy, VALID_AUTH_TOKEN } from './fixtures/test-authentication-strategies';
+import { CURRENT_USER_FRAGMENT } from './graphql/fragments';
 import {
     Authenticate,
+    CurrentUser,
+    CurrentUserFragment,
     GetCustomerHistory,
     GetCustomers,
     GetCustomerUserAuth,
@@ -48,6 +52,10 @@ describe('AuthenticationStrategy', () => {
         await server.destroy();
     });
 
+    const currentUserGuard: ErrorResultGuard<CurrentUserFragment> = createErrorResultGuard<
+        CurrentUserFragment
+    >(input => input.identifier != null);
+
     describe('external auth', () => {
         const userData = {
             email: 'test@email.com',
@@ -56,24 +64,24 @@ describe('AuthenticationStrategy', () => {
         };
         let newCustomerId: string;
 
-        it(
-            'fails with a bad token',
-            assertThrowsWithMessage(async () => {
-                await shopClient.query(AUTHENTICATE, {
-                    input: {
-                        test_strategy: {
-                            token: 'bad-token',
-                        },
+        it('fails with a bad token', async () => {
+            const { authenticate } = await shopClient.query(AUTHENTICATE, {
+                input: {
+                    test_strategy: {
+                        token: 'bad-token',
                     },
-                });
-            }, 'The credentials did not match. Please check and try again'),
-        );
+                },
+            });
+
+            expect(authenticate.message).toBe('The provided credentials are invalid');
+            expect(authenticate.errorCode).toBe(ErrorCode.INVALID_CREDENTIALS_ERROR);
+        });
 
         it('creates a new Customer with valid token', async () => {
             const { customers: before } = await adminClient.query<GetCustomers.Query>(GET_CUSTOMERS);
             expect(before.totalItems).toBe(1);
 
-            const result = await shopClient.query<Authenticate.Mutation>(AUTHENTICATE, {
+            const { authenticate } = await shopClient.query<Authenticate.Mutation>(AUTHENTICATE, {
                 input: {
                     test_strategy: {
                         token: VALID_AUTH_TOKEN,
@@ -81,7 +89,9 @@ describe('AuthenticationStrategy', () => {
                     },
                 },
             });
-            expect(result.authenticate.user.identifier).toEqual(userData.email);
+            currentUserGuard.assertSuccess(authenticate);
+
+            expect(authenticate.identifier).toEqual(userData.email);
 
             const { customers: after } = await adminClient.query<GetCustomers.Query>(GET_CUSTOMERS);
             expect(after.totalItems).toBe(2);
@@ -141,7 +151,7 @@ describe('AuthenticationStrategy', () => {
         });
 
         it('logging in again re-uses created User & Customer', async () => {
-            const result = await shopClient.query<Authenticate.Mutation>(AUTHENTICATE, {
+            const { authenticate } = await shopClient.query<Authenticate.Mutation>(AUTHENTICATE, {
                 input: {
                     test_strategy: {
                         token: VALID_AUTH_TOKEN,
@@ -149,7 +159,9 @@ describe('AuthenticationStrategy', () => {
                     },
                 },
             });
-            expect(result.authenticate.user.identifier).toEqual(userData.email);
+            currentUserGuard.assertSuccess(authenticate);
+
+            expect(authenticate.identifier).toEqual(userData.email);
 
             const { customers: after } = await adminClient.query<GetCustomers.Query>(GET_CUSTOMERS);
             expect(after.totalItems).toBe(2);
@@ -160,6 +172,10 @@ describe('AuthenticationStrategy', () => {
         });
 
         it('registerCustomerAccount with external email', async () => {
+            const successErrorGuard: ErrorResultGuard<{ success: boolean }> = createErrorResultGuard<{
+                success: boolean;
+            }>(input => input.success != null);
+
             const { registerCustomerAccount } = await shopClient.query<Register.Mutation, Register.Variables>(
                 REGISTER_ACCOUNT,
                 {
@@ -168,8 +184,9 @@ describe('AuthenticationStrategy', () => {
                     },
                 },
             );
+            successErrorGuard.assertSuccess(registerCustomerAccount);
 
-            expect(registerCustomerAccount).toBe(true);
+            expect(registerCustomerAccount.success).toBe(true);
             const { customer } = await adminClient.query<
                 GetCustomerUserAuth.Query,
                 GetCustomerUserAuth.Variables
@@ -205,12 +222,14 @@ describe('AuthenticationStrategy', () => {
 const AUTHENTICATE = gql`
     mutation Authenticate($input: AuthenticationInput!) {
         authenticate(input: $input) {
-            user {
-                id
-                identifier
+            ...CurrentUser
+            ... on ErrorResult {
+                errorCode
+                message
             }
         }
     }
+    ${CURRENT_USER_FRAGMENT}
 `;
 
 const GET_CUSTOMERS = gql`

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

@@ -1,20 +1,27 @@
 /* tslint:disable:no-non-null-assertion */
 import { DEFAULT_CHANNEL_CODE } from '@vendure/common/lib/shared-constants';
-import { createTestEnvironment, E2E_DEFAULT_CHANNEL_TOKEN } from '@vendure/testing';
+import {
+    createErrorResultGuard,
+    createTestEnvironment,
+    E2E_DEFAULT_CHANNEL_TOKEN,
+    ErrorResultGuard,
+} from '@vendure/testing';
 import gql from 'graphql-tag';
 import path from 'path';
 
 import { initialData } from '../../../e2e-common/e2e-initial-data';
-import { testConfig, TEST_SETUP_TIMEOUT_MS } from '../../../e2e-common/test-config';
+import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-config';
 
 import {
     AssignProductsToChannel,
+    ChannelFragment,
     CreateAdministrator,
     CreateChannel,
     CreateRole,
     CurrencyCode,
     DeleteChannel,
     DeletionResult,
+    ErrorCode,
     GetChannels,
     GetCustomerList,
     GetProductWithVariants,
@@ -23,7 +30,7 @@ import {
     Permission,
     RemoveProductsFromChannel,
     UpdateChannel,
-    UpdateGlobalSettings,
+    UpdateGlobalLanguages,
 } from './graphql/generated-e2e-admin-types';
 import {
     ASSIGN_PRODUCT_TO_CHANNEL,
@@ -45,6 +52,10 @@ describe('Channels', () => {
     let secondChannelAdminRole: CreateRole.CreateRole;
     let customerUser: GetCustomerList.Items;
 
+    const channelGuard: ErrorResultGuard<ChannelFragment> = createErrorResultGuard<ChannelFragment>(
+        input => !!input.defaultLanguageCode,
+    );
+
     beforeAll(async () => {
         await server.init({
             initialData,
@@ -66,6 +77,30 @@ describe('Channels', () => {
         await server.destroy();
     });
 
+    it('createChannel returns error result defaultLanguageCode not available', async () => {
+        const { createChannel } = await adminClient.query<CreateChannel.Mutation, CreateChannel.Variables>(
+            CREATE_CHANNEL,
+            {
+                input: {
+                    code: 'second-channel',
+                    token: SECOND_CHANNEL_TOKEN,
+                    defaultLanguageCode: LanguageCode.zh,
+                    currencyCode: CurrencyCode.GBP,
+                    pricesIncludeTax: true,
+                    defaultShippingZoneId: 'T_1',
+                    defaultTaxZoneId: 'T_1',
+                },
+            },
+        );
+        channelGuard.assertErrorResult(createChannel);
+
+        expect(createChannel.message).toBe(
+            'Language "zh" is not available. First enable it via GlobalSettings and try again',
+        );
+        expect(createChannel.errorCode).toBe(ErrorCode.LANGUAGE_NOT_AVAILABLE_ERROR);
+        expect(createChannel.languageCode).toBe('zh');
+    });
+
     it('create a new Channel', async () => {
         const { createChannel } = await adminClient.query<CreateChannel.Mutation, CreateChannel.Variables>(
             CREATE_CHANNEL,
@@ -81,6 +116,7 @@ describe('Channels', () => {
                 },
             },
         );
+        channelGuard.assertSuccess(createChannel);
 
         expect(createChannel).toEqual({
             id: 'T_2',
@@ -356,21 +392,28 @@ describe('Channels', () => {
     });
 
     describe('setting defaultLanguage', () => {
-        it(
-            'throws if languageCode not in availableLanguages',
-            assertThrowsWithMessage(async () => {
-                await adminClient.query<UpdateChannel.Mutation, UpdateChannel.Variables>(UPDATE_CHANNEL, {
-                    input: {
-                        id: 'T_1',
-                        defaultLanguageCode: LanguageCode.zh,
-                    },
-                });
-            }, 'Language "zh" is not available. First enable it via GlobalSettings and try again.'),
-        );
+        it('returns error result if languageCode not in availableLanguages', async () => {
+            const { updateChannel } = await adminClient.query<
+                UpdateChannel.Mutation,
+                UpdateChannel.Variables
+            >(UPDATE_CHANNEL, {
+                input: {
+                    id: 'T_1',
+                    defaultLanguageCode: LanguageCode.zh,
+                },
+            });
+            channelGuard.assertErrorResult(updateChannel);
+
+            expect(updateChannel.message).toBe(
+                'Language "zh" is not available. First enable it via GlobalSettings and try again',
+            );
+            expect(updateChannel.errorCode).toBe(ErrorCode.LANGUAGE_NOT_AVAILABLE_ERROR);
+            expect(updateChannel.languageCode).toBe('zh');
+        });
 
         it('allows setting to an available language', async () => {
-            await adminClient.query<UpdateGlobalSettings.Mutation, UpdateGlobalSettings.Variables>(
-                UPDATE_GLOBAL_SETTINGS,
+            await adminClient.query<UpdateGlobalLanguages.Mutation, UpdateGlobalLanguages.Variables>(
+                UPDATE_GLOBAL_LANGUAGES,
                 {
                     input: {
                         availableLanguages: [LanguageCode.en, LanguageCode.zh],
@@ -390,20 +433,6 @@ describe('Channels', () => {
 
             expect(updateChannel.defaultLanguageCode).toBe(LanguageCode.zh);
         });
-
-        it(
-            'attempting to remove availableLanguage when used by a Channel throws',
-            assertThrowsWithMessage(async () => {
-                await adminClient.query<UpdateGlobalSettings.Mutation, UpdateGlobalSettings.Variables>(
-                    UPDATE_GLOBAL_SETTINGS,
-                    {
-                        input: {
-                            availableLanguages: [LanguageCode.en],
-                        },
-                    },
-                );
-            }, 'Cannot remove make language "zh" unavailable as it is used as the defaultLanguage by the channel "__default_channel__"'),
-        );
     });
 
     it('deleteChannel', async () => {
@@ -461,11 +490,13 @@ const DELETE_CHANNEL = gql`
     }
 `;
 
-const UPDATE_GLOBAL_SETTINGS = gql`
-    mutation UpdateGlobalSettings($input: UpdateGlobalSettingsInput!) {
+const UPDATE_GLOBAL_LANGUAGES = gql`
+    mutation UpdateGlobalLanguages($input: UpdateGlobalSettingsInput!) {
         updateGlobalSettings(input: $input) {
-            id
-            availableLanguages
+            ... on GlobalSettings {
+                id
+                availableLanguages
+            }
         }
     }
 `;

packages/core/e2e/custom-fields.e2e-spec.ts

@@ -327,7 +327,9 @@ describe('Custom fields', () => {
             await adminClient.query(gql`
                 mutation {
                     updateCustomer(input: { id: "T_1", customFields: { score: 5 } }) {
-                        id
+                        ... on Customer {
+                            id
+                        }
                     }
                 }
             `);

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

@@ -9,7 +9,7 @@ import {
     mergeConfig,
     VendurePlugin,
 } from '@vendure/core';
-import { createTestEnvironment } from '@vendure/testing';
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
 import gql from 'graphql-tag';
 import path from 'path';
 
@@ -21,10 +21,12 @@ import {
     AddNoteToCustomer,
     CreateAddress,
     CreateCustomer,
+    CustomerFragment,
     DeleteCustomer,
     DeleteCustomerAddress,
     DeleteCustomerNote,
     DeletionResult,
+    ErrorCode,
     GetCustomer,
     GetCustomerHistory,
     GetCustomerList,
@@ -34,7 +36,7 @@ import {
     UpdateCustomer,
     UpdateCustomerNote,
 } from './graphql/generated-e2e-admin-types';
-import { AddItemToOrder } from './graphql/generated-e2e-shop-types';
+import { AddItemToOrder, UpdatedOrderFragment } from './graphql/generated-e2e-shop-types';
 import {
     CREATE_ADDRESS,
     CREATE_CUSTOMER,
@@ -78,6 +80,10 @@ describe('Customer resolver', () => {
     let secondCustomer: GetCustomerList.Items;
     let thirdCustomer: GetCustomerList.Items;
 
+    const customerErrorGuard: ErrorResultGuard<CustomerFragment> = createErrorResultGuard<CustomerFragment>(
+        input => !!input.emailAddress,
+    );
+
     beforeAll(async () => {
         await server.init({
             initialData,
@@ -331,13 +337,15 @@ describe('Customer resolver', () => {
             >(
                 gql`
                     mutation DeleteCustomerAddress($id: ID!) {
-                        deleteCustomerAddress(id: $id)
+                        deleteCustomerAddress(id: $id) {
+                            success
+                        }
                     }
                 `,
                 { id: firstCustomerThirdAddressId },
             );
 
-            expect(deleteCustomerAddress).toBe(true);
+            expect(deleteCustomerAddress.success).toBe(true);
 
             const { customer } = await adminClient.query<GetCustomer.Query, GetCustomer.Variables>(
                 GET_CUSTOMER,
@@ -358,6 +366,10 @@ describe('Customer resolver', () => {
     });
 
     describe('orders', () => {
+        const orderResultGuard: ErrorResultGuard<UpdatedOrderFragment> = createErrorResultGuard<
+            UpdatedOrderFragment
+        >(input => !!input.lines);
+
         it(`lists that user\'s orders`, async () => {
             // log in as first customer
             await shopClient.asUserWithCredentials(firstCustomer.emailAddress, 'test');
@@ -369,6 +381,7 @@ describe('Customer resolver', () => {
                 productVariantId: 'T_1',
                 quantity: 1,
             });
+            orderResultGuard.assertSuccess(addItemToOrder);
 
             const { customer } = await adminClient.query<
                 GetCustomerOrders.Query,
@@ -393,6 +406,7 @@ describe('Customer resolver', () => {
                     lastName: 'Customer',
                 },
             });
+            customerErrorGuard.assertSuccess(createCustomer);
 
             expect(createCustomer.user!.verified).toBe(false);
             expect(sendEmailFn).toHaveBeenCalledTimes(1);
@@ -413,27 +427,62 @@ describe('Customer resolver', () => {
                 },
                 password: 'test',
             });
+            customerErrorGuard.assertSuccess(createCustomer);
 
             expect(createCustomer.user!.verified).toBe(true);
             expect(sendEmailFn).toHaveBeenCalledTimes(0);
         });
 
-        it(
-            'throws when using an existing, non-deleted emailAddress',
-            assertThrowsWithMessage(async () => {
-                const { createCustomer } = await adminClient.query<
-                    CreateCustomer.Mutation,
-                    CreateCustomer.Variables
-                >(CREATE_CUSTOMER, {
-                    input: {
-                        emailAddress: 'test2@test.com',
-                        firstName: 'New',
-                        lastName: 'Customer',
-                    },
-                    password: 'test',
-                });
-            }, 'The email address must be unique'),
-        );
+        it('return error result when using an existing, non-deleted emailAddress', async () => {
+            const { createCustomer } = await adminClient.query<
+                CreateCustomer.Mutation,
+                CreateCustomer.Variables
+            >(CREATE_CUSTOMER, {
+                input: {
+                    emailAddress: 'test2@test.com',
+                    firstName: 'New',
+                    lastName: 'Customer',
+                },
+                password: 'test',
+            });
+            customerErrorGuard.assertErrorResult(createCustomer);
+
+            expect(createCustomer.message).toBe('The email address is not available.');
+            expect(createCustomer.errorCode).toBe(ErrorCode.EMAIL_ADDRESS_CONFLICT_ERROR);
+        });
+    });
+
+    describe('update', () => {
+        it('returns error result when emailAddress not available', async () => {
+            const { updateCustomer } = await adminClient.query<
+                UpdateCustomer.Mutation,
+                UpdateCustomer.Variables
+            >(UPDATE_CUSTOMER, {
+                input: {
+                    id: thirdCustomer.id,
+                    emailAddress: firstCustomer.emailAddress,
+                },
+            });
+            customerErrorGuard.assertErrorResult(updateCustomer);
+
+            expect(updateCustomer.message).toBe('The email address is not available.');
+            expect(updateCustomer.errorCode).toBe(ErrorCode.EMAIL_ADDRESS_CONFLICT_ERROR);
+        });
+
+        it('succeeds when emailAddress is available', async () => {
+            const { updateCustomer } = await adminClient.query<
+                UpdateCustomer.Mutation,
+                UpdateCustomer.Variables
+            >(UPDATE_CUSTOMER, {
+                input: {
+                    id: thirdCustomer.id,
+                    emailAddress: 'unique-email@test.com',
+                },
+            });
+            customerErrorGuard.assertSuccess(updateCustomer);
+
+            expect(updateCustomer.emailAddress).toBe('unique-email@test.com');
+        });
     });
 
     describe('deletion', () => {
@@ -502,6 +551,7 @@ describe('Customer resolver', () => {
                     lastName: 'Customer',
                 },
             });
+            customerErrorGuard.assertSuccess(createCustomer);
 
             expect(createCustomer.emailAddress).toBe(thirdCustomer.emailAddress);
             expect(createCustomer.firstName).toBe('Reusing Email');

packages/core/e2e/default-search-plugin.e2e-spec.ts

@@ -16,6 +16,7 @@ import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-conf
 
 import {
     AssignProductsToChannel,
+    ChannelFragment,
     CreateChannel,
     CreateCollection,
     CreateFacet,
@@ -869,7 +870,7 @@ describe('Default search plugin', () => {
 
         describe('channel handling', () => {
             const SECOND_CHANNEL_TOKEN = 'second-channel-token';
-            let secondChannel: CreateChannel.CreateChannel;
+            let secondChannel: ChannelFragment;
 
             beforeAll(async () => {
                 const { createChannel } = await adminClient.query<

packages/core/e2e/fixtures/test-payment-methods.ts

@@ -14,7 +14,7 @@ export const testSuccessfulPaymentMethod = new PaymentMethodHandler({
             metadata,
         };
     },
-    settlePayment: (order) => ({
+    settlePayment: order => ({
         success: true,
     }),
 });
@@ -105,10 +105,11 @@ export const testFailingPaymentMethod = new PaymentMethodHandler({
         return {
             amount: order.total,
             state: 'Declined',
+            errorMessage: 'Insufficient funds',
             metadata,
         };
     },
-    settlePayment: (order) => ({
+    settlePayment: order => ({
         success: true,
     }),
 });
@@ -124,7 +125,7 @@ export const testErrorPaymentMethod = new PaymentMethodHandler({
             metadata,
         };
     },
-    settlePayment: (order) => ({
+    settlePayment: order => ({
         success: true,
     }),
 });

packages/core/e2e/global-settings.e2e-spec.ts

@@ -0,0 +1,149 @@
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
+import gql from 'graphql-tag';
+import path from 'path';
+
+import { initialData } from '../../../e2e-common/e2e-initial-data';
+import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-config';
+
+import {
+    GetGlobalSettings,
+    GlobalSettingsFragment,
+    LanguageCode,
+    UpdateGlobalSettings,
+} from './graphql/generated-e2e-admin-types';
+
+describe('GlobalSettings resolver', () => {
+    const { server, adminClient } = createTestEnvironment({
+        ...testConfig,
+        ...{
+            customFields: {
+                Customer: [{ name: 'age', type: 'int' }],
+            },
+        },
+    });
+    let globalSettings: GlobalSettingsFragment;
+
+    const globalSettingsGuard: ErrorResultGuard<GlobalSettingsFragment> = createErrorResultGuard<
+        GlobalSettingsFragment
+    >(input => !!input.availableLanguages);
+
+    beforeAll(async () => {
+        await server.init({
+            initialData,
+            productsCsvPath: path.join(__dirname, 'fixtures/e2e-products-full.csv'),
+            customerCount: 1,
+        });
+        await adminClient.asSuperAdmin();
+        const result = await adminClient.query<GetGlobalSettings.Query>(GET_GLOBAL_SETTINGS);
+        globalSettings = result.globalSettings;
+    }, TEST_SETUP_TIMEOUT_MS);
+
+    afterAll(async () => {
+        await server.destroy();
+    });
+
+    describe('globalSettings query', () => {
+        it('includes basic settings', () => {
+            expect(globalSettings.availableLanguages).toEqual([LanguageCode.en]);
+            expect(globalSettings.trackInventory).toBe(false);
+        });
+
+        it('includes orderProcess', () => {
+            expect(globalSettings.serverConfig.orderProcess[0]).toEqual({
+                name: 'AddingItems',
+                to: ['ArrangingPayment', 'Cancelled'],
+            });
+        });
+
+        it('includes permittedAssetTypes', () => {
+            expect(globalSettings.serverConfig.permittedAssetTypes).toEqual([
+                'image/*',
+                'video/*',
+                'audio/*',
+                '.pdf',
+            ]);
+        });
+
+        it('includes customFieldConfig', () => {
+            expect(globalSettings.serverConfig.customFieldConfig.Customer).toEqual([{ name: 'age' }]);
+        });
+    });
+
+    describe('update', () => {
+        it('returns error result when removing required language', async () => {
+            const { updateGlobalSettings } = await adminClient.query<
+                UpdateGlobalSettings.Mutation,
+                UpdateGlobalSettings.Variables
+            >(UPDATE_GLOBAL_SETTINGS, {
+                input: {
+                    availableLanguages: [LanguageCode.zh],
+                },
+            });
+            globalSettingsGuard.assertErrorResult(updateGlobalSettings);
+
+            expect(updateGlobalSettings.message).toBe(
+                'Cannot make language "en" unavailable as it is used as the defaultLanguage by the channel "__default_channel__"',
+            );
+        });
+
+        it('successful update', async () => {
+            const { updateGlobalSettings } = await adminClient.query<
+                UpdateGlobalSettings.Mutation,
+                UpdateGlobalSettings.Variables
+            >(UPDATE_GLOBAL_SETTINGS, {
+                input: {
+                    availableLanguages: [LanguageCode.en, LanguageCode.zh],
+                    trackInventory: true,
+                },
+            });
+            globalSettingsGuard.assertSuccess(updateGlobalSettings);
+
+            expect(updateGlobalSettings.availableLanguages).toEqual([LanguageCode.en, LanguageCode.zh]);
+            expect(updateGlobalSettings.trackInventory).toBe(true);
+        });
+    });
+});
+
+const GLOBAL_SETTINGS_FRAGMENT = gql`
+    fragment GlobalSettings on GlobalSettings {
+        id
+        availableLanguages
+        trackInventory
+        serverConfig {
+            orderProcess {
+                name
+                to
+            }
+            permittedAssetTypes
+            customFieldConfig {
+                Customer {
+                    ... on CustomField {
+                        name
+                    }
+                }
+            }
+        }
+    }
+`;
+
+const GET_GLOBAL_SETTINGS = gql`
+    query GetGlobalSettings {
+        globalSettings {
+            ...GlobalSettings
+        }
+    }
+    ${GLOBAL_SETTINGS_FRAGMENT}
+`;
+
+const UPDATE_GLOBAL_SETTINGS = gql`
+    mutation UpdateGlobalSettings($input: UpdateGlobalSettingsInput!) {
+        updateGlobalSettings(input: $input) {
+            ...GlobalSettings
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+        }
+    }
+    ${GLOBAL_SETTINGS_FRAGMENT}
+`;

packages/core/e2e/graphql/fragments.ts

@@ -452,6 +452,7 @@ export const TAX_RATE_FRAGMENT = gql`
         }
     }
 `;
+
 export const CURRENT_USER_FRAGMENT = gql`
     fragment CurrentUser on CurrentUser {
         id
@@ -463,6 +464,7 @@ export const CURRENT_USER_FRAGMENT = gql`
         }
     }
 `;
+
 export const VARIANT_WITH_STOCK_FRAGMENT = gql`
     fragment VariantWithStock on ProductVariant {
         id
@@ -479,3 +481,33 @@ export const VARIANT_WITH_STOCK_FRAGMENT = gql`
         }
     }
 `;
+
+export const FULFILLMENT_FRAGMENT = gql`
+    fragment Fulfillment on Fulfillment {
+        id
+        state
+        nextStates
+        method
+        trackingCode
+        orderItems {
+            id
+        }
+    }
+`;
+
+export const CHANNEL_FRAGMENT = gql`
+    fragment Channel on Channel {
+        id
+        code
+        token
+        currencyCode
+        defaultLanguageCode
+        defaultShippingZone {
+            id
+        }
+        defaultTaxZone {
+            id
+        }
+        pricesIncludeTax
+    }
+`;

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

@@ -3,11 +3,13 @@ import gql from 'graphql-tag';
 import {
     ADMINISTRATOR_FRAGMENT,
     ASSET_FRAGMENT,
+    CHANNEL_FRAGMENT,
     COLLECTION_FRAGMENT,
     COUNTRY_FRAGMENT,
     CURRENT_USER_FRAGMENT,
     CUSTOMER_FRAGMENT,
     FACET_WITH_VALUES_FRAGMENT,
+    FULFILLMENT_FRAGMENT,
     ORDER_FRAGMENT,
     ORDER_WITH_LINES_FRAGMENT,
     PRODUCT_VARIANT_FRAGMENT,
@@ -199,9 +201,7 @@ export const GET_CUSTOMER = gql`
 export const ATTEMPT_LOGIN = gql`
     mutation AttemptLogin($username: String!, $password: String!, $rememberMe: Boolean) {
         login(username: $username, password: $password, rememberMe: $rememberMe) {
-            user {
-                ...CurrentUser
-            }
+            ...CurrentUser
         }
     }
     ${CURRENT_USER_FRAGMENT}
@@ -288,6 +288,10 @@ export const CREATE_PROMOTION = gql`
     mutation CreatePromotion($input: CreatePromotionInput!) {
         createPromotion(input: $input) {
             ...Promotion
+            ... on ErrorResult {
+                errorCode
+                message
+            }
         }
     }
     ${PROMOTION_FRAGMENT}
@@ -304,20 +308,15 @@ export const ME = gql`
 export const CREATE_CHANNEL = gql`
     mutation CreateChannel($input: CreateChannelInput!) {
         createChannel(input: $input) {
-            id
-            code
-            token
-            currencyCode
-            defaultLanguageCode
-            defaultShippingZone {
-                id
-            }
-            defaultTaxZone {
-                id
+            ...Channel
+            ... on LanguageNotAvailableError {
+                errorCode
+                message
+                languageCode
             }
-            pricesIncludeTax
         }
     }
+    ${CHANNEL_FRAGMENT}
 `;
 
 export const DELETE_PRODUCT_VARIANT = gql`
@@ -346,13 +345,16 @@ export const REMOVE_PRODUCT_FROM_CHANNEL = gql`
     }
     ${PRODUCT_WITH_VARIANTS_FRAGMENT}
 `;
+
 export const UPDATE_ASSET = gql`
     mutation UpdateAsset($input: UpdateAssetInput!) {
         updateAsset(input: $input) {
             ...Asset
-            focalPoint {
-                x
-                y
+            ... on Asset {
+                focalPoint {
+                    x
+                    y
+                }
             }
         }
     }
@@ -371,12 +373,15 @@ export const DELETE_ASSET = gql`
 export const UPDATE_CHANNEL = gql`
     mutation UpdateChannel($input: UpdateChannelInput!) {
         updateChannel(input: $input) {
-            id
-            code
-            defaultLanguageCode
-            currencyCode
+            ...Channel
+            ... on LanguageNotAvailableError {
+                errorCode
+                message
+                languageCode
+            }
         }
     }
+    ${CHANNEL_FRAGMENT}
 `;
 
 export const GET_CUSTOMER_HISTORY = gql`
@@ -440,25 +445,31 @@ export const REMOVE_CUSTOMERS_FROM_GROUP = gql`
 
 export const CREATE_FULFILLMENT = gql`
     mutation CreateFulfillment($input: FulfillOrderInput!) {
-        fulfillOrder(input: $input) {
-            id
-            method
-            state
-            trackingCode
-            orderItems {
-                id
+        addFulfillmentToOrder(input: $input) {
+            ...Fulfillment
+            ... on ErrorResult {
+                errorCode
+                message
             }
         }
     }
+    ${FULFILLMENT_FRAGMENT}
 `;
 
 export const TRANSIT_FULFILLMENT = gql`
     mutation TransitFulfillment($id: ID!, $state: String!) {
         transitionFulfillmentToState(id: $id, state: $state) {
-            id
-            state
+            ...Fulfillment
+            ... on FulfillmentStateTransitionError {
+                errorCode
+                message
+                transitionError
+                fromState
+                toState
+            }
         }
     }
+    ${FULFILLMENT_FRAGMENT}
 `;
 
 export const GET_ORDER_FULFILLMENTS = gql`
@@ -528,6 +539,10 @@ export const CREATE_CUSTOMER = gql`
     mutation CreateCustomer($input: CreateCustomerInput!, $password: String) {
         createCustomer(input: $input, password: $password) {
             ...Customer
+            ... on ErrorResult {
+                errorCode
+                message
+            }
         }
     }
     ${CUSTOMER_FRAGMENT}
@@ -537,6 +552,10 @@ export const UPDATE_CUSTOMER = gql`
     mutation UpdateCustomer($input: UpdateCustomerInput!) {
         updateCustomer(input: $input) {
             ...Customer
+            ... on ErrorResult {
+                errorCode
+                message
+            }
         }
     }
     ${CUSTOMER_FRAGMENT}
@@ -638,9 +657,15 @@ export const GET_CUSTOMER_WITH_GROUPS = gql`
 export const ADMIN_TRANSITION_TO_STATE = gql`
     mutation AdminTransition($id: ID!, $state: String!) {
         transitionOrderToState(id: $id, state: $state) {
-            id
-            state
-            nextStates
+            ...Order
+            ... on OrderStateTransitionError {
+                errorCode
+                message
+                transitionError
+                fromState
+                toState
+            }
         }
     }
+    ${ORDER_FRAGMENT}
 `;

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

@@ -50,26 +50,18 @@ export const TEST_ORDER_FRAGMENT = gql`
     }
 `;
 
-export const ADD_ITEM_TO_ORDER = gql`
-    mutation AddItemToOrder($productVariantId: ID!, $quantity: Int!) {
-        addItemToOrder(productVariantId: $productVariantId, quantity: $quantity) {
+export const UPDATED_ORDER_FRAGMENT = gql`
+    fragment UpdatedOrder on Order {
+        id
+        code
+        state
+        active
+        total
+        lines {
             id
-            code
-            state
-            active
-            total
-            lines {
+            quantity
+            productVariant {
                 id
-                quantity
-                productVariant {
-                    id
-                }
-                adjustments {
-                    adjustmentSource
-                    amount
-                    description
-                    type
-                }
             }
             adjustments {
                 adjustmentSource
@@ -78,7 +70,26 @@ export const ADD_ITEM_TO_ORDER = gql`
                 type
             }
         }
+        adjustments {
+            adjustmentSource
+            amount
+            description
+            type
+        }
+    }
+`;
+
+export const ADD_ITEM_TO_ORDER = gql`
+    mutation AddItemToOrder($productVariantId: ID!, $quantity: Int!) {
+        addItemToOrder(productVariantId: $productVariantId, quantity: $quantity) {
+            ...UpdatedOrder
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+        }
     }
+    ${UPDATED_ORDER_FRAGMENT}
 `;
 export const SEARCH_PRODUCTS_SHOP = gql`
     query SearchProductsShop($input: SearchInput!) {
@@ -108,47 +119,105 @@ export const SEARCH_PRODUCTS_SHOP = gql`
 `;
 export const REGISTER_ACCOUNT = gql`
     mutation Register($input: RegisterCustomerInput!) {
-        registerCustomerAccount(input: $input)
+        registerCustomerAccount(input: $input) {
+            ... on Success {
+                success
+            }
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+        }
     }
 `;
+
+export const CURRENT_USER_FRAGMENT = gql`
+    fragment CurrentUserShop on CurrentUser {
+        id
+        identifier
+        channels {
+            code
+            token
+            permissions
+        }
+    }
+`;
+
 export const VERIFY_EMAIL = gql`
     mutation Verify($password: String, $token: String!) {
         verifyCustomerAccount(password: $password, token: $token) {
-            user {
-                id
-                identifier
+            ...CurrentUserShop
+            ... on ErrorResult {
+                errorCode
+                message
             }
         }
     }
+    ${CURRENT_USER_FRAGMENT}
 `;
+
 export const REFRESH_TOKEN = gql`
     mutation RefreshToken($emailAddress: String!) {
-        refreshCustomerVerification(emailAddress: $emailAddress)
+        refreshCustomerVerification(emailAddress: $emailAddress) {
+            ... on Success {
+                success
+            }
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+        }
     }
 `;
 export const REQUEST_PASSWORD_RESET = gql`
     mutation RequestPasswordReset($identifier: String!) {
-        requestPasswordReset(emailAddress: $identifier)
+        requestPasswordReset(emailAddress: $identifier) {
+            ... on Success {
+                success
+            }
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+        }
     }
 `;
 export const RESET_PASSWORD = gql`
     mutation ResetPassword($token: String!, $password: String!) {
         resetPassword(token: $token, password: $password) {
-            user {
-                id
-                identifier
+            ...CurrentUserShop
+            ... on ErrorResult {
+                errorCode
+                message
             }
         }
     }
+    ${CURRENT_USER_FRAGMENT}
 `;
 export const REQUEST_UPDATE_EMAIL_ADDRESS = gql`
     mutation RequestUpdateEmailAddress($password: String!, $newEmailAddress: String!) {
-        requestUpdateCustomerEmailAddress(password: $password, newEmailAddress: $newEmailAddress)
+        requestUpdateCustomerEmailAddress(password: $password, newEmailAddress: $newEmailAddress) {
+            ... on Success {
+                success
+            }
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+        }
     }
 `;
 export const UPDATE_EMAIL_ADDRESS = gql`
     mutation UpdateEmailAddress($token: String!) {
-        updateCustomerEmailAddress(token: $token)
+        updateCustomerEmailAddress(token: $token) {
+            ... on Success {
+                success
+            }
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+        }
     }
 `;
 export const GET_ACTIVE_CUSTOMER = gql`
@@ -182,7 +251,9 @@ export const UPDATE_ADDRESS = gql`
 `;
 export const DELETE_ADDRESS = gql`
     mutation DeleteAddressShop($id: ID!) {
-        deleteCustomerAddress(id: $id)
+        deleteCustomerAddress(id: $id) {
+            success
+        }
     }
 `;
 
@@ -198,7 +269,15 @@ export const UPDATE_CUSTOMER = gql`
 
 export const UPDATE_PASSWORD = gql`
     mutation UpdatePassword($old: String!, $new: String!) {
-        updateCustomerPassword(currentPassword: $old, newPassword: $new)
+        updateCustomerPassword(currentPassword: $old, newPassword: $new) {
+            ... on Success {
+                success
+            }
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+        }
     }
 `;
 
@@ -215,6 +294,10 @@ export const ADJUST_ITEM_QUANTITY = gql`
     mutation AdjustItemQuantity($orderLineId: ID!, $quantity: Int!) {
         adjustOrderLine(orderLineId: $orderLineId, quantity: $quantity) {
             ...TestOrderFragment
+            ... on ErrorResult {
+                errorCode
+                message
+            }
         }
     }
     ${TEST_ORDER_FRAGMENT}
@@ -224,6 +307,10 @@ export const REMOVE_ITEM_FROM_ORDER = gql`
     mutation RemoveItemFromOrder($orderLineId: ID!) {
         removeOrderLine(orderLineId: $orderLineId) {
             ...TestOrderFragment
+            ... on ErrorResult {
+                errorCode
+                message
+            }
         }
     }
     ${TEST_ORDER_FRAGMENT}
@@ -242,28 +329,42 @@ export const GET_ELIGIBLE_SHIPPING_METHODS = gql`
 export const SET_SHIPPING_METHOD = gql`
     mutation SetShippingMethod($id: ID!) {
         setOrderShippingMethod(shippingMethodId: $id) {
-            shipping
-            shippingMethod {
-                id
-                code
-                description
+            ...TestOrderFragment
+            ... on ErrorResult {
+                errorCode
+                message
             }
         }
     }
+    ${TEST_ORDER_FRAGMENT}
+`;
+
+export const ACTIVE_ORDER_CUSTOMER = gql`
+    fragment ActiveOrderCustomer on Order {
+        id
+        customer {
+            id
+            emailAddress
+            firstName
+            lastName
+        }
+        lines {
+            id
+        }
+    }
 `;
 
 export const SET_CUSTOMER = gql`
     mutation SetCustomerForOrder($input: CreateCustomerInput!) {
         setCustomerForOrder(input: $input) {
-            id
-            customer {
-                id
-                emailAddress
-                firstName
-                lastName
+            ...ActiveOrderCustomer
+            ... on ErrorResult {
+                errorCode
+                message
             }
         }
     }
+    ${ACTIVE_ORDER_CUSTOMER}
 `;
 
 export const GET_ORDER_BY_CODE = gql`
@@ -300,10 +401,17 @@ export const GET_AVAILABLE_COUNTRIES = gql`
 export const TRANSITION_TO_STATE = gql`
     mutation TransitionToState($state: String!) {
         transitionOrderToState(state: $state) {
-            id
-            state
+            ...TestOrderFragment
+            ... on OrderStateTransitionError {
+                errorCode
+                message
+                transitionError
+                fromState
+                toState
+            }
         }
     }
+    ${TEST_ORDER_FRAGMENT}
 `;
 
 export const SET_SHIPPING_ADDRESS = gql`
@@ -342,21 +450,47 @@ export const SET_BILLING_ADDRESS = gql`
     }
 `;
 
+export const TEST_ORDER_WITH_PAYMENTS_FRAGMENT = gql`
+    fragment TestOrderWithPayments on Order {
+        ...TestOrderFragment
+        payments {
+            id
+            transactionId
+            method
+            amount
+            state
+            metadata
+        }
+    }
+    ${TEST_ORDER_FRAGMENT}
+`;
+
+export const GET_ACTIVE_ORDER_WITH_PAYMENTS = gql`
+    query GetActiveOrderWithPayments {
+        activeOrder {
+            ...TestOrderWithPayments
+        }
+    }
+    ${TEST_ORDER_WITH_PAYMENTS_FRAGMENT}
+`;
+
 export const ADD_PAYMENT = gql`
     mutation AddPaymentToOrder($input: PaymentInput!) {
         addPaymentToOrder(input: $input) {
-            ...TestOrderFragment
-            payments {
-                id
-                transactionId
-                method
-                amount
-                state
-                metadata
+            ...TestOrderWithPayments
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+            ... on PaymentDeclinedError {
+                paymentErrorMessage
+            }
+            ... on PaymentFailedError {
+                paymentErrorMessage
             }
         }
     }
-    ${TEST_ORDER_FRAGMENT}
+    ${TEST_ORDER_WITH_PAYMENTS_FRAGMENT}
 `;
 
 export const GET_ACTIVE_ORDER_PAYMENTS = gql`
@@ -413,6 +547,10 @@ export const APPLY_COUPON_CODE = gql`
     mutation ApplyCouponCode($couponCode: String!) {
         applyCouponCode(couponCode: $couponCode) {
             ...TestOrderFragment
+            ... on ErrorResult {
+                errorCode
+                message
+            }
         }
     }
     ${TEST_ORDER_FRAGMENT}
@@ -431,6 +569,10 @@ export const REMOVE_ALL_ORDER_LINES = gql`
     mutation RemoveAllOrderLines {
         removeAllOrderLines {
             ...TestOrderFragment
+            ... on ErrorResult {
+                errorCode
+                message
+            }
         }
     }
     ${TEST_ORDER_FRAGMENT}

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

@@ -1,5 +1,10 @@
 /* tslint:disable:no-non-null-assertion */
-import { createTestEnvironment, E2E_DEFAULT_CHANNEL_TOKEN } from '@vendure/testing';
+import {
+    createErrorResultGuard,
+    createTestEnvironment,
+    E2E_DEFAULT_CHANNEL_TOKEN,
+    ErrorResultGuard,
+} from '@vendure/testing';
 import path from 'path';
 
 import { initialData } from '../../../e2e-common/e2e-initial-data';
@@ -15,7 +20,7 @@ import {
     GetProductWithVariants,
     LanguageCode,
 } from './graphql/generated-e2e-admin-types';
-import { AddItemToOrder, GetActiveOrder } from './graphql/generated-e2e-shop-types';
+import { AddItemToOrder, GetActiveOrder, UpdatedOrderFragment } from './graphql/generated-e2e-shop-types';
 import {
     ASSIGN_PRODUCT_TO_CHANNEL,
     CREATE_CHANNEL,
@@ -120,6 +125,10 @@ describe('Channelaware orders', () => {
         await server.destroy();
     });
 
+    const orderResultGuard: ErrorResultGuard<UpdatedOrderFragment> = createErrorResultGuard<
+        UpdatedOrderFragment
+    >(input => !!input.lines);
+
     it('creates order on current channel', async () => {
         shopClient.setChannelToken(SECOND_CHANNEL_TOKEN);
         const { addItemToOrder } = await shopClient.query<AddItemToOrder.Mutation, AddItemToOrder.Variables>(
@@ -129,6 +138,7 @@ describe('Channelaware orders', () => {
                 quantity: 1,
             },
         );
+        orderResultGuard.assertSuccess(addItemToOrder);
 
         expect(addItemToOrder!.lines.length).toBe(1);
         expect(addItemToOrder!.lines[0].quantity).toBe(1);
@@ -151,6 +161,7 @@ describe('Channelaware orders', () => {
                 quantity: 1,
             },
         );
+        orderResultGuard.assertSuccess(addItemToOrder);
 
         expect(addItemToOrder!.lines.length).toBe(1);
         expect(addItemToOrder!.lines[0].quantity).toBe(1);

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

@@ -1,20 +1,22 @@
 /* tslint:disable:no-non-null-assertion */
 import { CustomOrderProcess, mergeConfig, OrderState } from '@vendure/core';
-import { createTestEnvironment } from '@vendure/testing';
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
 import path from 'path';
 
 import { initialData } from '../../../e2e-common/e2e-initial-data';
 import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-config';
 
 import { testSuccessfulPaymentMethod } from './fixtures/test-payment-methods';
-import { AdminTransition, GetOrder } from './graphql/generated-e2e-admin-types';
+import { AdminTransition, GetOrder, OrderFragment } from './graphql/generated-e2e-admin-types';
 import {
     AddItemToOrder,
     AddPaymentToOrder,
+    ErrorCode,
     GetNextOrderStates,
     SetCustomerForOrder,
     SetShippingAddress,
     SetShippingMethod,
+    TestOrderFragmentFragment,
     TransitionToState,
 } from './graphql/generated-e2e-shop-types';
 import { ADMIN_TRANSITION_TO_STATE, GET_ORDER } from './graphql/shared-definitions';
@@ -81,6 +83,10 @@ describe('Order process', () => {
         },
     };
 
+    const orderErrorGuard: ErrorResultGuard<
+        TestOrderFragmentFragment | OrderFragment
+    > = createErrorResultGuard<TestOrderFragmentFragment | OrderFragment>(input => !!input.total);
+
     const { server, adminClient, shopClient } = createTestEnvironment(
         mergeConfig(testConfig, {
             orderOptions: { process: [customOrderProcess as any, customOrderProcess2 as any] },
@@ -130,6 +136,7 @@ describe('Order process', () => {
             >(TRANSITION_TO_STATE, {
                 state: 'ValidatingCustomer',
             });
+            orderErrorGuard.assertSuccess(transitionOrderToState);
 
             expect(transitionStartSpy).toHaveBeenCalledTimes(1);
             expect(transitionEndSpy).not.toHaveBeenCalled();
@@ -155,17 +162,21 @@ describe('Order process', () => {
                 },
             );
 
-            try {
-                const { transitionOrderToState } = await shopClient.query<
-                    TransitionToState.Mutation,
-                    TransitionToState.Variables
-                >(TRANSITION_TO_STATE, {
-                    state: 'ValidatingCustomer',
-                });
-                fail('Should have thrown');
-            } catch (e) {
-                expect(e.message).toContain(VALIDATION_ERROR_MESSAGE);
-            }
+            const { transitionOrderToState } = await shopClient.query<
+                TransitionToState.Mutation,
+                TransitionToState.Variables
+            >(TRANSITION_TO_STATE, {
+                state: 'ValidatingCustomer',
+            });
+            orderErrorGuard.assertErrorResult(transitionOrderToState);
+
+            expect(transitionOrderToState!.message).toBe(
+                'Cannot transition Order from "AddingItems" to "ValidatingCustomer"',
+            );
+            expect(transitionOrderToState!.errorCode).toBe(ErrorCode.ORDER_STATE_TRANSITION_ERROR);
+            expect(transitionOrderToState!.transitionError).toBe(VALIDATION_ERROR_MESSAGE);
+            expect(transitionOrderToState!.fromState).toBe('AddingItems');
+            expect(transitionOrderToState!.toState).toBe('ValidatingCustomer');
 
             expect(transitionStartSpy).toHaveBeenCalledTimes(1);
             expect(transitionErrorSpy).toHaveBeenCalledTimes(1);
@@ -197,6 +208,7 @@ describe('Order process', () => {
             >(TRANSITION_TO_STATE, {
                 state: 'ValidatingCustomer',
             });
+            orderErrorGuard.assertSuccess(transitionOrderToState);
 
             expect(transitionEndSpy).toHaveBeenCalledTimes(1);
             expect(transitionEndSpy.mock.calls[0].slice(0, 2)).toEqual(['AddingItems', 'ValidatingCustomer']);
@@ -227,7 +239,7 @@ describe('Order process', () => {
     });
 
     describe('Admin API transition constraints', () => {
-        let order: NonNullable<TransitionToState.Mutation['transitionOrderToState']>;
+        let order: NonNullable<TestOrderFragmentFragment>;
 
         beforeAll(async () => {
             await shopClient.asAnonymousUser();
@@ -268,32 +280,35 @@ describe('Order process', () => {
                     state: 'ValidatingCustomer',
                 },
             );
-            const result = await shopClient.query<TransitionToState.Mutation, TransitionToState.Variables>(
-                TRANSITION_TO_STATE,
-                {
-                    state: 'ArrangingPayment',
-                },
-            );
-            order = result.transitionOrderToState!;
+            const { transitionOrderToState } = await shopClient.query<
+                TransitionToState.Mutation,
+                TransitionToState.Variables
+            >(TRANSITION_TO_STATE, {
+                state: 'ArrangingPayment',
+            });
+            orderErrorGuard.assertSuccess(transitionOrderToState);
+
+            order = transitionOrderToState!;
         });
 
         it('cannot manually transition to PaymentAuthorized', async () => {
             expect(order.state).toBe('ArrangingPayment');
 
-            try {
-                const { transitionOrderToState } = await adminClient.query<
-                    AdminTransition.Mutation,
-                    AdminTransition.Variables
-                >(ADMIN_TRANSITION_TO_STATE, {
-                    id: order.id,
-                    state: 'PaymentAuthorized',
-                });
-                fail('Should have thrown');
-            } catch (e) {
-                expect(e.message).toContain(
-                    'Cannot transition Order to the "PaymentAuthorized" state when the total is not covered by authorized Payments',
-                );
-            }
+            const { transitionOrderToState } = await adminClient.query<
+                AdminTransition.Mutation,
+                AdminTransition.Variables
+            >(ADMIN_TRANSITION_TO_STATE, {
+                id: order.id,
+                state: 'PaymentAuthorized',
+            });
+            orderErrorGuard.assertErrorResult(transitionOrderToState);
+
+            expect(transitionOrderToState!.message).toBe(
+                'Cannot transition Order from "ArrangingPayment" to "PaymentAuthorized"',
+            );
+            expect(transitionOrderToState!.transitionError).toBe(
+                'Cannot transition Order to the "PaymentAuthorized" state when the total is not covered by authorized Payments',
+            );
 
             const result = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: order.id,
@@ -302,20 +317,21 @@ describe('Order process', () => {
         });
 
         it('cannot manually transition to PaymentSettled', async () => {
-            try {
-                const { transitionOrderToState } = await adminClient.query<
-                    AdminTransition.Mutation,
-                    AdminTransition.Variables
-                >(ADMIN_TRANSITION_TO_STATE, {
-                    id: order.id,
-                    state: 'PaymentSettled',
-                });
-                fail('Should have thrown');
-            } catch (e) {
-                expect(e.message).toContain(
-                    'Cannot transition Order to the "PaymentSettled" state when the total is not covered by settled Payments',
-                );
-            }
+            const { transitionOrderToState } = await adminClient.query<
+                AdminTransition.Mutation,
+                AdminTransition.Variables
+            >(ADMIN_TRANSITION_TO_STATE, {
+                id: order.id,
+                state: 'PaymentSettled',
+            });
+            orderErrorGuard.assertErrorResult(transitionOrderToState);
+
+            expect(transitionOrderToState!.message).toBe(
+                'Cannot transition Order from "ArrangingPayment" to "PaymentSettled"',
+            );
+            expect(transitionOrderToState!.transitionError).toContain(
+                'Cannot transition Order to the "PaymentSettled" state when the total is not covered by settled Payments',
+            );
 
             const result = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: order.id,
@@ -333,23 +349,26 @@ describe('Order process', () => {
                     metadata: {},
                 },
             });
+            orderErrorGuard.assertSuccess(addPaymentToOrder);
 
             expect(addPaymentToOrder?.state).toBe('PaymentSettled');
 
-            try {
-                const { transitionOrderToState } = await adminClient.query<
-                    AdminTransition.Mutation,
-                    AdminTransition.Variables
-                >(ADMIN_TRANSITION_TO_STATE, {
-                    id: order.id,
-                    state: 'Cancelled',
-                });
-                fail('Should have thrown');
-            } catch (e) {
-                expect(e.message).toContain(
-                    'Cannot transition Order to the "Cancelled" state unless all OrderItems are cancelled',
-                );
-            }
+            const { transitionOrderToState } = await adminClient.query<
+                AdminTransition.Mutation,
+                AdminTransition.Variables
+            >(ADMIN_TRANSITION_TO_STATE, {
+                id: order.id,
+                state: 'Cancelled',
+            });
+            orderErrorGuard.assertErrorResult(transitionOrderToState);
+
+            expect(transitionOrderToState!.message).toBe(
+                'Cannot transition Order from "PaymentSettled" to "Cancelled"',
+            );
+            expect(transitionOrderToState!.transitionError).toContain(
+                'Cannot transition Order to the "Cancelled" state unless all OrderItems are cancelled',
+            );
+
             const result = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: order.id,
             });
@@ -357,20 +376,22 @@ describe('Order process', () => {
         });
 
         it('cannot manually transition to PartiallyDelivered', async () => {
-            try {
-                const { transitionOrderToState } = await adminClient.query<
-                    AdminTransition.Mutation,
-                    AdminTransition.Variables
-                >(ADMIN_TRANSITION_TO_STATE, {
-                    id: order.id,
-                    state: 'PartiallyDelivered',
-                });
-                fail('Should have thrown');
-            } catch (e) {
-                expect(e.message).toContain(
-                    'Cannot transition Order to the "PartiallyDelivered" state unless some OrderItems are delivered',
-                );
-            }
+            const { transitionOrderToState } = await adminClient.query<
+                AdminTransition.Mutation,
+                AdminTransition.Variables
+            >(ADMIN_TRANSITION_TO_STATE, {
+                id: order.id,
+                state: 'PartiallyDelivered',
+            });
+            orderErrorGuard.assertErrorResult(transitionOrderToState);
+
+            expect(transitionOrderToState!.message).toBe(
+                'Cannot transition Order from "PaymentSettled" to "PartiallyDelivered"',
+            );
+            expect(transitionOrderToState!.transitionError).toContain(
+                'Cannot transition Order to the "PartiallyDelivered" state unless some OrderItems are delivered',
+            );
+
             const result = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: order.id,
             });
@@ -378,20 +399,22 @@ describe('Order process', () => {
         });
 
         it('cannot manually transition to PartiallyDelivered', async () => {
-            try {
-                const { transitionOrderToState } = await adminClient.query<
-                    AdminTransition.Mutation,
-                    AdminTransition.Variables
-                >(ADMIN_TRANSITION_TO_STATE, {
-                    id: order.id,
-                    state: 'Delivered',
-                });
-                fail('Should have thrown');
-            } catch (e) {
-                expect(e.message).toContain(
-                    'Cannot transition Order to the "Delivered" state unless all OrderItems are delivered',
-                );
-            }
+            const { transitionOrderToState } = await adminClient.query<
+                AdminTransition.Mutation,
+                AdminTransition.Variables
+            >(ADMIN_TRANSITION_TO_STATE, {
+                id: order.id,
+                state: 'Delivered',
+            });
+            orderErrorGuard.assertErrorResult(transitionOrderToState);
+
+            expect(transitionOrderToState!.message).toBe(
+                'Cannot transition Order from "PaymentSettled" to "Delivered"',
+            );
+            expect(transitionOrderToState!.transitionError).toContain(
+                'Cannot transition Order to the "Delivered" state unless all OrderItems are delivered',
+            );
+
             const result = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: order.id,
             });

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

@@ -10,7 +10,7 @@ import {
     orderPercentageDiscount,
     productsPercentageDiscount,
 } from '@vendure/core';
-import { createTestEnvironment } from '@vendure/testing';
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
 import gql from 'graphql-tag';
 import path from 'path';
 
@@ -25,6 +25,7 @@ import {
     GetFacetList,
     GetPromoProducts,
     HistoryEntryType,
+    PromotionFragment,
     RemoveCustomersFromGroup,
 } from './graphql/generated-e2e-admin-types';
 import {
@@ -32,11 +33,15 @@ import {
     AdjustItemQuantity,
     AdjustmentType,
     ApplyCouponCode,
+    ErrorCode,
     GetActiveOrder,
     GetOrderPromotionsByCode,
     RemoveCouponCode,
     SetCustomerForOrder,
     TestOrderFragment,
+    TestOrderFragmentFragment,
+    TestOrderWithPaymentsFragment,
+    UpdatedOrderFragment,
 } from './graphql/generated-e2e-shop-types';
 import {
     CREATE_CUSTOMER_GROUP,
@@ -76,6 +81,11 @@ describe('Promotions applied to Orders', () => {
         ],
     });
 
+    type OrderSuccessResult = UpdatedOrderFragment | TestOrderFragmentFragment;
+    const orderResultGuard: ErrorResultGuard<OrderSuccessResult> = createErrorResultGuard<OrderSuccessResult>(
+        input => !!input.lines,
+    );
+
     let products: GetPromoProducts.Items[];
 
     beforeAll(async () => {
@@ -97,8 +107,8 @@ describe('Promotions applied to Orders', () => {
     describe('coupon codes', () => {
         const TEST_COUPON_CODE = 'TESTCOUPON';
         const EXPIRED_COUPON_CODE = 'EXPIRED';
-        let promoFreeWithCoupon: CreatePromotion.CreatePromotion;
-        let promoFreeWithExpiredCoupon: CreatePromotion.CreatePromotion;
+        let promoFreeWithCoupon: PromotionFragment;
+        let promoFreeWithExpiredCoupon: PromotionFragment;
 
         beforeAll(async () => {
             promoFreeWithCoupon = await createPromotion({
@@ -119,10 +129,7 @@ describe('Promotions applied to Orders', () => {
 
             await shopClient.asAnonymousUser();
             const item60 = getVariantBySlug('item-60');
-            const { addItemToOrder } = await shopClient.query<
-                AddItemToOrder.Mutation,
-                AddItemToOrder.Variables
-            >(ADD_ITEM_TO_ORDER, {
+            await shopClient.query<AddItemToOrder.Mutation, AddItemToOrder.Variables>(ADD_ITEM_TO_ORDER, {
                 productVariantId: item60.id,
                 quantity: 1,
             });
@@ -133,29 +140,29 @@ describe('Promotions applied to Orders', () => {
             await deletePromotion(promoFreeWithExpiredCoupon.id);
         });
 
-        it(
-            'applyCouponCode throws with nonexistant code',
-            assertThrowsWithMessage(async () => {
-                await shopClient.query<ApplyCouponCode.Mutation, ApplyCouponCode.Variables>(
-                    APPLY_COUPON_CODE,
-                    {
-                        couponCode: 'bad code',
-                    },
-                );
-            }, 'Coupon code "bad code" is not valid'),
-        );
+        it('applyCouponCode returns error result when code is nonexistant', async () => {
+            const { applyCouponCode } = await shopClient.query<
+                ApplyCouponCode.Mutation,
+                ApplyCouponCode.Variables
+            >(APPLY_COUPON_CODE, {
+                couponCode: 'bad code',
+            });
+            orderResultGuard.assertErrorResult(applyCouponCode);
+            expect(applyCouponCode.message).toBe('Coupon code "bad code" is not valid');
+            expect(applyCouponCode.errorCode).toBe(ErrorCode.COUPON_CODE_INVALID_ERROR);
+        });
 
-        it(
-            'applyCouponCode throws with expired code',
-            assertThrowsWithMessage(async () => {
-                await shopClient.query<ApplyCouponCode.Mutation, ApplyCouponCode.Variables>(
-                    APPLY_COUPON_CODE,
-                    {
-                        couponCode: EXPIRED_COUPON_CODE,
-                    },
-                );
-            }, `Coupon code "${EXPIRED_COUPON_CODE}" has expired`),
-        );
+        it('applyCouponCode returns error when code is expired', async () => {
+            const { applyCouponCode } = await shopClient.query<
+                ApplyCouponCode.Mutation,
+                ApplyCouponCode.Variables
+            >(APPLY_COUPON_CODE, {
+                couponCode: EXPIRED_COUPON_CODE,
+            });
+            orderResultGuard.assertErrorResult(applyCouponCode);
+            expect(applyCouponCode.message).toBe(`Coupon code "${EXPIRED_COUPON_CODE}" has expired`);
+            expect(applyCouponCode.errorCode).toBe(ErrorCode.COUPON_CODE_EXPIRED_ERROR);
+        });
 
         it('applies a valid coupon code', async () => {
             const { applyCouponCode } = await shopClient.query<
@@ -164,7 +171,7 @@ describe('Promotions applied to Orders', () => {
             >(APPLY_COUPON_CODE, {
                 couponCode: TEST_COUPON_CODE,
             });
-
+            orderResultGuard.assertSuccess(applyCouponCode);
             expect(applyCouponCode!.couponCodes).toEqual([TEST_COUPON_CODE]);
             expect(applyCouponCode!.adjustments.length).toBe(1);
             expect(applyCouponCode!.adjustments[0].description).toBe('Free with test coupon');
@@ -192,7 +199,7 @@ describe('Promotions applied to Orders', () => {
             >(APPLY_COUPON_CODE, {
                 couponCode: TEST_COUPON_CODE,
             });
-
+            orderResultGuard.assertSuccess(applyCouponCode);
             expect(applyCouponCode!.couponCodes).toEqual([TEST_COUPON_CODE]);
         });
 
@@ -274,6 +281,7 @@ describe('Promotions applied to Orders', () => {
                 productVariantId: item60.id,
                 quantity: 1,
             });
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.total).toBe(6000);
             expect(addItemToOrder!.adjustments.length).toBe(0);
 
@@ -284,6 +292,7 @@ describe('Promotions applied to Orders', () => {
                 orderLineId: addItemToOrder!.lines[0].id,
                 quantity: 2,
             });
+            orderResultGuard.assertSuccess(adjustOrderLine);
             expect(adjustOrderLine!.total).toBe(0);
             expect(adjustOrderLine!.adjustments[0].description).toBe('Free if order total greater than 100');
             expect(adjustOrderLine!.adjustments[0].amount).toBe(-12000);
@@ -318,6 +327,7 @@ describe('Promotions applied to Orders', () => {
                 productVariantId: itemSale1.id,
                 quantity: 1,
             });
+            orderResultGuard.assertSuccess(res1);
             expect(res1!.total).toBe(120);
             expect(res1!.adjustments.length).toBe(0);
 
@@ -328,6 +338,7 @@ describe('Promotions applied to Orders', () => {
                 productVariantId: itemSale12.id,
                 quantity: 1,
             });
+            orderResultGuard.assertSuccess(res2);
             expect(res2!.total).toBe(0);
             expect(res2!.adjustments.length).toBe(1);
             expect(res2!.total).toBe(0);
@@ -367,6 +378,7 @@ describe('Promotions applied to Orders', () => {
                 productVariantId: item12.id,
                 quantity: 1,
             });
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.total).toBe(7200);
             expect(addItemToOrder!.adjustments.length).toBe(0);
 
@@ -377,6 +389,7 @@ describe('Promotions applied to Orders', () => {
                 orderLineId: addItemToOrder!.lines[0].id,
                 quantity: 2,
             });
+            orderResultGuard.assertSuccess(adjustOrderLine);
             expect(adjustOrderLine!.total).toBe(0);
             expect(adjustOrderLine!.adjustments[0].description).toBe(
                 'Free if buying 3 or more offer products',
@@ -415,6 +428,7 @@ describe('Promotions applied to Orders', () => {
                 productVariantId: getVariantBySlug('item-60').id,
                 quantity: 1,
             });
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.total).toBe(0);
             expect(addItemToOrder!.adjustments.length).toBe(1);
             expect(addItemToOrder!.adjustments[0].description).toBe('Free for group members');
@@ -435,6 +449,7 @@ describe('Promotions applied to Orders', () => {
                 orderLineId: addItemToOrder!.lines[0].id,
                 quantity: 2,
             });
+            orderResultGuard.assertSuccess(adjustOrderLine);
             expect(adjustOrderLine!.total).toBe(12000);
             expect(adjustOrderLine!.adjustments.length).toBe(0);
 
@@ -469,6 +484,7 @@ describe('Promotions applied to Orders', () => {
                 productVariantId: item60.id,
                 quantity: 1,
             });
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.total).toBe(6000);
             expect(addItemToOrder!.adjustments.length).toBe(0);
 
@@ -478,7 +494,7 @@ describe('Promotions applied to Orders', () => {
             >(APPLY_COUPON_CODE, {
                 couponCode,
             });
-
+            orderResultGuard.assertSuccess(applyCouponCode);
             expect(applyCouponCode!.adjustments.length).toBe(1);
             expect(applyCouponCode!.adjustments[0].description).toBe('50% discount on order');
             expect(applyCouponCode!.total).toBe(3000);
@@ -524,6 +540,7 @@ describe('Promotions applied to Orders', () => {
             function getItemSale1Line(lines: TestOrderFragment.Lines[]): TestOrderFragment.Lines {
                 return lines.find(l => l.productVariant.id === getVariantBySlug('item-sale-1').id)!;
             }
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.adjustments.length).toBe(0);
             expect(getItemSale1Line(addItemToOrder!.lines).adjustments.length).toBe(2); // 2x tax
             expect(addItemToOrder!.total).toBe(2640);
@@ -534,6 +551,7 @@ describe('Promotions applied to Orders', () => {
             >(APPLY_COUPON_CODE, {
                 couponCode,
             });
+            orderResultGuard.assertSuccess(applyCouponCode);
 
             expect(applyCouponCode!.total).toBe(1920);
             expect(getItemSale1Line(applyCouponCode!.lines).adjustments.length).toBe(4); // 2x tax, 2x promotion
@@ -580,6 +598,7 @@ describe('Promotions applied to Orders', () => {
                 productVariantId: item60.id,
                 quantity: 1,
             });
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.adjustments.length).toBe(0);
             expect(addItemToOrder!.lines[0].adjustments.length).toBe(1); // 1x tax
             expect(addItemToOrder!.total).toBe(6000);
@@ -590,6 +609,7 @@ describe('Promotions applied to Orders', () => {
             >(APPLY_COUPON_CODE, {
                 couponCode,
             });
+            orderResultGuard.assertSuccess(applyCouponCode);
 
             expect(applyCouponCode!.total).toBe(3000);
             expect(applyCouponCode!.lines[0].adjustments.length).toBe(2); // 1x tax, 1x promotion
@@ -650,6 +670,7 @@ describe('Promotions applied to Orders', () => {
             >(APPLY_COUPON_CODE, {
                 couponCode: 'CODE1',
             });
+            orderResultGuard.assertSuccess(apply1);
 
             expect(apply1?.lines[0].adjustments.length).toBe(2);
             expect(
@@ -664,6 +685,7 @@ describe('Promotions applied to Orders', () => {
             >(APPLY_COUPON_CODE, {
                 couponCode: 'CODE2',
             });
+            orderResultGuard.assertSuccess(apply2);
 
             expect(apply2?.lines[0].adjustments.length).toBe(2);
             expect(
@@ -676,7 +698,10 @@ describe('Promotions applied to Orders', () => {
 
     describe('per-customer usage limit', () => {
         const TEST_COUPON_CODE = 'TESTCOUPON';
-        let promoWithUsageLimit: CreatePromotion.CreatePromotion;
+        const orderGuard: ErrorResultGuard<TestOrderWithPaymentsFragment> = createErrorResultGuard<
+            TestOrderWithPaymentsFragment
+        >(input => !!input.lines);
+        let promoWithUsageLimit: PromotionFragment;
 
         beforeAll(async () => {
             promoWithUsageLimit = await createPromotion({
@@ -731,12 +756,15 @@ describe('Promotions applied to Orders', () => {
                     ApplyCouponCode.Mutation,
                     ApplyCouponCode.Variables
                 >(APPLY_COUPON_CODE, { couponCode: TEST_COUPON_CODE });
+                orderResultGuard.assertSuccess(applyCouponCode);
 
                 expect(applyCouponCode!.total).toBe(0);
                 expect(applyCouponCode!.couponCodes).toEqual([TEST_COUPON_CODE]);
 
                 await proceedToArrangingPayment(shopClient);
                 const order = await addPaymentToOrder(shopClient, testSuccessfulPaymentMethod);
+                orderGuard.assertSuccess(order);
+
                 expect(order.state).toBe('PaymentSettled');
                 expect(order.active).toBe(false);
                 orderCode = order.code;
@@ -754,22 +782,20 @@ describe('Promotions applied to Orders', () => {
                 ]);
             });
 
-            it('throws when usage exceeds limit', async () => {
+            it('returns error result when usage exceeds limit', async () => {
                 await shopClient.asAnonymousUser();
                 await createNewActiveOrder();
                 await addGuestCustomerToOrder();
 
-                try {
-                    await shopClient.query<ApplyCouponCode.Mutation, ApplyCouponCode.Variables>(
-                        APPLY_COUPON_CODE,
-                        { couponCode: TEST_COUPON_CODE },
-                    );
-                    fail('should have thrown');
-                } catch (err) {
-                    expect(err.message).toEqual(
-                        expect.stringContaining('Coupon code cannot be used more than once per customer'),
-                    );
-                }
+                const { applyCouponCode } = await shopClient.query<
+                    ApplyCouponCode.Mutation,
+                    ApplyCouponCode.Variables
+                >(APPLY_COUPON_CODE, { couponCode: TEST_COUPON_CODE });
+                orderResultGuard.assertErrorResult(applyCouponCode);
+
+                expect(applyCouponCode.message).toEqual(
+                    'Coupon code cannot be used more than once per customer',
+                );
             });
 
             it('removes couponCode from order when adding customer after code applied', async () => {
@@ -780,6 +806,7 @@ describe('Promotions applied to Orders', () => {
                     ApplyCouponCode.Mutation,
                     ApplyCouponCode.Variables
                 >(APPLY_COUPON_CODE, { couponCode: TEST_COUPON_CODE });
+                orderResultGuard.assertSuccess(applyCouponCode);
 
                 expect(applyCouponCode!.total).toBe(0);
                 expect(applyCouponCode!.couponCodes).toEqual([TEST_COUPON_CODE]);
@@ -804,30 +831,31 @@ describe('Promotions applied to Orders', () => {
                     ApplyCouponCode.Mutation,
                     ApplyCouponCode.Variables
                 >(APPLY_COUPON_CODE, { couponCode: TEST_COUPON_CODE });
+                orderResultGuard.assertSuccess(applyCouponCode);
 
                 expect(applyCouponCode!.total).toBe(0);
                 expect(applyCouponCode!.couponCodes).toEqual([TEST_COUPON_CODE]);
 
                 await proceedToArrangingPayment(shopClient);
                 const order = await addPaymentToOrder(shopClient, testSuccessfulPaymentMethod);
+                orderGuard.assertSuccess(order);
+
                 expect(order.state).toBe('PaymentSettled');
                 expect(order.active).toBe(false);
             });
 
-            it('throws when usage exceeds limit', async () => {
+            it('returns error result when usage exceeds limit', async () => {
                 await logInAsRegisteredCustomer();
                 await createNewActiveOrder();
-                try {
-                    await shopClient.query<ApplyCouponCode.Mutation, ApplyCouponCode.Variables>(
-                        APPLY_COUPON_CODE,
-                        { couponCode: TEST_COUPON_CODE },
-                    );
-                    fail('should have thrown');
-                } catch (err) {
-                    expect(err.message).toEqual(
-                        expect.stringContaining('Coupon code cannot be used more than once per customer'),
-                    );
-                }
+                const { applyCouponCode } = await shopClient.query<
+                    ApplyCouponCode.Mutation,
+                    ApplyCouponCode.Variables
+                >(APPLY_COUPON_CODE, { couponCode: TEST_COUPON_CODE });
+                orderResultGuard.assertErrorResult(applyCouponCode);
+                expect(applyCouponCode.message).toEqual(
+                    'Coupon code cannot be used more than once per customer',
+                );
+                expect(applyCouponCode.errorCode).toBe(ErrorCode.COUPON_CODE_LIMIT_ERROR);
             });
 
             it('removes couponCode from order when logging in after code applied', async () => {
@@ -837,6 +865,7 @@ describe('Promotions applied to Orders', () => {
                     ApplyCouponCode.Mutation,
                     ApplyCouponCode.Variables
                 >(APPLY_COUPON_CODE, { couponCode: TEST_COUPON_CODE });
+                orderResultGuard.assertSuccess(applyCouponCode);
 
                 expect(applyCouponCode!.couponCodes).toEqual([TEST_COUPON_CODE]);
                 expect(applyCouponCode!.total).toBe(0);
@@ -879,14 +908,14 @@ describe('Promotions applied to Orders', () => {
         await deletePromotion(deletedPromotion.id);
     }
 
-    async function createPromotion(input: CreatePromotionInput): Promise<CreatePromotion.CreatePromotion> {
+    async function createPromotion(input: CreatePromotionInput): Promise<PromotionFragment> {
         const result = await adminClient.query<CreatePromotion.Mutation, CreatePromotion.Variables>(
             CREATE_PROMOTION,
             {
                 input,
             },
         );
-        return result.createPromotion;
+        return result.createPromotion as PromotionFragment;
     }
 
     function getVariantBySlug(

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

@@ -1,6 +1,11 @@
 /* tslint:disable:no-non-null-assertion */
 import { pick } from '@vendure/common/lib/pick';
-import { createTestEnvironment, SimpleGraphQLClient } from '@vendure/testing';
+import {
+    createErrorResultGuard,
+    createTestEnvironment,
+    ErrorResultGuard,
+    SimpleGraphQLClient,
+} from '@vendure/testing';
 import gql from 'graphql-tag';
 import path from 'path';
 
@@ -13,11 +18,15 @@ import {
     singleStageRefundablePaymentMethod,
     twoStagePaymentMethod,
 } from './fixtures/test-payment-methods';
+import { FULFILLMENT_FRAGMENT } from './graphql/fragments';
 import {
     AddNoteToOrder,
+    CanceledOrderFragment,
     CancelOrder,
     CreateFulfillment,
     DeleteOrderNote,
+    ErrorCode,
+    FulfillmentFragment,
     GetCustomerList,
     GetOrder,
     GetOrderFulfillmentItems,
@@ -28,6 +37,8 @@ import {
     GetProductWithVariants,
     GetStockMovement,
     HistoryEntryType,
+    PaymentFragment,
+    RefundFragment,
     RefundOrder,
     SettlePayment,
     SettleRefund,
@@ -37,7 +48,13 @@ import {
     UpdateOrderNote,
     UpdateProductVariants,
 } from './graphql/generated-e2e-admin-types';
-import { AddItemToOrder, DeletionResult, GetActiveOrder } from './graphql/generated-e2e-shop-types';
+import {
+    AddItemToOrder,
+    DeletionResult,
+    GetActiveOrder,
+    TestOrderFragmentFragment,
+    UpdatedOrder,
+} from './graphql/generated-e2e-shop-types';
 import {
     CREATE_FULFILLMENT,
     GET_CUSTOMER_LIST,
@@ -67,6 +84,19 @@ describe('Orders resolver', () => {
     let customers: GetCustomerList.Items[];
     const password = 'test';
 
+    const orderGuard: ErrorResultGuard<
+        TestOrderFragmentFragment | CanceledOrderFragment
+    > = createErrorResultGuard<TestOrderFragmentFragment | CanceledOrderFragment>(input => !!input.lines);
+    const paymentGuard: ErrorResultGuard<PaymentFragment> = createErrorResultGuard<PaymentFragment>(
+        input => !!input.state,
+    );
+    const fulfillmentGuard: ErrorResultGuard<FulfillmentFragment> = createErrorResultGuard<
+        FulfillmentFragment
+    >(input => !!input.method);
+    const refundGuard: ErrorResultGuard<RefundFragment> = createErrorResultGuard<RefundFragment>(
+        input => !!input.items,
+    );
+
     beforeAll(async () => {
         await server.init({
             initialData,
@@ -133,6 +163,7 @@ describe('Orders resolver', () => {
             await shopClient.asUserWithCredentials(customers[0].emailAddress, password);
             await proceedToArrangingPayment(shopClient);
             const order = await addPaymentToOrder(shopClient, failsToSettlePaymentMethod);
+            orderGuard.assertSuccess(order);
 
             expect(order.state).toBe('PaymentAuthorized');
 
@@ -143,9 +174,11 @@ describe('Orders resolver', () => {
             >(SETTLE_PAYMENT, {
                 id: payment.id,
             });
+            paymentGuard.assertErrorResult(settlePayment);
 
-            expect(settlePayment!.id).toBe(payment.id);
-            expect(settlePayment!.state).toBe('Authorized');
+            expect(settlePayment.message).toBe('Settling the payment failed');
+            expect(settlePayment.errorCode).toBe(ErrorCode.SETTLE_PAYMENT_ERROR);
+            expect((settlePayment as any).paymentErrorMessage).toBe('Something went horribly wrong');
 
             const result = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: order.id,
@@ -159,6 +192,7 @@ describe('Orders resolver', () => {
             await shopClient.asUserWithCredentials(customers[1].emailAddress, password);
             await proceedToArrangingPayment(shopClient);
             const order = await addPaymentToOrder(shopClient, twoStagePaymentMethod);
+            orderGuard.assertSuccess(order);
 
             expect(order.state).toBe('PaymentAuthorized');
             expect(onTransitionSpy).toHaveBeenCalledTimes(1);
@@ -172,6 +206,7 @@ describe('Orders resolver', () => {
             >(SETTLE_PAYMENT, {
                 id: payment.id,
             });
+            paymentGuard.assertSuccess(settlePayment);
 
             expect(settlePayment!.id).toBe(payment.id);
             expect(settlePayment!.state).toBe('Settled');
@@ -240,63 +275,45 @@ describe('Orders resolver', () => {
     });
 
     describe('fulfillment', () => {
-        it(
-            'throws if Order is not in "PaymentSettled" state',
-            assertThrowsWithMessage(async () => {
-                const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
-                    id: 'T_1',
-                });
-                expect(order!.state).toBe('PaymentAuthorized');
+        it('return error result if lines is empty', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: 'T_2',
+            });
+            expect(order!.state).toBe('PaymentSettled');
+            const { addFulfillmentToOrder } = await adminClient.query<
+                CreateFulfillment.Mutation,
+                CreateFulfillment.Variables
+            >(CREATE_FULFILLMENT, {
+                input: {
+                    lines: [],
+                    method: 'Test',
+                },
+            });
+            fulfillmentGuard.assertErrorResult(addFulfillmentToOrder);
 
-                await adminClient.query<CreateFulfillment.Mutation, CreateFulfillment.Variables>(
-                    CREATE_FULFILLMENT,
-                    {
-                        input: {
-                            lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: l.quantity })),
-                            method: 'Test',
-                        },
-                    },
-                );
-            }, 'One or more OrderItems belong to an Order which is in an invalid state'),
-        );
+            expect(addFulfillmentToOrder.message).toBe('At least one OrderLine must be specified');
+            expect(addFulfillmentToOrder.errorCode).toBe(ErrorCode.EMPTY_ORDER_LINE_SELECTION_ERROR);
+        });
 
-        it(
-            'throws if lines is empty',
-            assertThrowsWithMessage(async () => {
-                const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
-                    id: 'T_2',
-                });
-                expect(order!.state).toBe('PaymentSettled');
-                await adminClient.query<CreateFulfillment.Mutation, CreateFulfillment.Variables>(
-                    CREATE_FULFILLMENT,
-                    {
-                        input: {
-                            lines: [],
-                            method: 'Test',
-                        },
-                    },
-                );
-            }, 'Nothing to fulfill'),
-        );
+        it('returns error result if all quantities are zero', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: 'T_2',
+            });
+            expect(order!.state).toBe('PaymentSettled');
+            const { addFulfillmentToOrder } = await adminClient.query<
+                CreateFulfillment.Mutation,
+                CreateFulfillment.Variables
+            >(CREATE_FULFILLMENT, {
+                input: {
+                    lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: 0 })),
+                    method: 'Test',
+                },
+            });
+            fulfillmentGuard.assertErrorResult(addFulfillmentToOrder);
 
-        it(
-            'throws if all quantities are zero',
-            assertThrowsWithMessage(async () => {
-                const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
-                    id: 'T_2',
-                });
-                expect(order!.state).toBe('PaymentSettled');
-                await adminClient.query<CreateFulfillment.Mutation, CreateFulfillment.Variables>(
-                    CREATE_FULFILLMENT,
-                    {
-                        input: {
-                            lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: 0 })),
-                            method: 'Test',
-                        },
-                    },
-                );
-            }, 'Nothing to fulfill'),
-        );
+            expect(addFulfillmentToOrder.message).toBe('At least one OrderLine must be specified');
+            expect(addFulfillmentToOrder.errorCode).toBe(ErrorCode.EMPTY_ORDER_LINE_SELECTION_ERROR);
+        });
 
         it('creates the first fulfillment', async () => {
             const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
@@ -305,7 +322,7 @@ describe('Orders resolver', () => {
             expect(order!.state).toBe('PaymentSettled');
             const lines = order!.lines;
 
-            const { fulfillOrder } = await adminClient.query<
+            const { addFulfillmentToOrder } = await adminClient.query<
                 CreateFulfillment.Mutation,
                 CreateFulfillment.Variables
             >(CREATE_FULFILLMENT, {
@@ -315,21 +332,22 @@ describe('Orders resolver', () => {
                     trackingCode: '111',
                 },
             });
+            fulfillmentGuard.assertSuccess(addFulfillmentToOrder);
 
-            expect(fulfillOrder!.id).toBe('T_1');
-            expect(fulfillOrder!.method).toBe('Test1');
-            expect(fulfillOrder!.trackingCode).toBe('111');
-            expect(fulfillOrder!.state).toBe('Pending');
-            expect(fulfillOrder!.orderItems).toEqual([{ id: lines[0].items[0].id }]);
+            expect(addFulfillmentToOrder.id).toBe('T_1');
+            expect(addFulfillmentToOrder.method).toBe('Test1');
+            expect(addFulfillmentToOrder.trackingCode).toBe('111');
+            expect(addFulfillmentToOrder.state).toBe('Pending');
+            expect(addFulfillmentToOrder.orderItems).toEqual([{ id: lines[0].items[0].id }]);
 
             const result = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: 'T_2',
             });
 
-            expect(result.order!.lines[0].items[0].fulfillment!.id).toBe(fulfillOrder!.id);
+            expect(result.order!.lines[0].items[0].fulfillment!.id).toBe(addFulfillmentToOrder!.id);
             expect(
                 result.order!.lines[1].items.filter(
-                    i => i.fulfillment && i.fulfillment.id === fulfillOrder.id,
+                    i => i.fulfillment && i.fulfillment.id === addFulfillmentToOrder.id,
                 ).length,
             ).toBe(0);
             expect(result.order!.lines[1].items.filter(i => i.fulfillment == null).length).toBe(3);
@@ -346,7 +364,7 @@ describe('Orders resolver', () => {
                     return items.length > 0 ? true : false;
                 }) || [];
 
-            const { fulfillOrder } = await adminClient.query<
+            const { addFulfillmentToOrder } = await adminClient.query<
                 CreateFulfillment.Mutation,
                 CreateFulfillment.Variables
             >(CREATE_FULFILLMENT, {
@@ -359,93 +377,109 @@ describe('Orders resolver', () => {
                     trackingCode: '222',
                 },
             });
+            fulfillmentGuard.assertSuccess(addFulfillmentToOrder);
 
-            expect(fulfillOrder!.id).toBe('T_2');
-            expect(fulfillOrder!.method).toBe('Test2');
-            expect(fulfillOrder!.trackingCode).toBe('222');
-            expect(fulfillOrder!.state).toBe('Pending');
+            expect(addFulfillmentToOrder.id).toBe('T_2');
+            expect(addFulfillmentToOrder.method).toBe('Test2');
+            expect(addFulfillmentToOrder.trackingCode).toBe('222');
+            expect(addFulfillmentToOrder.state).toBe('Pending');
         });
 
-        it(
-            'throws if an OrderItem already part of a Fulfillment',
-            assertThrowsWithMessage(async () => {
-                const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
-                    id: 'T_2',
-                });
-                await adminClient.query<CreateFulfillment.Mutation, CreateFulfillment.Variables>(
-                    CREATE_FULFILLMENT,
-                    {
-                        input: {
-                            method: 'Test',
-                            lines: [
-                                {
-                                    orderLineId: order!.lines[0].id,
-                                    quantity: 1,
-                                },
-                            ],
+        it('returns error result if an OrderItem already part of a Fulfillment', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: 'T_2',
+            });
+            const { addFulfillmentToOrder } = await adminClient.query<
+                CreateFulfillment.Mutation,
+                CreateFulfillment.Variables
+            >(CREATE_FULFILLMENT, {
+                input: {
+                    method: 'Test',
+                    lines: [
+                        {
+                            orderLineId: order!.lines[0].id,
+                            quantity: 1,
                         },
-                    },
-                );
-            }, 'One or more OrderItems have already been fulfilled'),
-        );
+                    ],
+                },
+            });
+            fulfillmentGuard.assertErrorResult(addFulfillmentToOrder);
+
+            expect(addFulfillmentToOrder.message).toBe(
+                'One or more OrderItems are already part of a Fulfillment',
+            );
+            expect(addFulfillmentToOrder.errorCode).toBe(ErrorCode.ITEMS_ALREADY_FULFILLED_ERROR);
+        });
+
         it('transits the first fulfillment from created to Shipped and automatically change the order state to PartiallyShipped', async () => {
-            const fulfillment = await adminClient.query<
+            const { transitionFulfillmentToState } = await adminClient.query<
                 TransitFulfillment.Mutation,
                 TransitFulfillment.Variables
             >(TRANSIT_FULFILLMENT, {
                 id: 'T_1',
                 state: 'Shipped',
             });
-            expect(fulfillment.transitionFulfillmentToState?.id).toBe('T_1');
-            expect(fulfillment.transitionFulfillmentToState?.state).toBe('Shipped');
+            fulfillmentGuard.assertSuccess(transitionFulfillmentToState);
+
+            expect(transitionFulfillmentToState.id).toBe('T_1');
+            expect(transitionFulfillmentToState.state).toBe('Shipped');
 
             const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: 'T_2',
             });
             expect(order?.state).toBe('PartiallyShipped');
         });
+
         it('transits the second fulfillment from created to Shipped and automatically change the order state to Shipped', async () => {
-            const fulfillment = await adminClient.query<
+            const { transitionFulfillmentToState } = await adminClient.query<
                 TransitFulfillment.Mutation,
                 TransitFulfillment.Variables
             >(TRANSIT_FULFILLMENT, {
                 id: 'T_2',
                 state: 'Shipped',
             });
-            expect(fulfillment.transitionFulfillmentToState?.id).toBe('T_2');
-            expect(fulfillment.transitionFulfillmentToState?.state).toBe('Shipped');
+            fulfillmentGuard.assertSuccess(transitionFulfillmentToState);
+
+            expect(transitionFulfillmentToState.id).toBe('T_2');
+            expect(transitionFulfillmentToState.state).toBe('Shipped');
 
             const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: 'T_2',
             });
             expect(order?.state).toBe('Shipped');
         });
+
         it('transits the first fulfillment from Shipped to Delivered and change the order state to PartiallyDelivered', async () => {
-            const fulfillment = await adminClient.query<
+            const { transitionFulfillmentToState } = await adminClient.query<
                 TransitFulfillment.Mutation,
                 TransitFulfillment.Variables
             >(TRANSIT_FULFILLMENT, {
                 id: 'T_1',
                 state: 'Delivered',
             });
-            expect(fulfillment.transitionFulfillmentToState?.id).toBe('T_1');
-            expect(fulfillment.transitionFulfillmentToState?.state).toBe('Delivered');
+            fulfillmentGuard.assertSuccess(transitionFulfillmentToState);
+
+            expect(transitionFulfillmentToState.id).toBe('T_1');
+            expect(transitionFulfillmentToState.state).toBe('Delivered');
 
             const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: 'T_2',
             });
             expect(order?.state).toBe('PartiallyDelivered');
         });
+
         it('transits the second fulfillment from Shipped to Delivered and change the order state to Delivered', async () => {
-            const fulfillment = await adminClient.query<
+            const { transitionFulfillmentToState } = await adminClient.query<
                 TransitFulfillment.Mutation,
                 TransitFulfillment.Variables
             >(TRANSIT_FULFILLMENT, {
                 id: 'T_2',
                 state: 'Delivered',
             });
-            expect(fulfillment.transitionFulfillmentToState?.id).toBe('T_2');
-            expect(fulfillment.transitionFulfillmentToState?.state).toBe('Delivered');
+            fulfillmentGuard.assertSuccess(transitionFulfillmentToState);
+
+            expect(transitionFulfillmentToState.id).toBe('T_2');
+            expect(transitionFulfillmentToState.state).toBe('Delivered');
 
             const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: 'T_2',
@@ -642,6 +676,8 @@ describe('Orders resolver', () => {
             );
             await proceedToArrangingPayment(shopClient);
             const order = await addPaymentToOrder(shopClient, failsToSettlePaymentMethod);
+            orderGuard.assertSuccess(order);
+
             expect(order.state).toBe('PaymentAuthorized');
 
             const result1 = await adminClient.query<GetStockMovement.Query, GetStockMovement.Variables>(
@@ -665,6 +701,8 @@ describe('Orders resolver', () => {
                     },
                 },
             );
+            orderGuard.assertSuccess(cancelOrder);
+
             expect(
                 cancelOrder.lines.map(l =>
                     l.items.map(pick(['id', 'cancelled'])).sort((a, b) => (a.id > b.id ? 1 : -1)),
@@ -729,68 +767,91 @@ describe('Orders resolver', () => {
             productVariantId = result.productVariantId;
         });
 
-        it(
-            'cannot cancel from AddingItems state',
-            assertThrowsWithMessage(async () => {
-                const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
-                    id: orderId,
-                });
-                expect(order!.state).toBe('AddingItems');
-                await adminClient.query<CancelOrder.Mutation, CancelOrder.Variables>(CANCEL_ORDER, {
+        it('cannot cancel from AddingItems state', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: orderId,
+            });
+            expect(order!.state).toBe('AddingItems');
+
+            const { cancelOrder } = await adminClient.query<CancelOrder.Mutation, CancelOrder.Variables>(
+                CANCEL_ORDER,
+                {
                     input: {
                         orderId,
                         lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: 1 })),
                     },
-                });
-            }, 'Cannot cancel OrderLines from an Order in the "AddingItems" state'),
-        );
+                },
+            );
+            orderGuard.assertErrorResult(cancelOrder);
 
-        it(
-            'cannot cancel from ArrangingPayment state',
-            assertThrowsWithMessage(async () => {
-                await proceedToArrangingPayment(shopClient);
-                const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
-                    id: orderId,
-                });
-                expect(order!.state).toBe('ArrangingPayment');
-                await adminClient.query<CancelOrder.Mutation, CancelOrder.Variables>(CANCEL_ORDER, {
+            expect(cancelOrder.message).toBe(
+                'Cannot cancel OrderLines from an Order in the "AddingItems" state',
+            );
+            expect(cancelOrder.errorCode).toBe(ErrorCode.CANCEL_ACTIVE_ORDER_ERROR);
+        });
+
+        it('cannot cancel from ArrangingPayment state', async () => {
+            await proceedToArrangingPayment(shopClient);
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: orderId,
+            });
+            expect(order!.state).toBe('ArrangingPayment');
+            const { cancelOrder } = await adminClient.query<CancelOrder.Mutation, CancelOrder.Variables>(
+                CANCEL_ORDER,
+                {
                     input: {
                         orderId,
                         lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: 1 })),
                     },
-                });
-            }, 'Cannot cancel OrderLines from an Order in the "ArrangingPayment" state'),
-        );
+                },
+            );
+            orderGuard.assertErrorResult(cancelOrder);
 
-        it(
-            'throws if lines are empty',
-            assertThrowsWithMessage(async () => {
-                const order = await addPaymentToOrder(shopClient, twoStagePaymentMethod);
-                expect(order.state).toBe('PaymentAuthorized');
+            expect(cancelOrder.message).toBe(
+                'Cannot cancel OrderLines from an Order in the "ArrangingPayment" state',
+            );
+            expect(cancelOrder.errorCode).toBe(ErrorCode.CANCEL_ACTIVE_ORDER_ERROR);
+        });
 
-                await adminClient.query<CancelOrder.Mutation, CancelOrder.Variables>(CANCEL_ORDER, {
+        it('returns error result if lines are empty', async () => {
+            const order = await addPaymentToOrder(shopClient, twoStagePaymentMethod);
+            orderGuard.assertSuccess(order);
+
+            expect(order.state).toBe('PaymentAuthorized');
+
+            const { cancelOrder } = await adminClient.query<CancelOrder.Mutation, CancelOrder.Variables>(
+                CANCEL_ORDER,
+                {
                     input: {
                         orderId,
                         lines: [],
                     },
-                });
-            }, 'Nothing to cancel'),
-        );
+                },
+            );
+            orderGuard.assertErrorResult(cancelOrder);
 
-        it(
-            'throws if all quantities zero',
-            assertThrowsWithMessage(async () => {
-                const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
-                    id: orderId,
-                });
-                await adminClient.query<CancelOrder.Mutation, CancelOrder.Variables>(CANCEL_ORDER, {
+            expect(cancelOrder.message).toBe('At least one OrderLine must be specified');
+            expect(cancelOrder.errorCode).toBe(ErrorCode.EMPTY_ORDER_LINE_SELECTION_ERROR);
+        });
+
+        it('returns error result if all quantities zero', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: orderId,
+            });
+            const { cancelOrder } = await adminClient.query<CancelOrder.Mutation, CancelOrder.Variables>(
+                CANCEL_ORDER,
+                {
                     input: {
                         orderId,
                         lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: 0 })),
                     },
-                });
-            }, 'Nothing to cancel'),
-        );
+                },
+            );
+            orderGuard.assertErrorResult(cancelOrder);
+
+            expect(cancelOrder.message).toBe('At least one OrderLine must be specified');
+            expect(cancelOrder.errorCode).toBe(ErrorCode.EMPTY_ORDER_LINE_SELECTION_ERROR);
+        });
 
         it('partial cancellation', async () => {
             const result1 = await adminClient.query<GetStockMovement.Query, GetStockMovement.Variables>(
@@ -823,6 +884,7 @@ describe('Orders resolver', () => {
                     },
                 },
             );
+            orderGuard.assertSuccess(cancelOrder);
 
             expect(cancelOrder.lines[0].quantity).toBe(1);
             expect(cancelOrder.lines[0].items.sort((a, b) => (a.id < b.id ? -1 : 1))).toEqual([
@@ -855,6 +917,27 @@ describe('Orders resolver', () => {
             ]);
         });
 
+        it('returns error result if attempting to cancel already cancelled item', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: orderId,
+            });
+            const { cancelOrder } = await adminClient.query<CancelOrder.Mutation, CancelOrder.Variables>(
+                CANCEL_ORDER,
+                {
+                    input: {
+                        orderId,
+                        lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: 2 })),
+                    },
+                },
+            );
+            orderGuard.assertErrorResult(cancelOrder);
+
+            expect(cancelOrder.message).toBe(
+                'The specified quantity is greater than the available OrderItems',
+            );
+            expect(cancelOrder.errorCode).toBe(ErrorCode.QUANTITY_TOO_GREAT_ERROR);
+        });
+
         it('complete cancellation', async () => {
             const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
                 id: orderId,
@@ -968,50 +1051,61 @@ describe('Orders resolver', () => {
             productVariantId = result.productVariantId;
         });
 
-        it(
-            'cannot refund from PaymentAuthorized state',
-            assertThrowsWithMessage(async () => {
-                await proceedToArrangingPayment(shopClient);
-                const order = await addPaymentToOrder(shopClient, twoStagePaymentMethod);
-                expect(order.state).toBe('PaymentAuthorized');
-                paymentId = order.payments![0].id;
+        it('cannot refund from PaymentAuthorized state', async () => {
+            await proceedToArrangingPayment(shopClient);
+            const order = await addPaymentToOrder(shopClient, twoStagePaymentMethod);
+            orderGuard.assertSuccess(order);
 
-                await adminClient.query<RefundOrder.Mutation, RefundOrder.Variables>(REFUND_ORDER, {
+            expect(order.state).toBe('PaymentAuthorized');
+            paymentId = order.payments![0].id;
+
+            const { refundOrder } = await adminClient.query<RefundOrder.Mutation, RefundOrder.Variables>(
+                REFUND_ORDER,
+                {
                     input: {
                         lines: order.lines.map(l => ({ orderLineId: l.id, quantity: 1 })),
                         shipping: 0,
                         adjustment: 0,
                         paymentId,
                     },
-                });
-            }, 'Cannot refund an Order in the "PaymentAuthorized" state'),
-        );
+                },
+            );
+            refundGuard.assertErrorResult(refundOrder);
 
-        it(
-            'throws if no lines and no shipping',
-            assertThrowsWithMessage(async () => {
-                const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
-                    id: orderId,
-                });
-                const { settlePayment } = await adminClient.query<
-                    SettlePayment.Mutation,
-                    SettlePayment.Variables
-                >(SETTLE_PAYMENT, {
-                    id: order!.payments![0].id,
-                });
+            expect(refundOrder.message).toBe('Cannot refund an Order in the "PaymentAuthorized" state');
+            expect(refundOrder.errorCode).toBe(ErrorCode.REFUND_ORDER_STATE_ERROR);
+        });
 
-                expect(settlePayment!.state).toBe('Settled');
+        it('returns error result if no lines and no shipping', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: orderId,
+            });
+            const { settlePayment } = await adminClient.query<
+                SettlePayment.Mutation,
+                SettlePayment.Variables
+            >(SETTLE_PAYMENT, {
+                id: order!.payments![0].id,
+            });
+            paymentGuard.assertSuccess(settlePayment);
 
-                await adminClient.query<RefundOrder.Mutation, RefundOrder.Variables>(REFUND_ORDER, {
+            expect(settlePayment!.state).toBe('Settled');
+
+            const { refundOrder } = await adminClient.query<RefundOrder.Mutation, RefundOrder.Variables>(
+                REFUND_ORDER,
+                {
                     input: {
                         lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: 0 })),
                         shipping: 0,
                         adjustment: 0,
                         paymentId,
                     },
-                });
-            }, 'Nothing to refund'),
-        );
+                },
+            );
+            refundGuard.assertErrorResult(refundOrder);
+
+            expect(refundOrder.message).toBe('Nothing to refund');
+            expect(refundOrder.errorCode).toBe(ErrorCode.NOTHING_TO_REFUND_ERROR);
+        });
 
         it(
             'throws if paymentId not valid',
@@ -1030,28 +1124,29 @@ describe('Orders resolver', () => {
                         },
                     },
                 );
-            }, "No Payment with the id '999' could be found"),
+            }, `No Payment with the id '999' could be found`),
         );
 
-        it(
-            'throws if payment and order lines do not belong to the same Order',
-            assertThrowsWithMessage(async () => {
-                const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
-                    id: orderId,
-                });
-                const { refundOrder } = await adminClient.query<RefundOrder.Mutation, RefundOrder.Variables>(
-                    REFUND_ORDER,
-                    {
-                        input: {
-                            lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: l.quantity })),
-                            shipping: 100,
-                            adjustment: 0,
-                            paymentId: 'T_1',
-                        },
+        it('returns error result if payment and order lines do not belong to the same Order', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: orderId,
+            });
+            const { refundOrder } = await adminClient.query<RefundOrder.Mutation, RefundOrder.Variables>(
+                REFUND_ORDER,
+                {
+                    input: {
+                        lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: l.quantity })),
+                        shipping: 100,
+                        adjustment: 0,
+                        paymentId: 'T_1',
                     },
-                );
-            }, 'The Payment and OrderLines do not belong to the same Order'),
-        );
+                },
+            );
+            refundGuard.assertErrorResult(refundOrder);
+
+            expect(refundOrder.message).toBe('The Payment and OrderLines do not belong to the same Order');
+            expect(refundOrder.errorCode).toBe(ErrorCode.PAYMENT_ORDER_MISMATCH_ERROR);
+        });
 
         it('creates a Refund to be manually settled', async () => {
             const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
@@ -1069,6 +1164,7 @@ describe('Orders resolver', () => {
                     },
                 },
             );
+            refundGuard.assertSuccess(refundOrder);
 
             expect(refundOrder.shipping).toBe(order!.shipping);
             expect(refundOrder.items).toBe(order!.subTotal);
@@ -1078,25 +1174,26 @@ describe('Orders resolver', () => {
             refundId = refundOrder.id;
         });
 
-        it(
-            'throws if attempting to refund the same item more than once',
-            assertThrowsWithMessage(async () => {
-                const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
-                    id: orderId,
-                });
-                const { refundOrder } = await adminClient.query<RefundOrder.Mutation, RefundOrder.Variables>(
-                    REFUND_ORDER,
-                    {
-                        input: {
-                            lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: l.quantity })),
-                            shipping: order!.shipping,
-                            adjustment: 0,
-                            paymentId,
-                        },
+        it('returns error result if attempting to refund the same item more than once', async () => {
+            const { order } = await adminClient.query<GetOrder.Query, GetOrder.Variables>(GET_ORDER, {
+                id: orderId,
+            });
+            const { refundOrder } = await adminClient.query<RefundOrder.Mutation, RefundOrder.Variables>(
+                REFUND_ORDER,
+                {
+                    input: {
+                        lines: order!.lines.map(l => ({ orderLineId: l.id, quantity: l.quantity })),
+                        shipping: order!.shipping,
+                        adjustment: 0,
+                        paymentId,
                     },
-                );
-            }, 'Cannot refund an OrderItem which has already been refunded'),
-        );
+                },
+            );
+            refundGuard.assertErrorResult(refundOrder);
+
+            expect(refundOrder.message).toBe('Cannot refund an OrderItem which has already been refunded');
+            expect(refundOrder.errorCode).toBe(ErrorCode.ALREADY_REFUNDED_ERROR);
+        });
 
         it('manually settle a Refund', async () => {
             const { settleRefund } = await adminClient.query<SettleRefund.Mutation, SettleRefund.Variables>(
@@ -1108,6 +1205,7 @@ describe('Orders resolver', () => {
                     },
                 },
             );
+            refundGuard.assertSuccess(settleRefund);
 
             expect(settleRefund.state).toBe('Settled');
             expect(settleRefund.transactionId).toBe('aaabbb');
@@ -1356,18 +1454,28 @@ async function createTestOrder(
             quantity: 2,
         },
     );
-    const orderId = addItemToOrder!.id;
+    const orderId = (addItemToOrder as UpdatedOrder.Fragment).id;
     return { product, productVariantId, orderId };
 }
 
 export const SETTLE_PAYMENT = gql`
     mutation SettlePayment($id: ID!) {
         settlePayment(id: $id) {
-            id
-            state
-            metadata
+            ...Payment
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+            ... on SettlePaymentError {
+                paymentErrorMessage
+            }
         }
     }
+    fragment Payment on Payment {
+        id
+        state
+        metadata
+    }
 `;
 
 export const GET_ORDER_LIST_FULFILLMENTS = gql`
@@ -1393,57 +1501,71 @@ export const GET_ORDER_FULFILLMENT_ITEMS = gql`
             id
             state
             fulfillments {
-                id
-                state
-                orderItems {
-                    id
-                }
+                ...Fulfillment
             }
         }
     }
+    ${FULFILLMENT_FRAGMENT}
 `;
 
 export const CANCEL_ORDER = gql`
     mutation CancelOrder($input: CancelOrderInput!) {
         cancelOrder(input: $input) {
-            id
-            lines {
-                quantity
-                items {
-                    id
-                    cancelled
-                }
+            ...CanceledOrder
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+        }
+    }
+    fragment CanceledOrder on Order {
+        id
+        lines {
+            quantity
+            items {
+                id
+                cancelled
             }
         }
     }
 `;
 
+const REFUND_FRAGMENT = gql`
+    fragment Refund on Refund {
+        id
+        state
+        items
+        transactionId
+        shipping
+        total
+        metadata
+    }
+`;
+
 export const REFUND_ORDER = gql`
     mutation RefundOrder($input: RefundOrderInput!) {
         refundOrder(input: $input) {
-            id
-            state
-            items
-            transactionId
-            shipping
-            total
-            metadata
+            ...Refund
+            ... on ErrorResult {
+                errorCode
+                message
+            }
         }
     }
+    ${REFUND_FRAGMENT}
 `;
 
 export const SETTLE_REFUND = gql`
     mutation SettleRefund($input: SettleRefundInput!) {
         settleRefund(input: $input) {
-            id
-            state
-            items
-            transactionId
-            shipping
-            total
-            metadata
+            ...Refund
+            ... on ErrorResult {
+                errorCode
+                message
+            }
         }
     }
+    ${REFUND_FRAGMENT}
 `;
 
 export const GET_ORDER_HISTORY = gql`

packages/core/e2e/price-calculation-strategy.e2e-spec.ts

@@ -86,20 +86,22 @@ const ADD_ITEM_TO_ORDER_CUSTOM_FIELDS = gql`
             quantity: $quantity
             customFields: $customFields
         ) {
-            id
-            subTotalBeforeTax
-            subTotal
-            shipping
-            total
-            lines {
+            ... on Order {
                 id
-                quantity
-                unitPrice
-                unitPriceWithTax
-                items {
+                subTotalBeforeTax
+                subTotal
+                shipping
+                total
+                lines {
+                    id
+                    quantity
                     unitPrice
                     unitPriceWithTax
-                    unitPriceIncludesTax
+                    items {
+                        unitPrice
+                        unitPriceWithTax
+                        unitPriceIncludesTax
+                    }
                 }
             }
         }

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

@@ -1,7 +1,7 @@
 import { omit } from '@vendure/common/lib/omit';
 import { pick } from '@vendure/common/lib/pick';
 import { notNullOrUndefined } from '@vendure/common/lib/shared-utils';
-import { createTestEnvironment } from '@vendure/testing';
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
 import gql from 'graphql-tag';
 import path from 'path';
 
@@ -15,6 +15,7 @@ import {
     DeleteProduct,
     DeleteProductVariant,
     DeletionResult,
+    ErrorCode,
     GetAssetList,
     GetOptionGroup,
     GetProductList,
@@ -23,6 +24,7 @@ import {
     GetProductWithVariants,
     LanguageCode,
     ProductVariantFragment,
+    ProductWithOptionsFragment,
     ProductWithVariants,
     RemoveOptionGroupFromProduct,
     SortOrder,
@@ -49,6 +51,10 @@ import { sortById } from './utils/test-order-utils';
 describe('Product resolver', () => {
     const { server, adminClient, shopClient } = createTestEnvironment(testConfig);
 
+    const removeOptionGuard: ErrorResultGuard<ProductWithOptionsFragment> = createErrorResultGuard<
+        ProductWithOptionsFragment
+    >(input => !!input.optionGroups);
+
     beforeAll(async () => {
         await server.init({
             initialData,
@@ -682,31 +688,36 @@ describe('Product resolver', () => {
             });
             expect(addOptionGroupToProduct.optionGroups.length).toBe(1);
 
-            const result = await adminClient.query<
+            const { removeOptionGroupFromProduct } = await adminClient.query<
                 RemoveOptionGroupFromProduct.Mutation,
                 RemoveOptionGroupFromProduct.Variables
             >(REMOVE_OPTION_GROUP_FROM_PRODUCT, {
                 optionGroupId: 'T_1',
                 productId: newProductWithAssets.id,
             });
-            expect(result.removeOptionGroupFromProduct.id).toBe(newProductWithAssets.id);
-            expect(result.removeOptionGroupFromProduct.optionGroups.length).toBe(0);
+            removeOptionGuard.assertSuccess(removeOptionGroupFromProduct);
+
+            expect(removeOptionGroupFromProduct.id).toBe(newProductWithAssets.id);
+            expect(removeOptionGroupFromProduct.optionGroups.length).toBe(0);
         });
 
-        it(
-            'removeOptionGroupFromProduct errors if the optionGroup is being used by variants',
-            assertThrowsWithMessage(
-                () =>
-                    adminClient.query<
-                        RemoveOptionGroupFromProduct.Mutation,
-                        RemoveOptionGroupFromProduct.Variables
-                    >(REMOVE_OPTION_GROUP_FROM_PRODUCT, {
-                        optionGroupId: 'T_3',
-                        productId: 'T_2',
-                    }),
+        it('removeOptionGroupFromProduct return error result if the optionGroup is being used by variants', async () => {
+            const { removeOptionGroupFromProduct } = await adminClient.query<
+                RemoveOptionGroupFromProduct.Mutation,
+                RemoveOptionGroupFromProduct.Variables
+            >(REMOVE_OPTION_GROUP_FROM_PRODUCT, {
+                optionGroupId: 'T_3',
+                productId: 'T_2',
+            });
+            removeOptionGuard.assertErrorResult(removeOptionGroupFromProduct);
+
+            expect(removeOptionGroupFromProduct.message).toBe(
                 `Cannot remove ProductOptionGroup "curvy-monitor-monitor-size" as it is used by 2 ProductVariants`,
-            ),
-        );
+            );
+            expect(removeOptionGroupFromProduct.errorCode).toBe(ErrorCode.PRODUCT_OPTION_IN_USE_ERROR);
+            expect(removeOptionGroupFromProduct.optionGroupCode).toBe('curvy-monitor-monitor-size');
+            expect(removeOptionGroupFromProduct.productVariantCount).toBe(2);
+        });
 
         it(
             'removeOptionGroupFromProduct errors with an invalid productId',
@@ -1157,36 +1168,42 @@ describe('Product resolver', () => {
     });
 });
 
-export const ADD_OPTION_GROUP_TO_PRODUCT = gql`
-    mutation AddOptionGroupToProduct($productId: ID!, $optionGroupId: ID!) {
-        addOptionGroupToProduct(productId: $productId, optionGroupId: $optionGroupId) {
+const PRODUCT_WITH_OPTIONS_FRAGMENT = gql`
+    fragment ProductWithOptions on Product {
+        id
+        optionGroups {
             id
-            optionGroups {
+            code
+            options {
                 id
                 code
-                options {
-                    id
-                    code
-                }
             }
         }
     }
 `;
 
+export const ADD_OPTION_GROUP_TO_PRODUCT = gql`
+    mutation AddOptionGroupToProduct($productId: ID!, $optionGroupId: ID!) {
+        addOptionGroupToProduct(productId: $productId, optionGroupId: $optionGroupId) {
+            ...ProductWithOptions
+        }
+    }
+    ${PRODUCT_WITH_OPTIONS_FRAGMENT}
+`;
+
 export const REMOVE_OPTION_GROUP_FROM_PRODUCT = gql`
     mutation RemoveOptionGroupFromProduct($productId: ID!, $optionGroupId: ID!) {
         removeOptionGroupFromProduct(productId: $productId, optionGroupId: $optionGroupId) {
-            id
-            optionGroups {
-                id
-                code
-                options {
-                    id
-                    code
-                }
+            ...ProductWithOptions
+            ... on ProductOptionInUseError {
+                errorCode
+                message
+                optionGroupCode
+                productVariantCount
             }
         }
     }
+    ${PRODUCT_WITH_OPTIONS_FRAGMENT}
 `;
 
 export const GET_OPTION_GROUP = gql`

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

@@ -1,22 +1,24 @@
 import { pick } from '@vendure/common/lib/pick';
 import { PromotionAction, PromotionCondition, PromotionOrderAction } from '@vendure/core';
-import { createTestEnvironment } from '@vendure/testing';
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
 import gql from 'graphql-tag';
 import path from 'path';
 
 import { initialData } from '../../../e2e-common/e2e-initial-data';
-import { testConfig, TEST_SETUP_TIMEOUT_MS } from '../../../e2e-common/test-config';
+import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-config';
 
 import { PROMOTION_FRAGMENT } from './graphql/fragments';
 import {
     CreatePromotion,
     DeletePromotion,
     DeletionResult,
+    ErrorCode,
     GetAdjustmentOperations,
     GetPromotion,
     GetPromotionList,
     LanguageCode,
     Promotion,
+    PromotionFragment,
     UpdatePromotion,
 } from './graphql/generated-e2e-admin-types';
 import { CREATE_PROMOTION } from './graphql/shared-definitions';
@@ -48,6 +50,10 @@ describe('Promotion resolver', () => {
     ];
     let promotion: Promotion.Fragment;
 
+    const promotionGuard: ErrorResultGuard<PromotionFragment> = createErrorResultGuard<PromotionFragment>(
+        input => !!input.couponCode,
+    );
+
     beforeAll(async () => {
         await server.init({
             initialData,
@@ -62,100 +68,116 @@ describe('Promotion resolver', () => {
     });
 
     it('createPromotion', async () => {
-        const result = await adminClient.query<CreatePromotion.Mutation, CreatePromotion.Variables>(
-            CREATE_PROMOTION,
-            {
-                input: {
-                    name: 'test promotion',
-                    enabled: true,
-                    couponCode: 'TEST123',
-                    startsAt: new Date('2019-10-30T00:00:00.000Z'),
-                    endsAt: new Date('2019-12-01T00:00:00.000Z'),
-                    conditions: [
-                        {
-                            code: promoCondition.code,
-                            arguments: [{ name: 'arg', value: '500' }],
-                        },
-                    ],
-                    actions: [
-                        {
-                            code: promoAction.code,
-                            arguments: [
-                                {
-                                    name: 'facetValueIds',
-                                    value: '["T_1"]',
-                                },
-                            ],
-                        },
-                    ],
-                },
+        const { createPromotion } = await adminClient.query<
+            CreatePromotion.Mutation,
+            CreatePromotion.Variables
+        >(CREATE_PROMOTION, {
+            input: {
+                name: 'test promotion',
+                enabled: true,
+                couponCode: 'TEST123',
+                startsAt: new Date('2019-10-30T00:00:00.000Z'),
+                endsAt: new Date('2019-12-01T00:00:00.000Z'),
+                conditions: [
+                    {
+                        code: promoCondition.code,
+                        arguments: [{ name: 'arg', value: '500' }],
+                    },
+                ],
+                actions: [
+                    {
+                        code: promoAction.code,
+                        arguments: [
+                            {
+                                name: 'facetValueIds',
+                                value: '["T_1"]',
+                            },
+                        ],
+                    },
+                ],
             },
-        );
-        promotion = result.createPromotion;
+        });
+        promotionGuard.assertSuccess(createPromotion);
+
+        promotion = createPromotion;
         expect(pick(promotion, snapshotProps)).toMatchSnapshot();
     });
 
-    it(
-        'createPromotion throws with empty conditions and no couponCode',
-        assertThrowsWithMessage(async () => {
-            await adminClient.query<CreatePromotion.Mutation, CreatePromotion.Variables>(CREATE_PROMOTION, {
-                input: {
-                    name: 'bad promotion',
-                    enabled: true,
-                    conditions: [],
-                    actions: [
-                        {
-                            code: promoAction.code,
-                            arguments: [
-                                {
-                                    name: 'facetValueIds',
-                                    value: '["T_1"]',
-                                },
-                            ],
-                        },
-                    ],
-                },
-            });
-        }, 'A Promotion must have either at least one condition or a coupon code set'),
-    );
+    it('createPromotion return error result with empty conditions and no couponCode', async () => {
+        const { createPromotion } = await adminClient.query<
+            CreatePromotion.Mutation,
+            CreatePromotion.Variables
+        >(CREATE_PROMOTION, {
+            input: {
+                name: 'bad promotion',
+                enabled: true,
+                conditions: [],
+                actions: [
+                    {
+                        code: promoAction.code,
+                        arguments: [
+                            {
+                                name: 'facetValueIds',
+                                value: '["T_1"]',
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+        promotionGuard.assertErrorResult(createPromotion);
+
+        expect(createPromotion.message).toBe(
+            'A Promotion must have either at least one condition or a coupon code set',
+        );
+        expect(createPromotion.errorCode).toBe(ErrorCode.MISSING_CONDITIONS_ERROR);
+    });
 
     it('updatePromotion', async () => {
-        const result = await adminClient.query<UpdatePromotion.Mutation, UpdatePromotion.Variables>(
-            UPDATE_PROMOTION,
-            {
-                input: {
-                    id: promotion.id,
-                    couponCode: 'TEST1235',
-                    startsAt: new Date('2019-05-30T22:00:00.000Z'),
-                    endsAt: new Date('2019-06-01T22:00:00.000Z'),
-                    conditions: [
-                        {
-                            code: promoCondition.code,
-                            arguments: [{ name: 'arg', value: '90' }],
-                        },
-                        {
-                            code: promoCondition2.code,
-                            arguments: [{ name: 'arg', value: '10' }],
-                        },
-                    ],
-                },
+        const { updatePromotion } = await adminClient.query<
+            UpdatePromotion.Mutation,
+            UpdatePromotion.Variables
+        >(UPDATE_PROMOTION, {
+            input: {
+                id: promotion.id,
+                couponCode: 'TEST1235',
+                startsAt: new Date('2019-05-30T22:00:00.000Z'),
+                endsAt: new Date('2019-06-01T22:00:00.000Z'),
+                conditions: [
+                    {
+                        code: promoCondition.code,
+                        arguments: [{ name: 'arg', value: '90' }],
+                    },
+                    {
+                        code: promoCondition2.code,
+                        arguments: [{ name: 'arg', value: '10' }],
+                    },
+                ],
             },
-        );
-        expect(pick(result.updatePromotion, snapshotProps)).toMatchSnapshot();
+        });
+        promotionGuard.assertSuccess(updatePromotion);
+
+        expect(pick(updatePromotion, snapshotProps)).toMatchSnapshot();
     });
 
-    it(
-        'updatePromotion throws with empty conditions and no couponCode',
-        assertThrowsWithMessage(async () => {
-            await adminClient.query<UpdatePromotion.Mutation, UpdatePromotion.Variables>(UPDATE_PROMOTION, {
-                input: {
-                    id: promotion.id,
-                    couponCode: '',
-                    conditions: [],
-                },
-            });
-        }, 'A Promotion must have either at least one condition or a coupon code set'),
-    );
+    it('updatePromotion return error result with empty conditions and no couponCode', async () => {
+        const { updatePromotion } = await adminClient.query<
+            UpdatePromotion.Mutation,
+            UpdatePromotion.Variables
+        >(UPDATE_PROMOTION, {
+            input: {
+                id: promotion.id,
+                couponCode: '',
+                conditions: [],
+            },
+        });
+        promotionGuard.assertErrorResult(updatePromotion);
+
+        expect(updatePromotion.message).toBe(
+            'A Promotion must have either at least one condition or a coupon code set',
+        );
+        expect(updatePromotion.errorCode).toBe(ErrorCode.MISSING_CONDITIONS_ERROR);
+    });
 
     it('promotion', async () => {
         const result = await adminClient.query<GetPromotion.Query, GetPromotion.Variables>(GET_PROMOTION, {
@@ -291,6 +313,10 @@ export const UPDATE_PROMOTION = gql`
     mutation UpdatePromotion($input: UpdatePromotionInput!) {
         updatePromotion(input: $input) {
             ...Promotion
+            ... on ErrorResult {
+                errorCode
+                message
+            }
         }
     }
     ${PROMOTION_FRAGMENT}

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

@@ -13,6 +13,7 @@ import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-conf
 
 import { ROLE_FRAGMENT } from './graphql/fragments';
 import {
+    ChannelFragment,
     CreateChannel,
     CreateRole,
     CurrencyCode,
@@ -280,7 +281,7 @@ describe('Role resolver', () => {
     });
 
     describe('multi-channel', () => {
-        let secondChannel: CreateChannel.CreateChannel;
+        let secondChannel: ChannelFragment;
         let multiChannelRole: CreateRole.CreateRole;
 
         beforeAll(async () => {

packages/core/e2e/session-management.e2e-spec.ts

@@ -104,7 +104,9 @@ describe('Session caching', () => {
         await adminClient.query(
             gql`
                 mutation Logout {
-                    logout
+                    logout {
+                        success
+                    }
                 }
             `,
         );

packages/core/e2e/shop-auth.e2e-spec.ts

@@ -1,6 +1,6 @@
 /* tslint:disable:no-non-null-assertion */
 import { OnModuleInit } from '@nestjs/common';
-import { RegisterCustomerInput } from '@vendure/common/lib/generated-shop-types';
+import { ErrorCode, RegisterCustomerInput } from '@vendure/common/lib/generated-shop-types';
 import { pick } from '@vendure/common/lib/pick';
 import {
     AccountRegistrationEvent,
@@ -12,7 +12,7 @@ import {
     PasswordResetEvent,
     VendurePlugin,
 } from '@vendure/core';
-import { createTestEnvironment } from '@vendure/testing';
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
 import { DocumentNode } from 'graphql';
 import gql from 'graphql-tag';
 import path from 'path';
@@ -30,6 +30,7 @@ import {
     Permission,
 } from './graphql/generated-e2e-admin-types';
 import {
+    CurrentUserShopFragment,
     GetActiveCustomer,
     RefreshToken,
     Register,
@@ -70,21 +71,29 @@ let sendEmailFn: jest.Mock;
 class TestEmailPlugin implements OnModuleInit {
     constructor(private eventBus: EventBus) {}
     onModuleInit() {
-        this.eventBus.ofType(AccountRegistrationEvent).subscribe((event) => {
+        this.eventBus.ofType(AccountRegistrationEvent).subscribe(event => {
             sendEmailFn(event);
         });
-        this.eventBus.ofType(PasswordResetEvent).subscribe((event) => {
+        this.eventBus.ofType(PasswordResetEvent).subscribe(event => {
             sendEmailFn(event);
         });
-        this.eventBus.ofType(IdentifierChangeRequestEvent).subscribe((event) => {
+        this.eventBus.ofType(IdentifierChangeRequestEvent).subscribe(event => {
             sendEmailFn(event);
         });
-        this.eventBus.ofType(IdentifierChangeEvent).subscribe((event) => {
+        this.eventBus.ofType(IdentifierChangeEvent).subscribe(event => {
             sendEmailFn(event);
         });
     }
 }
 
+const successErrorGuard: ErrorResultGuard<{ success: boolean }> = createErrorResultGuard<{
+    success: boolean;
+}>(input => input.success != null);
+
+const currentUserErrorGuard: ErrorResultGuard<CurrentUserShopFragment> = createErrorResultGuard<
+    CurrentUserShopFragment
+>(input => input.identifier != null);
+
 describe('Shop auth & accounts', () => {
     const { server, adminClient, shopClient } = createTestEnvironment(
         mergeConfig(testConfig, {
@@ -115,6 +124,24 @@ describe('Shop auth & accounts', () => {
             sendEmailFn = jest.fn();
         });
 
+        it('does not return error result on email address conflict', async () => {
+            // To prevent account enumeration attacks
+            const { customers } = await adminClient.query<GetCustomerList.Query>(GET_CUSTOMER_LIST);
+            const input: RegisterCustomerInput = {
+                firstName: 'Duplicate',
+                lastName: 'Person',
+                phoneNumber: '123456',
+                emailAddress: customers.items[0].emailAddress,
+            };
+            const { registerCustomerAccount } = await shopClient.query<Register.Mutation, Register.Variables>(
+                REGISTER_ACCOUNT,
+                {
+                    input,
+                },
+            );
+            successErrorGuard.assertSuccess(registerCustomerAccount);
+        });
+
         it('register a new account without password', async () => {
             const verificationTokenPromise = getVerificationTokenPromise();
             const input: RegisterCustomerInput = {
@@ -123,13 +150,17 @@ describe('Shop auth & accounts', () => {
                 phoneNumber: '123456',
                 emailAddress,
             };
-            const result = await shopClient.query<Register.Mutation, Register.Variables>(REGISTER_ACCOUNT, {
-                input,
-            });
+            const { registerCustomerAccount } = await shopClient.query<Register.Mutation, Register.Variables>(
+                REGISTER_ACCOUNT,
+                {
+                    input,
+                },
+            );
+            successErrorGuard.assertSuccess(registerCustomerAccount);
 
             verificationToken = await verificationTokenPromise;
 
-            expect(result.registerCustomerAccount).toBe(true);
+            expect(registerCustomerAccount.success).toBe(true);
             expect(sendEmailFn).toHaveBeenCalled();
             expect(verificationToken).toBeDefined();
 
@@ -152,7 +183,7 @@ describe('Shop auth & accounts', () => {
         });
 
         it('issues a new token if attempting to register a second time', async () => {
-            const sendEmail = new Promise<string>((resolve) => {
+            const sendEmail = new Promise<string>(resolve => {
                 sendEmailFn.mockImplementation((event: AccountRegistrationEvent) => {
                     resolve(event.user.getNativeAuthenticationMethod().verificationToken!);
                 });
@@ -162,13 +193,17 @@ describe('Shop auth & accounts', () => {
                 lastName: 'Tester',
                 emailAddress,
             };
-            const result = await shopClient.query<Register.Mutation, Register.Variables>(REGISTER_ACCOUNT, {
-                input,
-            });
+            const { registerCustomerAccount } = await shopClient.query<Register.Mutation, Register.Variables>(
+                REGISTER_ACCOUNT,
+                {
+                    input,
+                },
+            );
+            successErrorGuard.assertSuccess(registerCustomerAccount);
 
             const newVerificationToken = await sendEmail;
 
-            expect(result.registerCustomerAccount).toBe(true);
+            expect(registerCustomerAccount.success).toBe(true);
             expect(sendEmailFn).toHaveBeenCalled();
             expect(newVerificationToken).not.toBe(verificationToken);
 
@@ -176,19 +211,19 @@ describe('Shop auth & accounts', () => {
         });
 
         it('refreshCustomerVerification issues a new token', async () => {
-            const sendEmail = new Promise<string>((resolve) => {
+            const sendEmail = new Promise<string>(resolve => {
                 sendEmailFn.mockImplementation((event: AccountRegistrationEvent) => {
                     resolve(event.user.getNativeAuthenticationMethod().verificationToken!);
                 });
             });
-            const result = await shopClient.query<RefreshToken.Mutation, RefreshToken.Variables>(
-                REFRESH_TOKEN,
-                { emailAddress },
-            );
-
+            const { refreshCustomerVerification } = await shopClient.query<
+                RefreshToken.Mutation,
+                RefreshToken.Variables
+            >(REFRESH_TOKEN, { emailAddress });
+            successErrorGuard.assertSuccess(refreshCustomerVerification);
             const newVerificationToken = await sendEmail;
 
-            expect(result.refreshCustomerVerification).toBe(true);
+            expect(refreshCustomerVerification.success).toBe(true);
             expect(sendEmailFn).toHaveBeenCalled();
             expect(newVerificationToken).not.toBe(verificationToken);
 
@@ -196,56 +231,62 @@ describe('Shop auth & accounts', () => {
         });
 
         it('refreshCustomerVerification does nothing with an unrecognized emailAddress', async () => {
-            const result = await shopClient.query<RefreshToken.Mutation, RefreshToken.Variables>(
-                REFRESH_TOKEN,
-                {
-                    emailAddress: 'never-been-registered@test.com',
-                },
-            );
+            const { refreshCustomerVerification } = await shopClient.query<
+                RefreshToken.Mutation,
+                RefreshToken.Variables
+            >(REFRESH_TOKEN, {
+                emailAddress: 'never-been-registered@test.com',
+            });
+            successErrorGuard.assertSuccess(refreshCustomerVerification);
             await waitForSendEmailFn();
-            expect(result.refreshCustomerVerification).toBe(true);
+
+            expect(refreshCustomerVerification.success).toBe(true);
             expect(sendEmailFn).not.toHaveBeenCalled();
         });
 
         it('login fails before verification', async () => {
-            try {
-                await shopClient.asUserWithCredentials(emailAddress, '');
-                fail('should have thrown');
-            } catch (err) {
-                expect(getErrorCode(err)).toBe('UNAUTHORIZED');
-            }
+            const result = await shopClient.asUserWithCredentials(emailAddress, '');
+            expect(result.errorCode).toBe(ErrorCode.INVALID_CREDENTIALS_ERROR);
         });
 
-        it(
-            'verification fails with wrong token',
-            assertThrowsWithMessage(
-                () =>
-                    shopClient.query<Verify.Mutation, Verify.Variables>(VERIFY_EMAIL, {
-                        password,
-                        token: 'bad-token',
-                    }),
-                `Verification token not recognized`,
-            ),
-        );
+        it('verification fails with wrong token', async () => {
+            const { verifyCustomerAccount } = await shopClient.query<Verify.Mutation, Verify.Variables>(
+                VERIFY_EMAIL,
+                {
+                    password,
+                    token: 'bad-token',
+                },
+            );
+            currentUserErrorGuard.assertErrorResult(verifyCustomerAccount);
 
-        it(
-            'verification fails with no password',
-            assertThrowsWithMessage(
-                () =>
-                    shopClient.query<Verify.Mutation, Verify.Variables>(VERIFY_EMAIL, {
-                        token: verificationToken,
-                    }),
-                `A password must be provided as it was not set during registration`,
-            ),
-        );
+            expect(verifyCustomerAccount.message).toBe(`Verification token not recognized`);
+            expect(verifyCustomerAccount.errorCode).toBe(ErrorCode.VERIFICATION_TOKEN_INVALID_ERROR);
+        });
+
+        it('verification fails with no password', async () => {
+            const { verifyCustomerAccount } = await shopClient.query<Verify.Mutation, Verify.Variables>(
+                VERIFY_EMAIL,
+                {
+                    token: verificationToken,
+                },
+            );
+            currentUserErrorGuard.assertErrorResult(verifyCustomerAccount);
+
+            expect(verifyCustomerAccount.message).toBe(`A password must be provided.`);
+            expect(verifyCustomerAccount.errorCode).toBe(ErrorCode.MISSING_PASSWORD_ERROR);
+        });
 
         it('verification succeeds with password and correct token', async () => {
-            const result = await shopClient.query<Verify.Mutation, Verify.Variables>(VERIFY_EMAIL, {
-                password,
-                token: verificationToken,
-            });
+            const { verifyCustomerAccount } = await shopClient.query<Verify.Mutation, Verify.Variables>(
+                VERIFY_EMAIL,
+                {
+                    password,
+                    token: verificationToken,
+                },
+            );
+            currentUserErrorGuard.assertSuccess(verifyCustomerAccount);
 
-            expect(result.verifyCustomerAccount.user.identifier).toBe('test1@test.com');
+            expect(verifyCustomerAccount.identifier).toBe('test1@test.com');
             const { activeCustomer } = await shopClient.query<GetActiveCustomer.Query>(GET_ACTIVE_CUSTOMER);
             newCustomerId = activeCustomer!.id;
         });
@@ -256,25 +297,32 @@ describe('Shop auth & accounts', () => {
                 lastName: 'Hacker',
                 emailAddress,
             };
-            const result = await shopClient.query<Register.Mutation, Register.Variables>(REGISTER_ACCOUNT, {
-                input,
-            });
+            const { registerCustomerAccount } = await shopClient.query<Register.Mutation, Register.Variables>(
+                REGISTER_ACCOUNT,
+                {
+                    input,
+                },
+            );
+            successErrorGuard.assertSuccess(registerCustomerAccount);
+
             await waitForSendEmailFn();
-            expect(result.registerCustomerAccount).toBe(true);
+            expect(registerCustomerAccount.success).toBe(true);
             expect(sendEmailFn).not.toHaveBeenCalled();
         });
 
-        it(
-            'verification fails if attempted a second time',
-            assertThrowsWithMessage(
-                () =>
-                    shopClient.query<Verify.Mutation, Verify.Variables>(VERIFY_EMAIL, {
-                        password,
-                        token: verificationToken,
-                    }),
-                `Verification token not recognized`,
-            ),
-        );
+        it('verification fails if attempted a second time', async () => {
+            const { verifyCustomerAccount } = await shopClient.query<Verify.Mutation, Verify.Variables>(
+                VERIFY_EMAIL,
+                {
+                    password,
+                    token: verificationToken,
+                },
+            );
+            currentUserErrorGuard.assertErrorResult(verifyCustomerAccount);
+
+            expect(verifyCustomerAccount.message).toBe(`Verification token not recognized`);
+            expect(verifyCustomerAccount.errorCode).toBe(ErrorCode.VERIFICATION_TOKEN_INVALID_ERROR);
+        });
 
         it('customer history contains entries for registration & verification', async () => {
             const { customer } = await adminClient.query<
@@ -322,13 +370,17 @@ describe('Shop auth & accounts', () => {
                 emailAddress,
                 password,
             };
-            const result = await shopClient.query<Register.Mutation, Register.Variables>(REGISTER_ACCOUNT, {
-                input,
-            });
+            const { registerCustomerAccount } = await shopClient.query<Register.Mutation, Register.Variables>(
+                REGISTER_ACCOUNT,
+                {
+                    input,
+                },
+            );
+            successErrorGuard.assertSuccess(registerCustomerAccount);
 
             verificationToken = await verificationTokenPromise;
 
-            expect(result.registerCustomerAccount).toBe(true);
+            expect(registerCustomerAccount.success).toBe(true);
             expect(sendEmailFn).toHaveBeenCalled();
             expect(verificationToken).toBeDefined();
 
@@ -349,25 +401,31 @@ describe('Shop auth & accounts', () => {
                 pick(customers.items[0], ['firstName', 'lastName', 'emailAddress', 'phoneNumber']),
             ).toEqual(pick(input, ['firstName', 'lastName', 'emailAddress', 'phoneNumber']));
         });
-        it(
-            'verification fails with password',
-            assertThrowsWithMessage(
-                () =>
-                    shopClient.query<Verify.Mutation, Verify.Variables>(VERIFY_EMAIL, {
-                        token: verificationToken,
-                        password: 'new password',
-                    }),
-                `A password has already been set during registration`,
-            ),
-        );
+
+        it('verification fails with password', async () => {
+            const { verifyCustomerAccount } = await shopClient.query<Verify.Mutation, Verify.Variables>(
+                VERIFY_EMAIL,
+                {
+                    token: verificationToken,
+                    password: 'new password',
+                },
+            );
+            currentUserErrorGuard.assertErrorResult(verifyCustomerAccount);
+
+            expect(verifyCustomerAccount.message).toBe(`A password has already been set during registration`);
+            expect(verifyCustomerAccount.errorCode).toBe(ErrorCode.PASSWORD_ALREADY_SET_ERROR);
+        });
 
         it('verification succeeds with no password and correct token', async () => {
-            const a = 1;
-            const result = await shopClient.query<Verify.Mutation, Verify.Variables>(VERIFY_EMAIL, {
-                token: verificationToken,
-            });
+            const { verifyCustomerAccount } = await shopClient.query<Verify.Mutation, Verify.Variables>(
+                VERIFY_EMAIL,
+                {
+                    token: verificationToken,
+                },
+            );
+            currentUserErrorGuard.assertSuccess(verifyCustomerAccount);
 
-            expect(result.verifyCustomerAccount.user.identifier).toBe('test2@test.com');
+            expect(verifyCustomerAccount.identifier).toBe('test2@test.com');
             const { activeCustomer } = await shopClient.query<GetActiveCustomer.Query>(GET_ACTIVE_CUSTOMER);
         });
     });
@@ -388,58 +446,65 @@ describe('Shop auth & accounts', () => {
         });
 
         it('requestPasswordReset silently fails with invalid identifier', async () => {
-            const result = await shopClient.query<
+            const { requestPasswordReset } = await shopClient.query<
                 RequestPasswordReset.Mutation,
                 RequestPasswordReset.Variables
             >(REQUEST_PASSWORD_RESET, {
                 identifier: 'invalid-identifier',
             });
+            successErrorGuard.assertSuccess(requestPasswordReset);
 
             await waitForSendEmailFn();
-            expect(result.requestPasswordReset).toBe(true);
+            expect(requestPasswordReset.success).toBe(true);
             expect(sendEmailFn).not.toHaveBeenCalled();
             expect(passwordResetToken).not.toBeDefined();
         });
 
         it('requestPasswordReset sends reset token', async () => {
             const passwordResetTokenPromise = getPasswordResetTokenPromise();
-            const result = await shopClient.query<
+            const { requestPasswordReset } = await shopClient.query<
                 RequestPasswordReset.Mutation,
                 RequestPasswordReset.Variables
             >(REQUEST_PASSWORD_RESET, {
                 identifier: customer.emailAddress,
             });
+            successErrorGuard.assertSuccess(requestPasswordReset);
 
             passwordResetToken = await passwordResetTokenPromise;
 
-            expect(result.requestPasswordReset).toBe(true);
+            expect(requestPasswordReset.success).toBe(true);
             expect(sendEmailFn).toHaveBeenCalled();
             expect(passwordResetToken).toBeDefined();
         });
 
-        it(
-            'resetPassword fails with wrong token',
-            assertThrowsWithMessage(
-                () =>
-                    shopClient.query<ResetPassword.Mutation, ResetPassword.Variables>(RESET_PASSWORD, {
-                        password: 'newPassword',
-                        token: 'bad-token',
-                    }),
-                `Password reset token not recognized`,
-            ),
-        );
+        it('resetPassword returns error result with wrong token', async () => {
+            const { resetPassword } = await shopClient.query<ResetPassword.Mutation, ResetPassword.Variables>(
+                RESET_PASSWORD,
+                {
+                    password: 'newPassword',
+                    token: 'bad-token',
+                },
+            );
+            currentUserErrorGuard.assertErrorResult(resetPassword);
+
+            expect(resetPassword.message).toBe(`Password reset token not recognized`);
+            expect(resetPassword.errorCode).toBe(ErrorCode.PASSWORD_RESET_TOKEN_INVALID_ERROR);
+        });
 
         it('resetPassword works with valid token', async () => {
-            const result = await shopClient.query<ResetPassword.Mutation, ResetPassword.Variables>(
+            const { resetPassword } = await shopClient.query<ResetPassword.Mutation, ResetPassword.Variables>(
                 RESET_PASSWORD,
                 {
                     token: passwordResetToken,
                     password: 'newPassword',
                 },
             );
+            currentUserErrorGuard.assertSuccess(resetPassword);
+
+            expect(resetPassword.identifier).toBe(customer.emailAddress);
 
             const loginResult = await shopClient.asUserWithCredentials(customer.emailAddress, 'newPassword');
-            expect(loginResult.user.identifier).toBe(customer.emailAddress);
+            expect(loginResult.identifier).toBe(customer.emailAddress);
         });
 
         it('customer history for password reset', async () => {
@@ -500,41 +565,40 @@ describe('Shop auth & accounts', () => {
             }
         });
 
-        it('throws if password is incorrect', async () => {
-            try {
-                await shopClient.asUserWithCredentials(customer.emailAddress, PASSWORD);
-                await shopClient.query<
-                    RequestUpdateEmailAddress.Mutation,
-                    RequestUpdateEmailAddress.Variables
-                >(REQUEST_UPDATE_EMAIL_ADDRESS, {
-                    password: 'bad password',
-                    newEmailAddress: NEW_EMAIL_ADDRESS,
-                });
-                fail('should have thrown');
-            } catch (err) {
-                expect(getErrorCode(err)).toBe('UNAUTHORIZED');
-            }
+        it('return error result if password is incorrect', async () => {
+            await shopClient.asUserWithCredentials(customer.emailAddress, PASSWORD);
+            const { requestUpdateCustomerEmailAddress } = await shopClient.query<
+                RequestUpdateEmailAddress.Mutation,
+                RequestUpdateEmailAddress.Variables
+            >(REQUEST_UPDATE_EMAIL_ADDRESS, {
+                password: 'bad password',
+                newEmailAddress: NEW_EMAIL_ADDRESS,
+            });
+            successErrorGuard.assertErrorResult(requestUpdateCustomerEmailAddress);
+
+            expect(requestUpdateCustomerEmailAddress.message).toBe('The provided credentials are invalid');
+            expect(requestUpdateCustomerEmailAddress.errorCode).toBe(ErrorCode.INVALID_CREDENTIALS_ERROR);
         });
 
-        it(
-            'throws if email address already in use',
-            assertThrowsWithMessage(async () => {
-                await shopClient.asUserWithCredentials(customer.emailAddress, PASSWORD);
-                const result = await adminClient.query<GetCustomer.Query, GetCustomer.Variables>(
-                    GET_CUSTOMER,
-                    { id: 'T_2' },
-                );
-                const otherCustomer = result.customer!;
+        it('return error result email address already in use', async () => {
+            await shopClient.asUserWithCredentials(customer.emailAddress, PASSWORD);
+            const result = await adminClient.query<GetCustomer.Query, GetCustomer.Variables>(GET_CUSTOMER, {
+                id: 'T_2',
+            });
+            const otherCustomer = result.customer!;
+
+            const { requestUpdateCustomerEmailAddress } = await shopClient.query<
+                RequestUpdateEmailAddress.Mutation,
+                RequestUpdateEmailAddress.Variables
+            >(REQUEST_UPDATE_EMAIL_ADDRESS, {
+                password: PASSWORD,
+                newEmailAddress: otherCustomer.emailAddress,
+            });
+            successErrorGuard.assertErrorResult(requestUpdateCustomerEmailAddress);
 
-                await shopClient.query<
-                    RequestUpdateEmailAddress.Mutation,
-                    RequestUpdateEmailAddress.Variables
-                >(REQUEST_UPDATE_EMAIL_ADDRESS, {
-                    password: PASSWORD,
-                    newEmailAddress: otherCustomer.emailAddress,
-                });
-            }, 'This email address is not available'),
-        );
+            expect(requestUpdateCustomerEmailAddress.message).toBe('The email address is not available.');
+            expect(requestUpdateCustomerEmailAddress.errorCode).toBe(ErrorCode.EMAIL_ADDRESS_CONFLICT_ERROR);
+        });
 
         it('triggers event with token', async () => {
             await shopClient.asUserWithCredentials(customer.emailAddress, PASSWORD);
@@ -556,30 +620,32 @@ describe('Shop auth & accounts', () => {
         });
 
         it('cannot login with new email address before verification', async () => {
-            try {
-                await shopClient.asUserWithCredentials(NEW_EMAIL_ADDRESS, PASSWORD);
-                fail('should have thrown');
-            } catch (err) {
-                expect(getErrorCode(err)).toBe('UNAUTHORIZED');
-            }
+            const result = await shopClient.asUserWithCredentials(NEW_EMAIL_ADDRESS, PASSWORD);
+
+            expect(result.errorCode).toBe(ErrorCode.INVALID_CREDENTIALS_ERROR);
         });
 
-        it(
-            'throws with bad token',
-            assertThrowsWithMessage(async () => {
-                await shopClient.query<UpdateEmailAddress.Mutation, UpdateEmailAddress.Variables>(
-                    UPDATE_EMAIL_ADDRESS,
-                    { token: 'bad token' },
-                );
-            }, 'Identifier change token not recognized'),
-        );
+        it('return error result for bad token', async () => {
+            const { updateCustomerEmailAddress } = await shopClient.query<
+                UpdateEmailAddress.Mutation,
+                UpdateEmailAddress.Variables
+            >(UPDATE_EMAIL_ADDRESS, { token: 'bad token' });
+            successErrorGuard.assertErrorResult(updateCustomerEmailAddress);
 
-        it('verify the new email address', async () => {
-            const result = await shopClient.query<UpdateEmailAddress.Mutation, UpdateEmailAddress.Variables>(
-                UPDATE_EMAIL_ADDRESS,
-                { token: emailUpdateToken },
+            expect(updateCustomerEmailAddress.message).toBe('Identifier change token not recognized');
+            expect(updateCustomerEmailAddress.errorCode).toBe(
+                ErrorCode.IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR,
             );
-            expect(result.updateCustomerEmailAddress).toBe(true);
+        });
+
+        it('verify the new email address', async () => {
+            const { updateCustomerEmailAddress } = await shopClient.query<
+                UpdateEmailAddress.Mutation,
+                UpdateEmailAddress.Variables
+            >(UPDATE_EMAIL_ADDRESS, { token: emailUpdateToken });
+            successErrorGuard.assertSuccess(updateCustomerEmailAddress);
+
+            expect(updateCustomerEmailAddress.success).toBe(true);
 
             expect(sendEmailFn).toHaveBeenCalled();
             expect(sendEmailFn.mock.calls[0][0] instanceof IdentifierChangeEvent).toBe(true);
@@ -593,12 +659,9 @@ describe('Shop auth & accounts', () => {
         });
 
         it('cannot login with old email address after verification', async () => {
-            try {
-                await shopClient.asUserWithCredentials(customer.emailAddress, PASSWORD);
-                fail('should have thrown');
-            } catch (err) {
-                expect(getErrorCode(err)).toBe('UNAUTHORIZED');
-            }
+            const result = await shopClient.asUserWithCredentials(customer.emailAddress, PASSWORD);
+
+            expect(result.errorCode).toBe(ErrorCode.INVALID_CREDENTIALS_ERROR);
         });
 
         it('customer history for email update', async () => {
@@ -699,7 +762,7 @@ describe('Shop auth & accounts', () => {
      * A "sleep" function which allows the sendEmailFn time to get called.
      */
     function waitForSendEmailFn() {
-        return new Promise((resolve) => setTimeout(resolve, 10));
+        return new Promise(resolve => setTimeout(resolve, 10));
     }
 });
 
@@ -730,64 +793,79 @@ describe('Expiring tokens', () => {
         await server.destroy();
     });
 
-    it(
-        'attempting to verify after token has expired throws',
-        assertThrowsWithMessage(async () => {
-            const verificationTokenPromise = getVerificationTokenPromise();
-            const input: RegisterCustomerInput = {
-                firstName: 'Barry',
-                lastName: 'Wallace',
-                emailAddress: 'barry.wallace@test.com',
-            };
-            const result = await shopClient.query<Register.Mutation, Register.Variables>(REGISTER_ACCOUNT, {
+    it('attempting to verify after token has expired throws', async () => {
+        const verificationTokenPromise = getVerificationTokenPromise();
+        const input: RegisterCustomerInput = {
+            firstName: 'Barry',
+            lastName: 'Wallace',
+            emailAddress: 'barry.wallace@test.com',
+        };
+        const { registerCustomerAccount } = await shopClient.query<Register.Mutation, Register.Variables>(
+            REGISTER_ACCOUNT,
+            {
                 input,
-            });
+            },
+        );
+        successErrorGuard.assertSuccess(registerCustomerAccount);
 
-            const verificationToken = await verificationTokenPromise;
+        const verificationToken = await verificationTokenPromise;
 
-            expect(result.registerCustomerAccount).toBe(true);
-            expect(sendEmailFn).toHaveBeenCalledTimes(1);
-            expect(verificationToken).toBeDefined();
+        expect(registerCustomerAccount.success).toBe(true);
+        expect(sendEmailFn).toHaveBeenCalledTimes(1);
+        expect(verificationToken).toBeDefined();
 
-            await new Promise((resolve) => setTimeout(resolve, 3));
+        await new Promise(resolve => setTimeout(resolve, 3));
 
-            return shopClient.query(VERIFY_EMAIL, {
+        const { verifyCustomerAccount } = await shopClient.query<Verify.Mutation, Verify.Variables>(
+            VERIFY_EMAIL,
+            {
                 password: 'test',
                 token: verificationToken,
-            });
-        }, `Verification token has expired. Use refreshCustomerVerification to send a new token.`),
-    );
+            },
+        );
+        currentUserErrorGuard.assertErrorResult(verifyCustomerAccount);
 
-    it(
-        'attempting to reset password after token has expired throws',
-        assertThrowsWithMessage(async () => {
-            const { customer } = await adminClient.query<GetCustomer.Query, GetCustomer.Variables>(
-                GET_CUSTOMER,
-                { id: 'T_1' },
-            );
+        expect(verifyCustomerAccount.message).toBe(
+            `Verification token has expired. Use refreshCustomerVerification to send a new token.`,
+        );
+        expect(verifyCustomerAccount.errorCode).toBe(ErrorCode.VERIFICATION_TOKEN_EXPIRED_ERROR);
+    });
 
-            const passwordResetTokenPromise = getPasswordResetTokenPromise();
-            const result = await shopClient.query<
-                RequestPasswordReset.Mutation,
-                RequestPasswordReset.Variables
-            >(REQUEST_PASSWORD_RESET, {
-                identifier: customer!.emailAddress,
-            });
+    it('attempting to reset password after token has expired returns error result', async () => {
+        const { customer } = await adminClient.query<GetCustomer.Query, GetCustomer.Variables>(GET_CUSTOMER, {
+            id: 'T_1',
+        });
 
-            const passwordResetToken = await passwordResetTokenPromise;
+        const passwordResetTokenPromise = getPasswordResetTokenPromise();
+        const { requestPasswordReset } = await shopClient.query<
+            RequestPasswordReset.Mutation,
+            RequestPasswordReset.Variables
+        >(REQUEST_PASSWORD_RESET, {
+            identifier: customer!.emailAddress,
+        });
+        successErrorGuard.assertSuccess(requestPasswordReset);
 
-            expect(result.requestPasswordReset).toBe(true);
-            expect(sendEmailFn).toHaveBeenCalledTimes(1);
-            expect(passwordResetToken).toBeDefined();
+        const passwordResetToken = await passwordResetTokenPromise;
+
+        expect(requestPasswordReset.success).toBe(true);
+        expect(sendEmailFn).toHaveBeenCalledTimes(1);
+        expect(passwordResetToken).toBeDefined();
 
-            await new Promise((resolve) => setTimeout(resolve, 3));
+        await new Promise(resolve => setTimeout(resolve, 3));
 
-            return shopClient.query<ResetPassword.Mutation, ResetPassword.Variables>(RESET_PASSWORD, {
+        const { resetPassword } = await shopClient.query<ResetPassword.Mutation, ResetPassword.Variables>(
+            RESET_PASSWORD,
+            {
                 password: 'test',
                 token: passwordResetToken,
-            });
-        }, `Password reset token has expired.`),
-    );
+            },
+        );
+
+        currentUserErrorGuard.assertErrorResult(resetPassword);
+
+        expect(resetPassword.message).toBe(`Password reset token has expired`);
+        expect(resetPassword.errorCode).toBe(ErrorCode.PASSWORD_RESET_TOKEN_EXPIRED_ERROR);
+    });
 });
 
 describe('Registration without email verification', () => {
@@ -817,19 +895,23 @@ describe('Registration without email verification', () => {
         await server.destroy();
     });
 
-    it(
-        'errors if no password is provided',
-        assertThrowsWithMessage(async () => {
-            const input: RegisterCustomerInput = {
-                firstName: 'Glen',
-                lastName: 'Beardsley',
-                emailAddress: userEmailAddress,
-            };
-            const result = await shopClient.query<Register.Mutation, Register.Variables>(REGISTER_ACCOUNT, {
+    it('Returns error result if no password is provided', async () => {
+        const input: RegisterCustomerInput = {
+            firstName: 'Glen',
+            lastName: 'Beardsley',
+            emailAddress: userEmailAddress,
+        };
+        const { registerCustomerAccount } = await shopClient.query<Register.Mutation, Register.Variables>(
+            REGISTER_ACCOUNT,
+            {
                 input,
-            });
-        }, 'A password must be provided when `authOptions.requireVerification` is set to "false"'),
-    );
+            },
+        );
+        successErrorGuard.assertErrorResult(registerCustomerAccount);
+
+        expect(registerCustomerAccount.message).toBe('A password must be provided.');
+        expect(registerCustomerAccount.errorCode).toBe(ErrorCode.MISSING_PASSWORD_ERROR);
+    });
 
     it('register a new account with password', async () => {
         const input: RegisterCustomerInput = {
@@ -838,11 +920,15 @@ describe('Registration without email verification', () => {
             emailAddress: userEmailAddress,
             password: 'test',
         };
-        const result = await shopClient.query<Register.Mutation, Register.Variables>(REGISTER_ACCOUNT, {
-            input,
-        });
+        const { registerCustomerAccount } = await shopClient.query<Register.Mutation, Register.Variables>(
+            REGISTER_ACCOUNT,
+            {
+                input,
+            },
+        );
+        successErrorGuard.assertSuccess(registerCustomerAccount);
 
-        expect(result.registerCustomerAccount).toBe(true);
+        expect(registerCustomerAccount.success).toBe(true);
         expect(sendEmailFn).not.toHaveBeenCalled();
     });
 
@@ -904,8 +990,9 @@ describe('Updating email address without email verification', () => {
             password: 'test',
             newEmailAddress: NEW_EMAIL_ADDRESS,
         });
+        successErrorGuard.assertSuccess(requestUpdateCustomerEmailAddress);
 
-        expect(requestUpdateCustomerEmailAddress).toBe(true);
+        expect(requestUpdateCustomerEmailAddress.success).toBe(true);
         expect(sendEmailFn).toHaveBeenCalledTimes(1);
         expect(sendEmailFn.mock.calls[0][0] instanceof IdentifierChangeEvent).toBe(true);
 
@@ -915,7 +1002,7 @@ describe('Updating email address without email verification', () => {
 });
 
 function getVerificationTokenPromise(): Promise<string> {
-    return new Promise<any>((resolve) => {
+    return new Promise<any>(resolve => {
         sendEmailFn.mockImplementation((event: AccountRegistrationEvent) => {
             resolve(event.user.getNativeAuthenticationMethod().verificationToken);
         });
@@ -923,7 +1010,7 @@ function getVerificationTokenPromise(): Promise<string> {
 }
 
 function getPasswordResetTokenPromise(): Promise<string> {
-    return new Promise<any>((resolve) => {
+    return new Promise<any>(resolve => {
         sendEmailFn.mockImplementation((event: PasswordResetEvent) => {
             resolve(event.user.getNativeAuthenticationMethod().passwordResetToken);
         });
@@ -934,7 +1021,7 @@ function getEmailUpdateTokenPromise(): Promise<{
     identifierChangeToken: string | null;
     pendingIdentifier: string | null;
 }> {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
         sendEmailFn.mockImplementation((event: IdentifierChangeRequestEvent) => {
             resolve(
                 pick(event.user.getNativeAuthenticationMethod(), [

packages/core/e2e/shop-customer.e2e-spec.ts

@@ -1,12 +1,12 @@
 /* tslint:disable:no-non-null-assertion */
 import { pick } from '@vendure/common/lib/pick';
-import { createTestEnvironment } from '@vendure/testing';
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
 import gql from 'graphql-tag';
 import path from 'path';
 import { skip } from 'rxjs/operators';
 
 import { initialData } from '../../../e2e-common/e2e-initial-data';
-import { testConfig, TEST_SETUP_TIMEOUT_MS } from '../../../e2e-common/test-config';
+import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-config';
 
 import {
     AttemptLogin,
@@ -19,6 +19,7 @@ import {
     CreateAddressInput,
     CreateAddressShop,
     DeleteAddressShop,
+    ErrorCode,
     UpdateAddressInput,
     UpdateAddressShop,
     UpdateCustomer,
@@ -39,6 +40,10 @@ describe('Shop customers', () => {
     const { server, adminClient, shopClient } = createTestEnvironment(testConfig);
     let customer: GetCustomer.Customer;
 
+    const successErrorGuard: ErrorResultGuard<{ success: boolean }> = createErrorResultGuard<{
+        success: boolean;
+    }>(input => input.success != null);
+
     beforeAll(async () => {
         await server.init({
             initialData,
@@ -252,12 +257,12 @@ describe('Shop customers', () => {
         );
 
         it('deleteCustomerAddress works', async () => {
-            const result = await shopClient.query<DeleteAddressShop.Mutation, DeleteAddressShop.Variables>(
-                DELETE_ADDRESS,
-                { id: 'T_3' },
-            );
+            const { deleteCustomerAddress } = await shopClient.query<
+                DeleteAddressShop.Mutation,
+                DeleteAddressShop.Variables
+            >(DELETE_ADDRESS, { id: 'T_3' });
 
-            expect(result.deleteCustomerAddress).toBe(true);
+            expect(deleteCustomerAddress.success).toBe(true);
         });
 
         it('customer history for CUSTOMER_ADDRESS_DELETED', async () => {
@@ -286,27 +291,32 @@ describe('Shop customers', () => {
             }, 'You are not currently authorized to perform this action'),
         );
 
-        it(
-            'updatePassword fails with incorrect current password',
-            assertThrowsWithMessage(async () => {
-                await shopClient.query<UpdatePassword.Mutation, UpdatePassword.Variables>(UPDATE_PASSWORD, {
-                    old: 'wrong',
-                    new: 'test2',
-                });
-            }, 'The credentials did not match. Please check and try again'),
-        );
+        it('updatePassword return error result with incorrect current password', async () => {
+            const { updateCustomerPassword } = await shopClient.query<
+                UpdatePassword.Mutation,
+                UpdatePassword.Variables
+            >(UPDATE_PASSWORD, {
+                old: 'wrong',
+                new: 'test2',
+            });
+            successErrorGuard.assertErrorResult(updateCustomerPassword);
+
+            expect(updateCustomerPassword.message).toBe('The provided credentials are invalid');
+            expect(updateCustomerPassword.errorCode).toBe(ErrorCode.INVALID_CREDENTIALS_ERROR);
+        });
 
         it('updatePassword works', async () => {
-            const response = await shopClient.query<UpdatePassword.Mutation, UpdatePassword.Variables>(
-                UPDATE_PASSWORD,
-                { old: 'test', new: 'test2' },
-            );
+            const { updateCustomerPassword } = await shopClient.query<
+                UpdatePassword.Mutation,
+                UpdatePassword.Variables
+            >(UPDATE_PASSWORD, { old: 'test', new: 'test2' });
+            successErrorGuard.assertSuccess(updateCustomerPassword);
 
-            expect(response.updateCustomerPassword).toBe(true);
+            expect(updateCustomerPassword.success).toBe(true);
 
             // Log out and log in with new password
             const loginResult = await shopClient.asUserWithCredentials(customer.emailAddress, 'test2');
-            expect(loginResult.user.identifier).toBe(customer.emailAddress);
+            expect(loginResult.identifier).toBe(customer.emailAddress);
         });
 
         it('customer history for CUSTOMER_PASSWORD_UPDATED', async () => {

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

@@ -1,6 +1,7 @@
 /* tslint:disable:no-non-null-assertion */
+import { pick } from '@vendure/common/lib/pick';
 import { mergeConfig } from '@vendure/core';
-import { createTestEnvironment } from '@vendure/testing';
+import { createErrorResultGuard, createTestEnvironment, ErrorResultGuard } from '@vendure/testing';
 import gql from 'graphql-tag';
 import path from 'path';
 
@@ -21,24 +22,32 @@ import {
     UpdateCountry,
 } from './graphql/generated-e2e-admin-types';
 import {
+    ActiveOrderCustomer,
+    ActiveOrderCustomerFragment,
     AddItemToOrder,
     AddPaymentToOrder,
     AdjustItemQuantity,
+    ErrorCode,
     GetActiveOrder,
     GetActiveOrderPayments,
+    GetActiveOrderWithPayments,
     GetAvailableCountries,
     GetCustomerAddresses,
     GetCustomerOrders,
     GetNextOrderStates,
     GetOrderByCode,
     GetShippingMethods,
+    PaymentDeclinedError,
     RemoveAllOrderLines,
     RemoveItemFromOrder,
     SetBillingAddress,
     SetCustomerForOrder,
     SetShippingAddress,
     SetShippingMethod,
+    TestOrderFragmentFragment,
+    TestOrderWithPaymentsFragment,
     TransitionToState,
+    UpdatedOrderFragment,
 } from './graphql/generated-e2e-shop-types';
 import {
     ATTEMPT_LOGIN,
@@ -55,6 +64,7 @@ import {
     GET_ACTIVE_ORDER_ADDRESSES,
     GET_ACTIVE_ORDER_ORDERS,
     GET_ACTIVE_ORDER_PAYMENTS,
+    GET_ACTIVE_ORDER_WITH_PAYMENTS,
     GET_AVAILABLE_COUNTRIES,
     GET_ELIGIBLE_SHIPPING_METHODS,
     GET_NEXT_STATES,
@@ -65,6 +75,7 @@ import {
     SET_CUSTOMER,
     SET_SHIPPING_ADDRESS,
     SET_SHIPPING_METHOD,
+    TEST_ORDER_FRAGMENT,
     TRANSITION_TO_STATE,
 } from './graphql/shop-definitions';
 import { assertThrowsWithMessage } from './utils/assert-throws-with-message';
@@ -88,6 +99,15 @@ describe('Shop orders', () => {
         }),
     );
 
+    type OrderSuccessResult =
+        | UpdatedOrderFragment
+        | TestOrderFragmentFragment
+        | TestOrderWithPaymentsFragment
+        | ActiveOrderCustomerFragment;
+    const orderResultGuard: ErrorResultGuard<OrderSuccessResult> = createErrorResultGuard<OrderSuccessResult>(
+        input => !!input.lines,
+    );
+
     beforeAll(async () => {
         await server.init({
             initialData,
@@ -144,6 +164,7 @@ describe('Shop orders', () => {
                 quantity: 1,
             });
 
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.lines.length).toBe(1);
             expect(addItemToOrder!.lines[0].quantity).toBe(1);
             expect(addItemToOrder!.lines[0].productVariant.id).toBe('T_1');
@@ -164,17 +185,19 @@ describe('Shop orders', () => {
             ),
         );
 
-        it(
-            'addItemToOrder errors with a negative quantity',
-            assertThrowsWithMessage(
-                () =>
-                    shopClient.query<AddItemToOrder.Mutation, AddItemToOrder.Variables>(ADD_ITEM_TO_ORDER, {
-                        productVariantId: 'T_999',
-                        quantity: -3,
-                    }),
-                `-3 is not a valid quantity for an OrderItem`,
-            ),
-        );
+        it('addItemToOrder errors with a negative quantity', async () => {
+            const { addItemToOrder } = await shopClient.query<
+                AddItemToOrder.Mutation,
+                AddItemToOrder.Variables
+            >(ADD_ITEM_TO_ORDER, {
+                productVariantId: 'T_999',
+                quantity: -3,
+            });
+
+            orderResultGuard.assertErrorResult(addItemToOrder);
+            expect(addItemToOrder.message).toEqual(`The quantity for an OrderItem cannot be negative`);
+            expect(addItemToOrder.errorCode).toEqual(ErrorCode.NEGATIVE_QUANTITY_ERROR);
+        });
 
         it('addItemToOrder with an existing productVariantId adds quantity to the existing OrderLine', async () => {
             const { addItemToOrder } = await shopClient.query<
@@ -184,20 +207,26 @@ describe('Shop orders', () => {
                 productVariantId: 'T_1',
                 quantity: 2,
             });
-
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.lines.length).toBe(1);
             expect(addItemToOrder!.lines[0].quantity).toBe(3);
         });
 
-        it(
-            'addItemToOrder errors when going beyond orderItemsLimit',
-            assertThrowsWithMessage(async () => {
-                await shopClient.query<AddItemToOrder.Mutation, AddItemToOrder.Variables>(ADD_ITEM_TO_ORDER, {
-                    productVariantId: 'T_1',
-                    quantity: 100,
-                });
-            }, 'Cannot add items. An order may consist of a maximum of 99 items'),
-        );
+        it('addItemToOrder errors when going beyond orderItemsLimit', async () => {
+            const { addItemToOrder } = await shopClient.query<
+                AddItemToOrder.Mutation,
+                AddItemToOrder.Variables
+            >(ADD_ITEM_TO_ORDER, {
+                productVariantId: 'T_1',
+                quantity: 100,
+            });
+
+            orderResultGuard.assertErrorResult(addItemToOrder);
+            expect(addItemToOrder.message).toBe(
+                'Cannot add items. An order may consist of a maximum of 99 items',
+            );
+            expect(addItemToOrder.errorCode).toBe(ErrorCode.ORDER_LIMIT_ERROR);
+        });
 
         it('adjustOrderLine adjusts the quantity', async () => {
             const { adjustOrderLine } = await shopClient.query<
@@ -207,7 +236,7 @@ describe('Shop orders', () => {
                 orderLineId: firstOrderLineId,
                 quantity: 50,
             });
-
+            orderResultGuard.assertSuccess(adjustOrderLine);
             expect(adjustOrderLine!.lines.length).toBe(1);
             expect(adjustOrderLine!.lines[0].quantity).toBe(50);
         });
@@ -220,6 +249,7 @@ describe('Shop orders', () => {
                 productVariantId: 'T_3',
                 quantity: 3,
             });
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.lines.length).toBe(2);
             expect(addItemToOrder!.lines.map(i => i.productVariant.id)).toEqual(['T_1', 'T_3']);
 
@@ -230,38 +260,38 @@ describe('Shop orders', () => {
                 orderLineId: addItemToOrder?.lines[1].id!,
                 quantity: 0,
             });
-
+            orderResultGuard.assertSuccess(adjustOrderLine);
             expect(adjustOrderLine!.lines.length).toBe(1);
             expect(adjustOrderLine!.lines.map(i => i.productVariant.id)).toEqual(['T_1']);
         });
 
-        it(
-            'adjustOrderLine errors when going beyond orderItemsLimit',
-            assertThrowsWithMessage(async () => {
-                await shopClient.query<AdjustItemQuantity.Mutation, AdjustItemQuantity.Variables>(
-                    ADJUST_ITEM_QUANTITY,
-                    {
-                        orderLineId: firstOrderLineId,
-                        quantity: 100,
-                    },
-                );
-            }, 'Cannot add items. An order may consist of a maximum of 99 items'),
-        );
+        it('adjustOrderLine errors when going beyond orderItemsLimit', async () => {
+            const { adjustOrderLine } = await shopClient.query<
+                AdjustItemQuantity.Mutation,
+                AdjustItemQuantity.Variables
+            >(ADJUST_ITEM_QUANTITY, {
+                orderLineId: firstOrderLineId,
+                quantity: 100,
+            });
+            orderResultGuard.assertErrorResult(adjustOrderLine);
+            expect(adjustOrderLine.message).toBe(
+                'Cannot add items. An order may consist of a maximum of 99 items',
+            );
+            expect(adjustOrderLine.errorCode).toBe(ErrorCode.ORDER_LIMIT_ERROR);
+        });
 
-        it(
-            'adjustOrderLine errors with a negative quantity',
-            assertThrowsWithMessage(
-                () =>
-                    shopClient.query<AdjustItemQuantity.Mutation, AdjustItemQuantity.Variables>(
-                        ADJUST_ITEM_QUANTITY,
-                        {
-                            orderLineId: firstOrderLineId,
-                            quantity: -3,
-                        },
-                    ),
-                `-3 is not a valid quantity for an OrderItem`,
-            ),
-        );
+        it('adjustOrderLine errors with a negative quantity', async () => {
+            const { adjustOrderLine } = await shopClient.query<
+                AdjustItemQuantity.Mutation,
+                AdjustItemQuantity.Variables
+            >(ADJUST_ITEM_QUANTITY, {
+                orderLineId: firstOrderLineId,
+                quantity: -3,
+            });
+            orderResultGuard.assertErrorResult(adjustOrderLine);
+            expect(adjustOrderLine.message).toBe('The quantity for an OrderItem cannot be negative');
+            expect(adjustOrderLine.errorCode).toBe(ErrorCode.NEGATIVE_QUANTITY_ERROR);
+        });
 
         it(
             'adjustOrderLine errors with an invalid orderLineId',
@@ -286,6 +316,7 @@ describe('Shop orders', () => {
                 productVariantId: 'T_3',
                 quantity: 3,
             });
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.lines.length).toBe(2);
             expect(addItemToOrder!.lines.map(i => i.productVariant.id)).toEqual(['T_1', 'T_3']);
 
@@ -295,6 +326,7 @@ describe('Shop orders', () => {
             >(REMOVE_ITEM_FROM_ORDER, {
                 orderLineId: firstOrderLineId,
             });
+            orderResultGuard.assertSuccess(removeOrderLine);
             expect(removeOrderLine!.lines.length).toBe(1);
             expect(removeOrderLine!.lines.map(i => i.productVariant.id)).toEqual(['T_3']);
         });
@@ -319,29 +351,50 @@ describe('Shop orders', () => {
             expect(result.nextOrderStates).toEqual(['ArrangingPayment', 'Cancelled']);
         });
 
-        it(
-            'transitionOrderToState throws for an invalid state',
-            assertThrowsWithMessage(
-                () =>
-                    shopClient.query<TransitionToState.Mutation, TransitionToState.Variables>(
-                        TRANSITION_TO_STATE,
-                        { state: 'Completed' },
-                    ),
+        it('transitionOrderToState returns error result for invalid state', async () => {
+            const { transitionOrderToState } = await shopClient.query<
+                TransitionToState.Mutation,
+                TransitionToState.Variables
+            >(TRANSITION_TO_STATE, { state: 'Completed' });
+            orderResultGuard.assertErrorResult(transitionOrderToState);
+
+            expect(transitionOrderToState!.message).toBe(
                 `Cannot transition Order from "AddingItems" to "Completed"`,
-            ),
-        );
+            );
+            expect(transitionOrderToState!.errorCode).toBe(ErrorCode.ORDER_STATE_TRANSITION_ERROR);
+        });
 
-        it(
-            'attempting to transition to ArrangingPayment throws when Order has no Customer',
-            assertThrowsWithMessage(
-                () =>
-                    shopClient.query<TransitionToState.Mutation, TransitionToState.Variables>(
-                        TRANSITION_TO_STATE,
-                        { state: 'ArrangingPayment' },
-                    ),
+        it('attempting to transition to ArrangingPayment returns error result when Order has no Customer', async () => {
+            const { transitionOrderToState } = await shopClient.query<
+                TransitionToState.Mutation,
+                TransitionToState.Variables
+            >(TRANSITION_TO_STATE, { state: 'ArrangingPayment' });
+            orderResultGuard.assertErrorResult(transitionOrderToState);
+
+            expect(transitionOrderToState!.transitionError).toBe(
                 `Cannot transition Order to the "ArrangingPayment" state without Customer details`,
-            ),
-        );
+            );
+            expect(transitionOrderToState!.errorCode).toBe(ErrorCode.ORDER_STATE_TRANSITION_ERROR);
+        });
+
+        it('setCustomerForOrder returns error result on email address conflict', async () => {
+            const { customers } = await adminClient.query<GetCustomerList.Query>(GET_CUSTOMER_LIST);
+
+            const { setCustomerForOrder } = await shopClient.query<
+                SetCustomerForOrder.Mutation,
+                SetCustomerForOrder.Variables
+            >(SET_CUSTOMER, {
+                input: {
+                    emailAddress: customers.items[0].emailAddress,
+                    firstName: 'Test',
+                    lastName: 'Person',
+                },
+            });
+            orderResultGuard.assertErrorResult(setCustomerForOrder);
+
+            expect(setCustomerForOrder!.message).toBe('The email address is not available.');
+            expect(setCustomerForOrder!.errorCode).toBe(ErrorCode.EMAIL_ADDRESS_CONFLICT_ERROR);
+        });
 
         it('setCustomerForOrder creates a new Customer and associates it with the Order', async () => {
             const { setCustomerForOrder } = await shopClient.query<
@@ -354,6 +407,7 @@ describe('Shop orders', () => {
                     lastName: 'Person',
                 },
             });
+            orderResultGuard.assertSuccess(setCustomerForOrder);
 
             const customer = setCustomerForOrder!.customer!;
             expect(customer.firstName).toBe('Test');
@@ -373,6 +427,7 @@ describe('Shop orders', () => {
                     lastName: 'Person',
                 },
             });
+            orderResultGuard.assertSuccess(setCustomerForOrder);
 
             const customer = setCustomerForOrder!.customer!;
             expect(customer.firstName).toBe('Changed');
@@ -456,12 +511,16 @@ describe('Shop orders', () => {
         });
 
         it('can transition to ArrangingPayment once Customer has been set', async () => {
-            const result = await shopClient.query<TransitionToState.Mutation, TransitionToState.Variables>(
-                TRANSITION_TO_STATE,
-                { state: 'ArrangingPayment' },
-            );
-
-            expect(result.transitionOrderToState).toEqual({ id: 'T_1', state: 'ArrangingPayment' });
+            const { transitionOrderToState } = await shopClient.query<
+                TransitionToState.Mutation,
+                TransitionToState.Variables
+            >(TRANSITION_TO_STATE, { state: 'ArrangingPayment' });
+            orderResultGuard.assertSuccess(transitionOrderToState);
+
+            expect(pick(transitionOrderToState, ['id', 'state'])).toEqual({
+                id: 'T_1',
+                state: 'ArrangingPayment',
+            });
         });
 
         it('adds a successful payment and transitions Order state', async () => {
@@ -474,6 +533,7 @@ describe('Shop orders', () => {
                     metadata: {},
                 },
             });
+            orderResultGuard.assertSuccess(addPaymentToOrder);
 
             const payment = addPaymentToOrder!.payments![0];
             expect(addPaymentToOrder!.state).toBe('PaymentSettled');
@@ -505,7 +565,7 @@ describe('Shop orders', () => {
 
     describe('ordering as authenticated user', () => {
         let firstOrderLineId: string;
-        let activeOrder: AddItemToOrder.AddItemToOrder;
+        let activeOrder: UpdatedOrderFragment;
         let authenticatedUserEmailAddress: string;
         let customers: GetCustomerList.Items[];
         const password = 'test';
@@ -538,7 +598,7 @@ describe('Shop orders', () => {
                 productVariantId: 'T_1',
                 quantity: 1,
             });
-
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.lines.length).toBe(1);
             expect(addItemToOrder!.lines[0].quantity).toBe(1);
             expect(addItemToOrder!.lines[0].productVariant.id).toBe('T_1');
@@ -568,7 +628,7 @@ describe('Shop orders', () => {
                 productVariantId: 'T_1',
                 quantity: 2,
             });
-
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.lines.length).toBe(1);
             expect(addItemToOrder!.lines[0].quantity).toBe(3);
         });
@@ -581,7 +641,7 @@ describe('Shop orders', () => {
                 orderLineId: firstOrderLineId,
                 quantity: 50,
             });
-
+            orderResultGuard.assertSuccess(adjustOrderLine);
             expect(adjustOrderLine!.lines.length).toBe(1);
             expect(adjustOrderLine!.lines[0].quantity).toBe(50);
         });
@@ -594,6 +654,7 @@ describe('Shop orders', () => {
                 productVariantId: 'T_3',
                 quantity: 3,
             });
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.lines.length).toBe(2);
             expect(addItemToOrder!.lines.map(i => i.productVariant.id)).toEqual(['T_1', 'T_3']);
 
@@ -603,6 +664,7 @@ describe('Shop orders', () => {
             >(REMOVE_ITEM_FROM_ORDER, {
                 orderLineId: firstOrderLineId,
             });
+            orderResultGuard.assertSuccess(removeOrderLine);
             expect(removeOrderLine!.lines.length).toBe(1);
             expect(removeOrderLine!.lines.map(i => i.productVariant.id)).toEqual(['T_3']);
         });
@@ -623,21 +685,24 @@ describe('Shop orders', () => {
             expect(result2.activeOrder!.id).toBe(activeOrder.id);
         });
 
-        it(
-            'cannot setCustomerForOrder when already logged in',
-            assertThrowsWithMessage(async () => {
-                await shopClient.query<SetCustomerForOrder.Mutation, SetCustomerForOrder.Variables>(
-                    SET_CUSTOMER,
-                    {
-                        input: {
-                            emailAddress: 'newperson@email.com',
-                            firstName: 'New',
-                            lastName: 'Person',
-                        },
-                    },
-                );
-            }, 'Cannot set a Customer for the Order when already logged in'),
-        );
+        it('cannot setCustomerForOrder when already logged in', async () => {
+            const { setCustomerForOrder } = await shopClient.query<
+                SetCustomerForOrder.Mutation,
+                SetCustomerForOrder.Variables
+            >(SET_CUSTOMER, {
+                input: {
+                    emailAddress: 'newperson@email.com',
+                    firstName: 'New',
+                    lastName: 'Person',
+                },
+            });
+            orderResultGuard.assertErrorResult(setCustomerForOrder);
+
+            expect(setCustomerForOrder!.message).toBe(
+                'Cannot set a Customer for the Order when already logged in',
+            );
+            expect(setCustomerForOrder!.errorCode).toBe(ErrorCode.ALREADY_LOGGED_IN_ERROR);
+        });
 
         describe('shipping', () => {
             let shippingMethods: GetShippingMethods.EligibleShippingMethods[];
@@ -738,7 +803,7 @@ describe('Shop orders', () => {
                     orderLineId: activeOrder.lines[0].id,
                     quantity: 10,
                 });
-
+                orderResultGuard.assertSuccess(adjustOrderLine);
                 expect(adjustOrderLine!.shipping).toBe(shippingMethods[1].price);
                 expect(adjustOrderLine!.shippingMethod!.id).toBe(shippingMethods[1].id);
                 expect(adjustOrderLine!.shippingMethod!.description).toBe(shippingMethods[1].description);
@@ -746,93 +811,110 @@ describe('Shop orders', () => {
         });
 
         describe('payment', () => {
-            it(
-                'attempting add a Payment throws error when in AddingItems state',
-                assertThrowsWithMessage(
-                    () =>
-                        shopClient.query<AddPaymentToOrder.Mutation, AddPaymentToOrder.Variables>(
-                            ADD_PAYMENT,
-                            {
-                                input: {
-                                    method: testSuccessfulPaymentMethod.code,
-                                    metadata: {},
-                                },
-                            },
-                        ),
+            it('attempting add a Payment returns error result when in AddingItems state', async () => {
+                const { addPaymentToOrder } = await shopClient.query<
+                    AddPaymentToOrder.Mutation,
+                    AddPaymentToOrder.Variables
+                >(ADD_PAYMENT, {
+                    input: {
+                        method: testSuccessfulPaymentMethod.code,
+                        metadata: {},
+                    },
+                });
+
+                orderResultGuard.assertErrorResult(addPaymentToOrder);
+                expect(addPaymentToOrder!.message).toBe(
                     `A Payment may only be added when Order is in "ArrangingPayment" state`,
-                ),
-            );
+                );
+                expect(addPaymentToOrder!.errorCode).toBe(ErrorCode.ORDER_PAYMENT_STATE_ERROR);
+            });
 
             it('transitions to the ArrangingPayment state', async () => {
-                const result = await shopClient.query<
+                const { transitionOrderToState } = await shopClient.query<
                     TransitionToState.Mutation,
                     TransitionToState.Variables
                 >(TRANSITION_TO_STATE, { state: 'ArrangingPayment' });
-                expect(result.transitionOrderToState).toEqual({
+
+                orderResultGuard.assertSuccess(transitionOrderToState);
+                expect(pick(transitionOrderToState, ['id', 'state'])).toEqual({
                     id: activeOrder.id,
                     state: 'ArrangingPayment',
                 });
             });
 
-            it(
-                'attempting to add an item throws error when in ArrangingPayment state',
-                assertThrowsWithMessage(
-                    () =>
-                        shopClient.query<AddItemToOrder.Mutation, AddItemToOrder.Variables>(
-                            ADD_ITEM_TO_ORDER,
-                            {
-                                productVariantId: 'T_4',
-                                quantity: 1,
-                            },
-                        ),
+            it('attempting to add an item returns error result when in ArrangingPayment state', async () => {
+                const { addItemToOrder } = await shopClient.query<
+                    AddItemToOrder.Mutation,
+                    AddItemToOrder.Variables
+                >(ADD_ITEM_TO_ORDER, {
+                    productVariantId: 'T_4',
+                    quantity: 1,
+                });
+
+                orderResultGuard.assertErrorResult(addItemToOrder);
+                expect(addItemToOrder.message).toBe(
                     `Order contents may only be modified when in the "AddingItems" state`,
-                ),
-            );
+                );
+                expect(addItemToOrder.errorCode).toBe(ErrorCode.ORDER_MODIFICATION_ERROR);
+            });
 
-            it(
-                'attempting to modify item quantity throws error when in ArrangingPayment state',
-                assertThrowsWithMessage(
-                    () =>
-                        shopClient.query<AdjustItemQuantity.Mutation, AdjustItemQuantity.Variables>(
-                            ADJUST_ITEM_QUANTITY,
-                            {
-                                orderLineId: activeOrder.lines[0].id,
-                                quantity: 12,
-                            },
-                        ),
+            it('attempting to modify item quantity returns error result when in ArrangingPayment state', async () => {
+                const { adjustOrderLine } = await shopClient.query<
+                    AdjustItemQuantity.Mutation,
+                    AdjustItemQuantity.Variables
+                >(ADJUST_ITEM_QUANTITY, {
+                    orderLineId: activeOrder.lines[0].id,
+                    quantity: 12,
+                });
+                orderResultGuard.assertErrorResult(adjustOrderLine);
+                expect(adjustOrderLine.message).toBe(
                     `Order contents may only be modified when in the "AddingItems" state`,
-                ),
-            );
+                );
+                expect(adjustOrderLine.errorCode).toBe(ErrorCode.ORDER_MODIFICATION_ERROR);
+            });
 
-            it(
-                'attempting to remove an item throws error when in ArrangingPayment state',
-                assertThrowsWithMessage(
-                    () =>
-                        shopClient.query<RemoveItemFromOrder.Mutation, RemoveItemFromOrder.Variables>(
-                            REMOVE_ITEM_FROM_ORDER,
-                            {
-                                orderLineId: activeOrder.lines[0].id,
-                            },
-                        ),
+            it('attempting to remove an item returns error result when in ArrangingPayment state', async () => {
+                const { removeOrderLine } = await shopClient.query<
+                    RemoveItemFromOrder.Mutation,
+                    RemoveItemFromOrder.Variables
+                >(REMOVE_ITEM_FROM_ORDER, {
+                    orderLineId: activeOrder.lines[0].id,
+                });
+                orderResultGuard.assertErrorResult(removeOrderLine);
+                expect(removeOrderLine.message).toBe(
                     `Order contents may only be modified when in the "AddingItems" state`,
-                ),
-            );
+                );
+                expect(removeOrderLine.errorCode).toBe(ErrorCode.ORDER_MODIFICATION_ERROR);
+            });
 
-            it(
-                'attempting to setOrderShippingMethod throws error when in ArrangingPayment state',
-                assertThrowsWithMessage(async () => {
-                    const shippingMethodsResult = await shopClient.query<GetShippingMethods.Query>(
-                        GET_ELIGIBLE_SHIPPING_METHODS,
-                    );
-                    const shippingMethods = shippingMethodsResult.eligibleShippingMethods;
-                    return shopClient.query<SetShippingMethod.Mutation, SetShippingMethod.Variables>(
-                        SET_SHIPPING_METHOD,
-                        {
-                            id: shippingMethods[0].id,
-                        },
-                    );
-                }, `Order contents may only be modified when in the "AddingItems" state`),
-            );
+            it('attempting to remove all items returns error result when in ArrangingPayment state', async () => {
+                const { removeAllOrderLines } = await shopClient.query<RemoveAllOrderLines.Mutation>(
+                    REMOVE_ALL_ORDER_LINES,
+                );
+                orderResultGuard.assertErrorResult(removeAllOrderLines);
+                expect(removeAllOrderLines.message).toBe(
+                    `Order contents may only be modified when in the "AddingItems" state`,
+                );
+                expect(removeAllOrderLines.errorCode).toBe(ErrorCode.ORDER_MODIFICATION_ERROR);
+            });
+
+            it('attempting to setOrderShippingMethod returns error result when in ArrangingPayment state', async () => {
+                const shippingMethodsResult = await shopClient.query<GetShippingMethods.Query>(
+                    GET_ELIGIBLE_SHIPPING_METHODS,
+                );
+                const shippingMethods = shippingMethodsResult.eligibleShippingMethods;
+                const { setOrderShippingMethod } = await shopClient.query<
+                    SetShippingMethod.Mutation,
+                    SetShippingMethod.Variables
+                >(SET_SHIPPING_METHOD, {
+                    id: shippingMethods[0].id,
+                });
+                orderResultGuard.assertErrorResult(setOrderShippingMethod);
+                expect(setOrderShippingMethod.message).toBe(
+                    `Order contents may only be modified when in the "AddingItems" state`,
+                );
+                expect(setOrderShippingMethod.errorCode).toBe(ErrorCode.ORDER_MODIFICATION_ERROR);
+            });
 
             it('adds a declined payment', async () => {
                 const { addPaymentToOrder } = await shopClient.query<
@@ -846,9 +928,17 @@ describe('Shop orders', () => {
                         },
                     },
                 });
+                orderResultGuard.assertErrorResult(addPaymentToOrder);
 
-                const payment = addPaymentToOrder!.payments![0];
-                expect(addPaymentToOrder!.payments!.length).toBe(1);
+                expect(addPaymentToOrder!.message).toBe('The payment was declined');
+                expect(addPaymentToOrder!.errorCode).toBe(ErrorCode.PAYMENT_DECLINED_ERROR);
+                expect((addPaymentToOrder as any).paymentErrorMessage).toBe('Insufficient funds');
+
+                const { activeOrder: order } = await shopClient.query<GetActiveOrderWithPayments.Query>(
+                    GET_ACTIVE_ORDER_WITH_PAYMENTS,
+                );
+                const payment = order!.payments![0];
+                expect(order!.payments!.length).toBe(1);
                 expect(payment.method).toBe(testFailingPaymentMethod.code);
                 expect(payment.state).toBe('Declined');
                 expect(payment.transactionId).toBe(null);
@@ -857,25 +947,24 @@ describe('Shop orders', () => {
                 });
             });
 
-            it('adds an error payment and returns error response', async () => {
-                try {
-                    await shopClient.query<AddPaymentToOrder.Mutation, AddPaymentToOrder.Variables>(
-                        ADD_PAYMENT,
-                        {
-                            input: {
-                                method: testErrorPaymentMethod.code,
-                                metadata: {
-                                    foo: 'bar',
-                                },
-                            },
+            it('adds an error payment and returns error result', async () => {
+                const { addPaymentToOrder } = await shopClient.query<
+                    AddPaymentToOrder.Mutation,
+                    AddPaymentToOrder.Variables
+                >(ADD_PAYMENT, {
+                    input: {
+                        method: testErrorPaymentMethod.code,
+                        metadata: {
+                            foo: 'bar',
                         },
-                    );
-                    // TODO: we need to return an Error response as per
-                    // https://github.com/vendure-ecommerce/vendure/issues/437
-                    // fail('should have thrown');
-                } catch (err) {
-                    // expect(err.message).toEqual('Something went horribly wrong');
-                }
+                    },
+                });
+
+                orderResultGuard.assertErrorResult(addPaymentToOrder);
+                expect(addPaymentToOrder!.message).toBe('The payment failed');
+                expect(addPaymentToOrder!.errorCode).toBe(ErrorCode.PAYMENT_FAILED_ERROR);
+                expect((addPaymentToOrder as any).paymentErrorMessage).toBe('Something went horribly wrong');
+
                 const result = await shopClient.query<GetActiveOrderPayments.Query>(
                     GET_ACTIVE_ORDER_PAYMENTS,
                 );
@@ -898,6 +987,7 @@ describe('Shop orders', () => {
                         },
                     },
                 });
+                orderResultGuard.assertSuccess(addPaymentToOrder);
 
                 const payment = addPaymentToOrder!.payments![2];
                 expect(addPaymentToOrder!.state).toBe('PaymentSettled');
@@ -979,7 +1069,7 @@ describe('Shop orders', () => {
                 productVariantId: 'T_1',
                 quantity: 1,
             });
-
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.lines.length).toBe(1);
             expect(addItemToOrder!.lines[0].productVariant.id).toBe('T_1');
 
@@ -1002,7 +1092,7 @@ describe('Shop orders', () => {
                 productVariantId: 'T_2',
                 quantity: 1,
             });
-
+            orderResultGuard.assertSuccess(addItemToOrder);
             expect(addItemToOrder!.lines.length).toBe(1);
             expect(addItemToOrder!.lines[0].productVariant.id).toBe('T_2');
 
@@ -1069,23 +1159,21 @@ describe('Shop orders', () => {
                 quantity: 1,
             });
 
-            try {
-                await shopClient.query<SetCustomerForOrder.Mutation, SetCustomerForOrder.Variables>(
-                    SET_CUSTOMER,
-                    {
-                        input: {
-                            emailAddress: customers[0].emailAddress,
-                            firstName: 'Evil',
-                            lastName: 'Hacker',
-                        },
-                    },
-                );
-                fail('Should have thrown');
-            } catch (e) {
-                expect(e.message).toContain(
-                    'Cannot use a registered email address for a guest order. Please log in first',
-                );
-            }
+            const { setCustomerForOrder } = await shopClient.query<
+                SetCustomerForOrder.Mutation,
+                SetCustomerForOrder.Variables
+            >(SET_CUSTOMER, {
+                input: {
+                    emailAddress: customers[0].emailAddress,
+                    firstName: 'Evil',
+                    lastName: 'Hacker',
+                },
+            });
+            orderResultGuard.assertErrorResult(setCustomerForOrder);
+
+            expect(setCustomerForOrder!.message).toBe('The email address is not available.');
+            expect(setCustomerForOrder!.errorCode).toBe(ErrorCode.EMAIL_ADDRESS_CONFLICT_ERROR);
+
             const { customer } = await adminClient.query<GetCustomer.Query, GetCustomer.Variables>(
                 GET_CUSTOMER,
                 {
@@ -1201,6 +1289,7 @@ describe('Shop orders', () => {
                 RemoveAllOrderLines.Mutation,
                 RemoveAllOrderLines.Variables
             >(REMOVE_ALL_ORDER_LINES);
+            orderResultGuard.assertSuccess(removeAllOrderLines);
             expect(removeAllOrderLines?.total).toBe(0);
             expect(removeAllOrderLines?.lines.length).toBe(0);
         });

packages/core/src/api/api.module.ts

@@ -3,6 +3,7 @@ import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
 import path from 'path';
 
 import { DataImportModule } from '../data-import/data-import.module';
+import { I18nModule } from '../i18n/i18n.module';
 import { ServiceModule } from '../service/service.module';
 
 import { AdminApiModule, ApiSharedModule, ShopApiModule } from './api-internal-modules';
@@ -11,6 +12,7 @@ import { configureGraphQLModule } from './config/configure-graphql-module';
 import { AuthGuard } from './middleware/auth-guard';
 import { ExceptionLoggerFilter } from './middleware/exception-logger.filter';
 import { IdInterceptor } from './middleware/id-interceptor';
+import { TranslateErrorResultInterceptor } from './middleware/translate-error-result-interceptor';
 import { ValidateCustomFieldsInterceptor } from './middleware/validate-custom-fields-interceptor';
 
 /**
@@ -22,6 +24,7 @@ import { ValidateCustomFieldsInterceptor } from './middleware/validate-custom-fi
     imports: [
         ServiceModule.forRoot(),
         DataImportModule,
+        I18nModule,
         ApiSharedModule,
         AdminApiModule,
         ShopApiModule,
@@ -60,6 +63,10 @@ import { ValidateCustomFieldsInterceptor } from './middleware/validate-custom-fi
             provide: APP_INTERCEPTOR,
             useClass: ValidateCustomFieldsInterceptor,
         },
+        {
+            provide: APP_INTERCEPTOR,
+            useClass: TranslateErrorResultInterceptor,
+        },
         {
             provide: APP_FILTER,
             useClass: ExceptionLoggerFilter,

packages/core/src/api/config/configure-graphql-module.ts

@@ -8,6 +8,11 @@ import { GraphQLDateTime } from 'graphql-iso-date';
 import GraphQLJSON from 'graphql-type-json';
 import path from 'path';
 
+import {
+    adminErrorOperationTypeResolvers,
+    ErrorResult,
+} from '../../common/error/generated-graphql-admin-errors';
+import { shopErrorOperationTypeResolvers } from '../../common/error/generated-graphql-shop-errors';
 import { ConfigModule } from '../../config/config.module';
 import { ConfigService } from '../../config/config.service';
 import { I18nModule } from '../../i18n/i18n.module';
@@ -21,6 +26,7 @@ import { IdCodecPlugin } from '../middleware/id-codec-plugin';
 import { TranslateErrorsPlugin } from '../middleware/translate-errors-plugin';
 
 import { generateAuthenticationTypes } from './generate-auth-types';
+import { generateErrorCodeEnum } from './generate-error-code-enum';
 import { generateListOptions } from './generate-list-options';
 import {
     addGraphQLCustomFields,
@@ -133,6 +139,14 @@ async function createGraphQLOptions(
             StockMovement: stockMovementResolveType,
             CustomFieldConfig: customFieldsConfigResolveType,
             CustomField: customFieldsConfigResolveType,
+            ErrorResult: {
+                __resolveType(value: ErrorResult) {
+                    return value.__typename;
+                },
+            },
+            ...(options.apiType === 'admin'
+                ? adminErrorOperationTypeResolvers
+                : shopErrorOperationTypeResolvers),
         },
         uploads: {
             maxFileSize: configService.assetOptions.uploadMaxFileSize,
@@ -177,6 +191,7 @@ async function createGraphQLOptions(
         schema = addServerConfigCustomFields(schema, customFields);
         schema = addOrderLineCustomFieldsInput(schema, customFields.OrderLine || []);
         schema = generateAuthenticationTypes(schema, authStrategies);
+        schema = generateErrorCodeEnum(schema);
         if (apiType === 'shop') {
             schema = addRegisterCustomerCustomFieldsInput(schema, customFields.Customer || []);
         }

packages/core/src/api/config/generate-error-code-enum.ts

@@ -0,0 +1,33 @@
+import { buildSchema, extendSchema, GraphQLSchema, parse } from 'graphql';
+
+export const ERROR_INTERFACE_NAME = 'ErrorResult';
+
+/**
+ * Generates the members of the `ErrorCode` enum dynamically, by getting the names of
+ * all the types which inherit from the `ErrorResult` interface.
+ */
+export function generateErrorCodeEnum(typeDefsOrSchema: string | GraphQLSchema): GraphQLSchema {
+    const schema = typeof typeDefsOrSchema === 'string' ? buildSchema(typeDefsOrSchema) : typeDefsOrSchema;
+    const errorNodes = Object.values(schema.getTypeMap())
+        .map(type => type.astNode)
+        .filter(node => {
+            return (
+                node &&
+                node?.kind === 'ObjectTypeDefinition' &&
+                node.interfaces?.map(i => i.name.value).includes(ERROR_INTERFACE_NAME)
+            );
+        });
+    if (!errorNodes.length) {
+        return schema;
+    }
+
+    const errorCodeEnum = `
+        extend enum ErrorCode {
+            ${errorNodes.map(n => camelToUpperSnakeCase(n?.name.value || '')).join('\n')}
+        }`;
+    return extendSchema(schema, parse(errorCodeEnum));
+}
+
+function camelToUpperSnakeCase(input: string): string {
+    return input.replace(/([a-z])([A-Z])/g, '$1_$2').toUpperCase();
+}

packages/core/src/api/middleware/asset-interceptor-plugin.ts

@@ -1,6 +1,6 @@
 import { Asset } from '@vendure/common/lib/generated-types';
 import { ApolloServerPlugin, GraphQLRequestListener, GraphQLServiceContext } from 'apollo-server-plugin-base';
-import { DocumentNode } from 'graphql';
+import { DocumentNode, GraphQLNamedType, isUnionType } from 'graphql';
 
 import { AssetStorageStrategy } from '../../config/asset-storage-strategy/asset-storage-strategy';
 import { ConfigService } from '../../config/config.service';
@@ -49,8 +49,12 @@ export class AssetInterceptorPlugin implements ApolloServerPlugin {
             return;
         }
         this.graphqlValueTransformer.transformValues(typeTree, data, (value, type) => {
-            const isAssetType = type && (type.name === 'Asset' || type.name === 'SearchResultAsset');
-            if (isAssetType) {
+            if (!type) {
+                return value;
+            }
+            const isAssetType = this.isAssetType(type);
+            const isUnionWithAssetType = isUnionType(type) && type.getTypes().find(t => this.isAssetType(t));
+            if (isAssetType || isUnionWithAssetType) {
                 if (value && !Array.isArray(value)) {
                     if (value.preview) {
                         value.preview = toAbsoluteUrl(request, value.preview);
@@ -77,4 +81,9 @@ export class AssetInterceptorPlugin implements ApolloServerPlugin {
             return value;
         });
     }
+
+    private isAssetType(type: GraphQLNamedType): boolean {
+        const assetTypeNames = ['Asset', 'SearchResultAsset'];
+        return assetTypeNames.includes(type.name);
+    }
 }

packages/core/src/api/middleware/translate-error-result-interceptor.ts

@@ -0,0 +1,40 @@
+import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+
+import { ErrorResult as AdminErrorResult } from '../../common/error/generated-graphql-admin-errors';
+import { ErrorResult as ShopErrorResult } from '../../common/error/generated-graphql-shop-errors';
+import { I18nService } from '../../i18n/i18n.service';
+import { parseContext } from '../common/parse-context';
+
+/**
+ * @description
+ * Translates any top-level ErrorResult message
+ */
+@Injectable()
+export class TranslateErrorResultInterceptor implements NestInterceptor {
+    constructor(private i18nService: I18nService) {}
+
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+        const { isGraphQL, req } = parseContext(context);
+        return next.handle().pipe(
+            switchMap(result => Promise.resolve(result)),
+            map(result => {
+                if (Array.isArray(result)) {
+                    for (const item of result) {
+                        this.translateResult(req, item);
+                    }
+                } else {
+                    this.translateResult(req, result);
+                }
+                return result;
+            }),
+        );
+    }
+
+    private translateResult(req: any, result: unknown) {
+        if (result instanceof AdminErrorResult || result instanceof ShopErrorResult) {
+            this.i18nService.translateErrorResult(req, result as any);
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
+    CreateAssetResult,
     MutationCreateAssetsArgs,
     MutationDeleteAssetArgs,
     MutationDeleteAssetsArgs,
@@ -36,15 +37,13 @@ export class AssetResolver {
     @Transaction()
     @Mutation()
     @Allow(Permission.CreateCatalog)
-    async createAssets(@Ctx() ctx: RequestContext, @Args() args: MutationCreateAssetsArgs): Promise<Asset[]> {
-        // TODO: Currently we validate _all_ mime types up-front due to limitations
-        // with the existing error handling mechanisms. With a solution as described
-        // in https://github.com/vendure-ecommerce/vendure/issues/437 we could defer
-        // this check to the individual processing of a single Asset.
-        await this.assetService.validateInputMimeTypes(args.input);
+    async createAssets(
+        @Ctx() ctx: RequestContext,
+        @Args() args: MutationCreateAssetsArgs,
+    ): Promise<CreateAssetResult[]> {
         // TODO: Is there some way to parellelize this while still preserving
         // the order of files in the upload? Non-deterministic IDs mess up the e2e test snapshots.
-        const assets: Asset[] = [];
+        const assets: CreateAssetResult[] = [];
         for (const input of args.input) {
             const asset = await this.assetService.create(ctx, input);
             assets.push(asset);

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

@@ -1,12 +1,15 @@
 import { Args, Context, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
-    LoginResult,
+    AuthenticationResult,
     MutationAuthenticateArgs,
     MutationLoginArgs,
+    NativeAuthenticationResult,
     Permission,
+    Success,
 } from '@vendure/common/lib/generated-types';
 import { Request, Response } from 'express';
 
+import { NativeAuthStrategyError } from '../../../common/error/generated-graphql-admin-errors';
 import { ConfigService } from '../../../config/config.service';
 import { AdministratorService } from '../../../service/services/administrator.service';
 import { AuthService } from '../../../service/services/auth.service';
@@ -33,25 +36,29 @@ export class AuthResolver extends BaseAuthResolver {
     @Transaction()
     @Mutation()
     @Allow(Permission.Public)
-    login(
+    async login(
         @Args() args: MutationLoginArgs,
         @Ctx() ctx: RequestContext,
         @Context('req') req: Request,
         @Context('res') res: Response,
-    ): Promise<LoginResult> {
-        return super.login(args, ctx, req, res);
+    ): Promise<NativeAuthenticationResult> {
+        const nativeAuthStrategyError = this.requireNativeAuthStrategy();
+        if (nativeAuthStrategyError) {
+            return nativeAuthStrategyError;
+        }
+        return (await super.login(args, ctx, req, res)) as AuthenticationResult;
     }
 
     @Transaction()
     @Mutation()
     @Allow(Permission.Public)
-    authenticate(
+    async authenticate(
         @Args() args: MutationAuthenticateArgs,
         @Ctx() ctx: RequestContext,
         @Context('req') req: Request,
         @Context('res') res: Response,
-    ): Promise<LoginResult> {
-        return this.authenticateAndCreateSession(ctx, args, req, res);
+    ): Promise<AuthenticationResult> {
+        return (await this.authenticateAndCreateSession(ctx, args, req, res)) as AuthenticationResult;
     }
 
     @Transaction()
@@ -61,7 +68,7 @@ export class AuthResolver extends BaseAuthResolver {
         @Ctx() ctx: RequestContext,
         @Context('req') req: Request,
         @Context('res') res: Response,
-    ): Promise<boolean> {
+    ): Promise<Success> {
         return super.logout(ctx, req, res);
     }
 
@@ -70,4 +77,8 @@ export class AuthResolver extends BaseAuthResolver {
     me(@Ctx() ctx: RequestContext) {
         return super.me(ctx, 'admin');
     }
+
+    protected requireNativeAuthStrategy() {
+        return super.requireNativeAuthStrategy() as NativeAuthStrategyError | undefined;
+    }
 }

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

@@ -1,13 +1,16 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
+    CreateChannelResult,
     DeletionResponse,
     MutationCreateChannelArgs,
     MutationDeleteChannelArgs,
     MutationUpdateChannelArgs,
     Permission,
     QueryChannelArgs,
+    UpdateChannelResult,
 } from '@vendure/common/lib/generated-types';
 
+import { ErrorResultUnion, isGraphQlErrorResult } from '../../../common/error/error-result';
 import { Channel } from '../../../entity/channel/channel.entity';
 import { ChannelService } from '../../../service/services/channel.service';
 import { RoleService } from '../../../service/services/role.service';
@@ -44,13 +47,16 @@ export class ChannelResolver {
     async createChannel(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationCreateChannelArgs,
-    ): Promise<Channel> {
-        const channel = await this.channelService.create(ctx, args.input);
+    ): Promise<ErrorResultUnion<CreateChannelResult, Channel>> {
+        const result = await this.channelService.create(ctx, args.input);
+        if (isGraphQlErrorResult(result)) {
+            return result;
+        }
         const superAdminRole = await this.roleService.getSuperAdminRole();
         const customerRole = await this.roleService.getCustomerRole();
-        await this.roleService.assignRoleToChannel(ctx, superAdminRole.id, channel.id);
-        await this.roleService.assignRoleToChannel(ctx, customerRole.id, channel.id);
-        return channel;
+        await this.roleService.assignRoleToChannel(ctx, superAdminRole.id, result.id);
+        await this.roleService.assignRoleToChannel(ctx, customerRole.id, result.id);
+        return result;
     }
 
     @Transaction()
@@ -59,8 +65,12 @@ export class ChannelResolver {
     async updateChannel(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationUpdateChannelArgs,
-    ): Promise<Channel> {
-        return this.channelService.update(ctx, args.input);
+    ): Promise<ErrorResultUnion<UpdateChannelResult, Channel>> {
+        const result = await this.channelService.update(ctx, args.input);
+        if (isGraphQlErrorResult(result)) {
+            return result;
+        }
+        return result;
     }
 
     @Transaction()

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

@@ -1,8 +1,8 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
+    CreateCustomerResult,
     DeletionResponse,
     MutationAddNoteToCustomerArgs,
-    MutationAddNoteToOrderArgs,
     MutationCreateCustomerAddressArgs,
     MutationCreateCustomerArgs,
     MutationDeleteCustomerAddressArgs,
@@ -14,9 +14,12 @@ import {
     Permission,
     QueryCustomerArgs,
     QueryCustomersArgs,
+    Success,
+    UpdateCustomerResult,
 } from '@vendure/common/lib/generated-types';
 import { PaginatedList } from '@vendure/common/lib/shared-types';
 
+import { ErrorResultUnion } from '../../../common/error/error-result';
 import { Address } from '../../../entity/address/address.entity';
 import { Customer } from '../../../entity/customer/customer.entity';
 import { CustomerService } from '../../../service/services/customer.service';
@@ -54,7 +57,7 @@ export class CustomerResolver {
     async createCustomer(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationCreateCustomerArgs,
-    ): Promise<Customer> {
+    ): Promise<ErrorResultUnion<CreateCustomerResult, Customer>> {
         const { input, password } = args;
         return this.customerService.create(ctx, input, password || undefined);
     }
@@ -65,7 +68,7 @@ export class CustomerResolver {
     async updateCustomer(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationUpdateCustomerArgs,
-    ): Promise<Customer> {
+    ): Promise<ErrorResultUnion<UpdateCustomerResult, Customer>> {
         const { input } = args;
         return this.customerService.update(ctx, input);
     }
@@ -98,9 +101,10 @@ export class CustomerResolver {
     async deleteCustomerAddress(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationDeleteCustomerAddressArgs,
-    ): Promise<boolean> {
+    ): Promise<Success> {
         const { id } = args;
-        return this.customerService.deleteAddress(ctx, id);
+        const success = await this.customerService.deleteAddress(ctx, id);
+        return { success };
     }
 
     @Transaction()

packages/core/src/api/resolvers/admin/global-settings.resolver.ts

@@ -3,11 +3,15 @@ import {
     MutationUpdateGlobalSettingsArgs,
     OrderProcessState,
     Permission,
+    UpdateGlobalSettingsResult,
 } from '@vendure/common/lib/generated-types';
 
+import { ErrorResultUnion } from '../../../common/error/error-result';
 import { UserInputError } from '../../../common/error/errors';
+import { ChannelDefaultLanguageError } from '../../../common/error/generated-graphql-admin-errors';
 import { ConfigService } from '../../../config/config.service';
 import { CustomFields } from '../../../config/custom-field/custom-field-types';
+import { GlobalSettings } from '../../../entity/global-settings/global-settings.entity';
 import { ChannelService } from '../../../service/services/channel.service';
 import { GlobalSettingsService } from '../../../service/services/global-settings.service';
 import { OrderService } from '../../../service/services/order.service';
@@ -57,7 +61,10 @@ export class GlobalSettingsResolver {
     @Transaction()
     @Mutation()
     @Allow(Permission.UpdateSettings)
-    async updateGlobalSettings(@Ctx() ctx: RequestContext, @Args() args: MutationUpdateGlobalSettingsArgs) {
+    async updateGlobalSettings(
+        @Ctx() ctx: RequestContext,
+        @Args() args: MutationUpdateGlobalSettingsArgs,
+    ): Promise<ErrorResultUnion<UpdateGlobalSettingsResult, GlobalSettings>> {
         // This validation is performed here in the resolver rather than at the service
         // layer to avoid a circular dependency [ChannelService <> GlobalSettingsService]
         const { availableLanguages } = args.input;
@@ -67,10 +74,10 @@ export class GlobalSettingsResolver {
                 c => !availableLanguages.includes(c.defaultLanguageCode),
             );
             if (unavailableDefaults.length) {
-                throw new UserInputError('error.cannot-set-default-language-as-unavailable', {
-                    language: unavailableDefaults.map(c => c.defaultLanguageCode).join(', '),
-                    channelCode: unavailableDefaults.map(c => c.code).join(', '),
-                });
+                return new ChannelDefaultLanguageError(
+                    unavailableDefaults.map(c => c.defaultLanguageCode).join(', '),
+                    unavailableDefaults.map(c => c.code).join(', '),
+                );
             }
         }
         return this.globalSettingsService.updateSettings(ctx, args.input);

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

@@ -1,9 +1,11 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
+    AddFulfillmentToOrderResult,
+    CancelOrderResult,
+    MutationAddFulfillmentToOrderArgs,
     MutationAddNoteToOrderArgs,
     MutationCancelOrderArgs,
     MutationDeleteOrderNoteArgs,
-    MutationFulfillOrderArgs,
     MutationRefundOrderArgs,
     MutationSetOrderCustomFieldsArgs,
     MutationSettlePaymentArgs,
@@ -14,10 +16,16 @@ import {
     Permission,
     QueryOrderArgs,
     QueryOrdersArgs,
+    RefundOrderResult,
+    SettlePaymentResult,
 } from '@vendure/common/lib/generated-types';
 import { PaginatedList } from '@vendure/common/lib/shared-types';
 
+import { ErrorResultUnion } from '../../../common/error/error-result';
+import { Fulfillment } from '../../../entity/fulfillment/fulfillment.entity';
 import { Order } from '../../../entity/order/order.entity';
+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 { OrderService } from '../../../service/services/order.service';
@@ -46,28 +54,40 @@ export class OrderResolver {
     @Transaction()
     @Mutation()
     @Allow(Permission.UpdateOrder)
-    async settlePayment(@Ctx() ctx: RequestContext, @Args() args: MutationSettlePaymentArgs) {
+    async settlePayment(
+        @Ctx() ctx: RequestContext,
+        @Args() args: MutationSettlePaymentArgs,
+    ): Promise<ErrorResultUnion<SettlePaymentResult, Payment>> {
         return this.orderService.settlePayment(ctx, args.id);
     }
 
     @Transaction()
     @Mutation()
     @Allow(Permission.UpdateOrder)
-    async fulfillOrder(@Ctx() ctx: RequestContext, @Args() args: MutationFulfillOrderArgs) {
+    async addFulfillmentToOrder(
+        @Ctx() ctx: RequestContext,
+        @Args() args: MutationAddFulfillmentToOrderArgs,
+    ): Promise<ErrorResultUnion<AddFulfillmentToOrderResult, Fulfillment>> {
         return this.orderService.createFulfillment(ctx, args.input);
     }
 
     @Transaction()
     @Mutation()
     @Allow(Permission.UpdateOrder)
-    async cancelOrder(@Ctx() ctx: RequestContext, @Args() args: MutationCancelOrderArgs) {
+    async cancelOrder(
+        @Ctx() ctx: RequestContext,
+        @Args() args: MutationCancelOrderArgs,
+    ): Promise<ErrorResultUnion<CancelOrderResult, Order>> {
         return this.orderService.cancelOrder(ctx, args.input);
     }
 
     @Transaction()
     @Mutation()
     @Allow(Permission.UpdateOrder)
-    async refundOrder(@Ctx() ctx: RequestContext, @Args() args: MutationRefundOrderArgs) {
+    async refundOrder(
+        @Ctx() ctx: RequestContext,
+        @Args() args: MutationRefundOrderArgs,
+    ): Promise<ErrorResultUnion<RefundOrderResult, Refund>> {
         return this.orderService.refundOrder(ctx, args.input);
     }
 

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

@@ -15,9 +15,11 @@ import {
     QueryProductArgs,
     QueryProductsArgs,
     QueryProductVariantArgs,
+    RemoveOptionGroupFromProductResult,
 } from '@vendure/common/lib/generated-types';
 import { PaginatedList } from '@vendure/common/lib/shared-types';
 
+import { ErrorResultUnion } from '../../../common/error/error-result';
 import { UserInputError } from '../../../common/error/errors';
 import { Translated } from '../../../common/types/locale-types';
 import { ProductVariant } from '../../../entity/product-variant/product-variant.entity';
@@ -124,7 +126,7 @@ export class ProductResolver {
     async removeOptionGroupFromProduct(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationRemoveOptionGroupFromProductArgs,
-    ): Promise<Translated<Product>> {
+    ): Promise<ErrorResultUnion<RemoveOptionGroupFromProductResult, Translated<Product>>> {
         const { productId, optionGroupId } = args;
         return this.productService.removeOptionGroupFromProduct(ctx, productId, optionGroupId);
     }

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

@@ -1,5 +1,6 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
+    CreatePromotionResult,
     DeletionResponse,
     MutationCreatePromotionArgs,
     MutationDeletePromotionArgs,
@@ -7,9 +8,11 @@ import {
     Permission,
     QueryPromotionArgs,
     QueryPromotionsArgs,
+    UpdatePromotionResult,
 } from '@vendure/common/lib/generated-types';
 import { PaginatedList } from '@vendure/common/lib/shared-types';
 
+import { ErrorResultUnion } from '../../../common/error/error-result';
 import { PromotionItemAction, PromotionOrderAction } from '../../../config/promotion/promotion-action';
 import { PromotionCondition } from '../../../config/promotion/promotion-condition';
 import { Promotion } from '../../../entity/promotion/promotion.entity';
@@ -63,7 +66,7 @@ export class PromotionResolver {
     createPromotion(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationCreatePromotionArgs,
-    ): Promise<Promotion> {
+    ): Promise<ErrorResultUnion<CreatePromotionResult, Promotion>> {
         this.configurableOperationCodec.decodeConfigurableOperationIds(
             PromotionOrderAction,
             args.input.actions,
@@ -81,7 +84,7 @@ export class PromotionResolver {
     updatePromotion(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationUpdatePromotionArgs,
-    ): Promise<Promotion> {
+    ): Promise<ErrorResultUnion<UpdatePromotionResult, Promotion>> {
         this.configurableOperationCodec.decodeConfigurableOperationIds(
             PromotionOrderAction,
             args.input.actions || [],
@@ -110,17 +113,21 @@ export class PromotionResolver {
     /**
      * Encodes any entity IDs used in the filter arguments.
      */
-    private encodeConditionsAndActions = <T extends Promotion | undefined>(collection: T): T => {
-        if (collection) {
+    private encodeConditionsAndActions = <
+        T extends ErrorResultUnion<CreatePromotionResult, Promotion> | undefined
+    >(
+        maybePromotion: T,
+    ): T => {
+        if (maybePromotion instanceof Promotion) {
             this.configurableOperationCodec.encodeConfigurableOperationIds(
                 PromotionOrderAction,
-                collection.actions,
+                maybePromotion.actions,
             );
             this.configurableOperationCodec.encodeConfigurableOperationIds(
                 PromotionCondition,
-                collection.conditions,
+                maybePromotion.conditions,
             );
         }
-        return collection;
+        return maybePromotion;
     };
 }

packages/core/src/api/resolvers/base/base-auth.resolver.ts

@@ -1,15 +1,24 @@
+import { AuthenticationResult as ShopAuthenticationResult } from '@vendure/common/lib/generated-shop-types';
 import {
+    AuthenticationResult as AdminAuthenticationResult,
     CurrentUser,
     CurrentUserChannel,
-    LoginResult,
     MutationAuthenticateArgs,
     MutationLoginArgs,
+    Success,
 } from '@vendure/common/lib/generated-types';
 import { Request, Response } from 'express';
 
-import { ForbiddenError, InternalServerError, UnauthorizedError } from '../../../common/error/errors';
+import { isGraphQlErrorResult } from '../../../common/error/error-result';
+import { ForbiddenError, UnauthorizedError } from '../../../common/error/errors';
+import { NativeAuthStrategyError as AdminNativeAuthStrategyError } from '../../../common/error/generated-graphql-admin-errors';
+import {
+    InvalidCredentialsError,
+    NativeAuthStrategyError as ShopNativeAuthStrategyError,
+} from '../../../common/error/generated-graphql-shop-errors';
 import { NATIVE_AUTH_STRATEGY_NAME } from '../../../config/auth/native-authentication-strategy';
 import { ConfigService } from '../../../config/config.service';
+import { Logger } from '../../../config/logger/vendure-logger';
 import { User } from '../../../entity/user/user.entity';
 import { getUserChannelsPermissions } from '../../../service/helpers/utils/get-user-channels-permissions';
 import { AdministratorService } from '../../../service/services/administrator.service';
@@ -21,12 +30,18 @@ import { RequestContext } from '../../common/request-context';
 import { setSessionToken } from '../../common/set-session-token';
 
 export class BaseAuthResolver {
+    protected readonly nativeAuthStrategyIsConfigured: boolean;
+
     constructor(
         protected authService: AuthService,
         protected userService: UserService,
         protected administratorService: AdministratorService,
         protected configService: ConfigService,
-    ) {}
+    ) {
+        this.nativeAuthStrategyIsConfigured = !!this.configService.authOptions.shopAuthenticationStrategy.find(
+            strategy => strategy.name === NATIVE_AUTH_STRATEGY_NAME,
+        );
+    }
 
     /**
      * Attempts a login given the username and password of a user. If successful, returns
@@ -37,7 +52,7 @@ export class BaseAuthResolver {
         ctx: RequestContext,
         req: Request,
         res: Response,
-    ): Promise<LoginResult> {
+    ): Promise<AdminAuthenticationResult | ShopAuthenticationResult> {
         return await this.authenticateAndCreateSession(
             ctx,
             {
@@ -48,10 +63,10 @@ export class BaseAuthResolver {
         );
     }
 
-    async logout(ctx: RequestContext, req: Request, res: Response): Promise<boolean> {
+    async logout(ctx: RequestContext, req: Request, res: Response): Promise<Success> {
         const token = extractSessionToken(req, this.configService.authOptions.tokenMethod);
         if (!token) {
-            return false;
+            return { success: false };
         }
         await this.authService.destroyAuthenticatedSession(ctx, token);
         setSessionToken({
@@ -61,7 +76,7 @@ export class BaseAuthResolver {
             rememberMe: false,
             sessionToken: '',
         });
-        return true;
+        return { success: true };
     }
 
     /**
@@ -90,14 +105,17 @@ export class BaseAuthResolver {
         args: MutationAuthenticateArgs,
         req: Request,
         res: Response,
-    ): Promise<LoginResult> {
+    ): Promise<AdminAuthenticationResult | ShopAuthenticationResult> {
         const [method, data] = Object.entries(args.input)[0];
         const { apiType } = ctx;
         const session = await this.authService.authenticate(ctx, apiType, method, data);
+        if (isGraphQlErrorResult(session)) {
+            return session;
+        }
         if (apiType && apiType === 'admin') {
             const administrator = await this.administratorService.findOneByUserId(ctx, session.user.id);
             if (!administrator) {
-                throw new UnauthorizedError();
+                return new InvalidCredentialsError();
             }
         }
         setSessionToken({
@@ -107,9 +125,7 @@ export class BaseAuthResolver {
             rememberMe: args.rememberMe || false,
             sessionToken: session.token,
         });
-        return {
-            user: this.publiclyAccessibleUser(session.user),
-        };
+        return this.publiclyAccessibleUser(session.user);
     }
 
     /**
@@ -119,10 +135,10 @@ export class BaseAuthResolver {
         ctx: RequestContext,
         currentPassword: string,
         newPassword: string,
-    ): Promise<boolean> {
+    ): Promise<boolean | InvalidCredentialsError> {
         const { activeUserId } = ctx;
         if (!activeUserId) {
-            throw new InternalServerError(`error.no-active-user-id`);
+            throw new ForbiddenError();
         }
         return this.userService.updatePassword(ctx, activeUserId, currentPassword, newPassword);
     }
@@ -137,4 +153,20 @@ export class BaseAuthResolver {
             channels: getUserChannelsPermissions(user) as CurrentUserChannel[],
         };
     }
+
+    protected requireNativeAuthStrategy():
+        | AdminNativeAuthStrategyError
+        | ShopNativeAuthStrategyError
+        | undefined {
+        if (!this.nativeAuthStrategyIsConfigured) {
+            const authStrategyNames = this.configService.authOptions.shopAuthenticationStrategy
+                .map(s => s.name)
+                .join(', ');
+            const errorMessage =
+                'This GraphQL operation requires that the NativeAuthenticationStrategy be configured for the Shop API.\n' +
+                `Currently the following AuthenticationStrategies are enabled: ${authStrategyNames}`;
+            Logger.error(errorMessage);
+            return new AdminNativeAuthStrategyError();
+        }
+    }
 }

packages/core/src/api/resolvers/shop/shop-auth.resolver.ts

@@ -1,6 +1,9 @@
 import { Args, Context, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
-    LoginResult,
+    AuthenticationResult,
+    ErrorCode,
+    InvalidCredentialsError,
+    MissingPasswordError,
     MutationAuthenticateArgs,
     MutationLoginArgs,
     MutationRefreshCustomerVerificationArgs,
@@ -11,20 +14,26 @@ import {
     MutationUpdateCustomerEmailAddressArgs,
     MutationUpdateCustomerPasswordArgs,
     MutationVerifyCustomerAccountArgs,
+    NativeAuthenticationResult,
     Permission,
+    RefreshCustomerVerificationResult,
+    RegisterCustomerAccountResult,
+    RequestPasswordResetResult,
+    RequestUpdateCustomerEmailAddressResult,
+    ResetPasswordResult,
+    Success,
+    UpdateCustomerEmailAddressResult,
+    UpdateCustomerPasswordResult,
+    VerifyCustomerAccountResult,
 } from '@vendure/common/lib/generated-shop-types';
 import { HistoryEntryType } from '@vendure/common/lib/generated-types';
 import { Request, Response } from 'express';
 
-import {
-    ForbiddenError,
-    InternalServerError,
-    PasswordResetTokenError,
-    VerificationTokenError,
-} from '../../../common/error/errors';
+import { isGraphQlErrorResult } from '../../../common/error/error-result';
+import { ForbiddenError } from '../../../common/error/errors';
+import { NativeAuthStrategyError } from '../../../common/error/generated-graphql-shop-errors';
 import { NATIVE_AUTH_STRATEGY_NAME } from '../../../config/auth/native-authentication-strategy';
 import { ConfigService } from '../../../config/config.service';
-import { Logger } from '../../../config/logger/vendure-logger';
 import { AdministratorService } from '../../../service/services/administrator.service';
 import { AuthService } from '../../../service/services/auth.service';
 import { CustomerService } from '../../../service/services/customer.service';
@@ -39,8 +48,6 @@ import { BaseAuthResolver } from '../base/base-auth.resolver';
 
 @Resolver()
 export class ShopAuthResolver extends BaseAuthResolver {
-    private readonly nativeAuthStrategyIsConfigured: boolean;
-
     constructor(
         authService: AuthService,
         userService: UserService,
@@ -50,44 +57,44 @@ export class ShopAuthResolver extends BaseAuthResolver {
         protected historyService: HistoryService,
     ) {
         super(authService, userService, administratorService, configService);
-        this.nativeAuthStrategyIsConfigured = !!this.configService.authOptions.shopAuthenticationStrategy.find(
-            strategy => strategy.name === NATIVE_AUTH_STRATEGY_NAME,
-        );
     }
 
     @Transaction()
     @Mutation()
     @Allow(Permission.Public)
-    login(
+    async login(
         @Args() args: MutationLoginArgs,
         @Ctx() ctx: RequestContext,
         @Context('req') req: Request,
         @Context('res') res: Response,
-    ): Promise<LoginResult> {
-        this.requireNativeAuthStrategy();
-        return super.login(args, ctx, req, res);
+    ): Promise<NativeAuthenticationResult> {
+        const nativeAuthStrategyError = this.requireNativeAuthStrategy();
+        if (nativeAuthStrategyError) {
+            return nativeAuthStrategyError;
+        }
+        return (await super.login(args, ctx, req, res)) as AuthenticationResult;
     }
 
     @Transaction()
     @Mutation()
     @Allow(Permission.Public)
-    authenticate(
+    async authenticate(
         @Args() args: MutationAuthenticateArgs,
         @Ctx() ctx: RequestContext,
         @Context('req') req: Request,
         @Context('res') res: Response,
-    ): Promise<LoginResult> {
-        return this.authenticateAndCreateSession(ctx, args, req, res);
+    ): Promise<AuthenticationResult> {
+        return (await this.authenticateAndCreateSession(ctx, args, req, res)) as AuthenticationResult;
     }
 
     @Transaction()
     @Mutation()
     @Allow(Permission.Public)
-    logout(
+    async logout(
         @Ctx() ctx: RequestContext,
         @Context('req') req: Request,
         @Context('res') res: Response,
-    ): Promise<boolean> {
+    ): Promise<Success> {
         return super.logout(ctx, req, res);
     }
 
@@ -103,9 +110,21 @@ export class ShopAuthResolver extends BaseAuthResolver {
     async registerCustomerAccount(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationRegisterCustomerAccountArgs,
-    ) {
-        this.requireNativeAuthStrategy();
-        return this.customerService.registerCustomerAccount(ctx, args.input).then(() => true);
+    ): Promise<RegisterCustomerAccountResult> {
+        const nativeAuthStrategyError = this.requireNativeAuthStrategy();
+        if (nativeAuthStrategyError) {
+            return nativeAuthStrategyError;
+        }
+        const result = await this.customerService.registerCustomerAccount(ctx, args.input);
+        if (isGraphQlErrorResult(result)) {
+            if (result.errorCode === ErrorCode.EMAIL_ADDRESS_CONFLICT_ERROR) {
+                // We do not want to reveal the email address conflict,
+                // otherwise account enumeration attacks become possible.
+                return { success: true };
+            }
+            return result as MissingPasswordError;
+        }
+        return { success: true };
     }
 
     @Transaction()
@@ -116,33 +135,36 @@ export class ShopAuthResolver extends BaseAuthResolver {
         @Args() args: MutationVerifyCustomerAccountArgs,
         @Context('req') req: Request,
         @Context('res') res: Response,
-    ): Promise<LoginResult> {
-        this.requireNativeAuthStrategy();
+    ): Promise<VerifyCustomerAccountResult> {
+        const nativeAuthStrategyError = this.requireNativeAuthStrategy();
+        if (nativeAuthStrategyError) {
+            return nativeAuthStrategyError;
+        }
         const { token, password } = args;
         const customer = await this.customerService.verifyCustomerEmailAddress(
             ctx,
             token,
             password || undefined,
         );
-        if (customer && customer.user) {
-            const session = await this.authService.createAuthenticatedSessionForUser(
-                ctx,
-                customer.user,
-                NATIVE_AUTH_STRATEGY_NAME,
-            );
-            setSessionToken({
-                req,
-                res,
-                authOptions: this.configService.authOptions,
-                rememberMe: true,
-                sessionToken: session.token,
-            });
-            return {
-                user: this.publiclyAccessibleUser(session.user),
-            };
-        } else {
-            throw new VerificationTokenError();
+        if (isGraphQlErrorResult(customer)) {
+            return customer;
         }
+        const session = await this.authService.createAuthenticatedSessionForUser(
+            ctx,
+            // We know that there is a user, since the Customer
+            // was found with the .getCustomerByUserId() method.
+            // tslint:disable-next-line:no-non-null-assertion
+            customer.user!,
+            NATIVE_AUTH_STRATEGY_NAME,
+        );
+        setSessionToken({
+            req,
+            res,
+            authOptions: this.configService.authOptions,
+            rememberMe: true,
+            sessionToken: session.token,
+        });
+        return this.publiclyAccessibleUser(session.user);
     }
 
     @Transaction()
@@ -151,16 +173,28 @@ export class ShopAuthResolver extends BaseAuthResolver {
     async refreshCustomerVerification(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationRefreshCustomerVerificationArgs,
-    ) {
-        this.requireNativeAuthStrategy();
-        return this.customerService.refreshVerificationToken(ctx, args.emailAddress).then(() => true);
+    ): Promise<RefreshCustomerVerificationResult> {
+        const nativeAuthStrategyError = this.requireNativeAuthStrategy();
+        if (nativeAuthStrategyError) {
+            return nativeAuthStrategyError;
+        }
+        await this.customerService.refreshVerificationToken(ctx, args.emailAddress);
+        return { success: true };
     }
 
     @Transaction()
     @Mutation()
     @Allow(Permission.Public)
-    async requestPasswordReset(@Ctx() ctx: RequestContext, @Args() args: MutationRequestPasswordResetArgs) {
-        return this.customerService.requestPasswordReset(ctx, args.emailAddress).then(() => true);
+    async requestPasswordReset(
+        @Ctx() ctx: RequestContext,
+        @Args() args: MutationRequestPasswordResetArgs,
+    ): Promise<RequestPasswordResetResult> {
+        const nativeAuthStrategyError = this.requireNativeAuthStrategy();
+        if (nativeAuthStrategyError) {
+            return nativeAuthStrategyError;
+        }
+        await this.customerService.requestPasswordReset(ctx, args.emailAddress);
+        return { success: true };
     }
 
     @Transaction()
@@ -171,27 +205,35 @@ export class ShopAuthResolver extends BaseAuthResolver {
         @Args() args: MutationResetPasswordArgs,
         @Context('req') req: Request,
         @Context('res') res: Response,
-    ) {
-        this.requireNativeAuthStrategy();
+    ): Promise<ResetPasswordResult> {
+        const nativeAuthStrategyError = this.requireNativeAuthStrategy();
+        if (nativeAuthStrategyError) {
+            return nativeAuthStrategyError;
+        }
         const { token, password } = args;
-        const customer = await this.customerService.resetPassword(ctx, token, password);
-        if (customer && customer.user) {
-            return super.authenticateAndCreateSession(
-                ctx,
-                {
-                    input: {
-                        [NATIVE_AUTH_STRATEGY_NAME]: {
-                            username: customer.user.identifier,
-                            password: args.password,
-                        },
+        const resetResult = await this.customerService.resetPassword(ctx, token, password);
+        if (isGraphQlErrorResult(resetResult)) {
+            return resetResult;
+        }
+
+        const authResult = await super.authenticateAndCreateSession(
+            ctx,
+            {
+                input: {
+                    [NATIVE_AUTH_STRATEGY_NAME]: {
+                        username: resetResult.identifier,
+                        password: args.password,
                     },
                 },
-                req,
-                res,
-            );
-        } else {
-            throw new PasswordResetTokenError();
+            },
+            req,
+            res,
+        );
+        if (isGraphQlErrorResult(authResult)) {
+            // This should never occur in theory
+            throw authResult;
         }
+        return authResult;
     }
 
     @Transaction()
@@ -200,9 +242,15 @@ export class ShopAuthResolver extends BaseAuthResolver {
     async updateCustomerPassword(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationUpdateCustomerPasswordArgs,
-    ): Promise<boolean> {
-        this.requireNativeAuthStrategy();
+    ): Promise<UpdateCustomerPasswordResult> {
+        const nativeAuthStrategyError = this.requireNativeAuthStrategy();
+        if (nativeAuthStrategyError) {
+            return nativeAuthStrategyError;
+        }
         const result = await super.updatePassword(ctx, args.currentPassword, args.newPassword);
+        if (isGraphQlErrorResult(result)) {
+            return result;
+        }
         if (result && ctx.activeUserId) {
             const customer = await this.customerService.findOneByUserId(ctx, ctx.activeUserId);
             if (customer) {
@@ -214,7 +262,7 @@ export class ShopAuthResolver extends BaseAuthResolver {
                 });
             }
         }
-        return result;
+        return { success: result };
     }
 
     @Transaction()
@@ -223,13 +271,29 @@ export class ShopAuthResolver extends BaseAuthResolver {
     async requestUpdateCustomerEmailAddress(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationRequestUpdateCustomerEmailAddressArgs,
-    ): Promise<boolean> {
-        this.requireNativeAuthStrategy();
+    ): Promise<RequestUpdateCustomerEmailAddressResult> {
+        const nativeAuthStrategyError = this.requireNativeAuthStrategy();
+        if (nativeAuthStrategyError) {
+            return nativeAuthStrategyError;
+        }
         if (!ctx.activeUserId) {
             throw new ForbiddenError();
         }
-        await this.authService.verifyUserPassword(ctx, ctx.activeUserId, args.password);
-        return this.customerService.requestUpdateEmailAddress(ctx, ctx.activeUserId, args.newEmailAddress);
+        const verify = await this.authService.verifyUserPassword(ctx, ctx.activeUserId, args.password);
+        if (isGraphQlErrorResult(verify)) {
+            return verify as InvalidCredentialsError;
+        }
+        const result = await this.customerService.requestUpdateEmailAddress(
+            ctx,
+            ctx.activeUserId,
+            args.newEmailAddress,
+        );
+        if (isGraphQlErrorResult(result)) {
+            return result;
+        }
+        return {
+            success: result,
+        };
     }
 
     @Transaction()
@@ -238,21 +302,19 @@ export class ShopAuthResolver extends BaseAuthResolver {
     async updateCustomerEmailAddress(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationUpdateCustomerEmailAddressArgs,
-    ): Promise<boolean> {
-        this.requireNativeAuthStrategy();
-        return this.customerService.updateEmailAddress(ctx, args.token);
+    ): Promise<UpdateCustomerEmailAddressResult> {
+        const nativeAuthStrategyError = this.requireNativeAuthStrategy();
+        if (nativeAuthStrategyError) {
+            return nativeAuthStrategyError;
+        }
+        const result = await this.customerService.updateEmailAddress(ctx, args.token);
+        if (isGraphQlErrorResult(result)) {
+            return result;
+        }
+        return { success: result };
     }
 
-    private requireNativeAuthStrategy() {
-        if (!this.nativeAuthStrategyIsConfigured) {
-            const authStrategyNames = this.configService.authOptions.shopAuthenticationStrategy
-                .map(s => s.name)
-                .join(', ');
-            const errorMessage =
-                'This GraphQL operation requires that the NativeAuthenticationStrategy be configured for the Shop API.\n' +
-                `Currently the following AuthenticationStrategies are enabled: ${authStrategyNames}`;
-            Logger.error(errorMessage);
-            throw new InternalServerError('error.');
-        }
+    protected requireNativeAuthStrategy() {
+        return super.requireNativeAuthStrategy() as NativeAuthStrategyError | undefined;
     }
 }

packages/core/src/api/resolvers/shop/shop-customer.resolver.ts

@@ -1,9 +1,12 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
-import { MutationDeleteCustomerAddressArgs } from '@vendure/common/lib/generated-shop-types';
+import {
+    MutationDeleteCustomerAddressArgs,
+    MutationUpdateCustomerArgs,
+    Success,
+} from '@vendure/common/lib/generated-shop-types';
 import {
     MutationCreateCustomerAddressArgs,
     MutationUpdateCustomerAddressArgs,
-    MutationUpdateCustomerArgs,
     Permission,
 } from '@vendure/common/lib/generated-types';
 
@@ -75,13 +78,14 @@ export class ShopCustomerResolver {
     async deleteCustomerAddress(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationDeleteCustomerAddressArgs,
-    ): Promise<boolean> {
+    ): Promise<Success> {
         const customer = await this.getCustomerForOwner(ctx);
         const customerAddresses = await this.customerService.findAddressesByCustomerId(ctx, customer.id);
         if (!customerAddresses.find(address => idsAreEqual(address.id, args.id))) {
             throw new ForbiddenError();
         }
-        return this.customerService.deleteAddress(ctx, args.id);
+        const success = await this.customerService.deleteAddress(ctx, args.id);
+        return { success };
     }
 
     /**

packages/core/src/api/resolvers/shop/shop-order.resolver.ts

@@ -1,5 +1,7 @@
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import {
+    AddPaymentToOrderResult,
+    ApplyCouponCodeResult,
     MutationAddItemToOrderArgs,
     MutationAddPaymentToOrderArgs,
     MutationAdjustOrderLineArgs,
@@ -14,12 +16,19 @@ import {
     Permission,
     QueryOrderArgs,
     QueryOrderByCodeArgs,
+    RemoveOrderItemsResult,
+    SetCustomerForOrderResult,
+    SetOrderShippingMethodResult,
     ShippingMethodQuote,
+    TransitionOrderToStateResult,
+    UpdateOrderItemsResult,
 } from '@vendure/common/lib/generated-shop-types';
 import { QueryCountriesArgs } from '@vendure/common/lib/generated-types';
 import ms from 'ms';
 
-import { ForbiddenError, IllegalOperationError, InternalServerError } from '../../../common/error/errors';
+import { ErrorResultUnion, isGraphQlErrorResult } from '../../../common/error/error-result';
+import { ForbiddenError, InternalServerError } from '../../../common/error/errors';
+import { AlreadyLoggedInError } from '../../../common/error/generated-graphql-shop-errors';
 import { Translated } from '../../../common/types/locale-types';
 import { idsAreEqual } from '../../../common/utils';
 import { Country } from '../../../entity';
@@ -175,7 +184,7 @@ export class ShopOrderResolver {
     async setOrderShippingMethod(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationSetOrderShippingMethodArgs,
-    ): Promise<Order | undefined> {
+    ): Promise<ErrorResultUnion<SetOrderShippingMethodResult, Order> | undefined> {
         if (ctx.authorizedAsOwnerOnly) {
             const sessionOrder = await this.getOrderFromContext(ctx);
             if (sessionOrder) {
@@ -215,10 +224,10 @@ export class ShopOrderResolver {
     async transitionOrderToState(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationTransitionOrderToStateArgs,
-    ): Promise<Order | undefined> {
+    ): Promise<ErrorResultUnion<TransitionOrderToStateResult, Order> | undefined> {
         if (ctx.authorizedAsOwnerOnly) {
             const sessionOrder = await this.getOrderFromContext(ctx, true);
-            return this.orderService.transitionToState(ctx, sessionOrder.id, args.state as OrderState);
+            return await this.orderService.transitionToState(ctx, sessionOrder.id, args.state as OrderState);
         }
     }
 
@@ -228,7 +237,7 @@ export class ShopOrderResolver {
     async addItemToOrder(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationAddItemToOrderArgs,
-    ): Promise<Order> {
+    ): Promise<ErrorResultUnion<UpdateOrderItemsResult, Order>> {
         const order = await this.getOrderFromContext(ctx, true);
         return this.orderService.addItemToOrder(
             ctx,
@@ -245,7 +254,7 @@ export class ShopOrderResolver {
     async adjustOrderLine(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationAdjustOrderLineArgs,
-    ): Promise<Order> {
+    ): Promise<ErrorResultUnion<UpdateOrderItemsResult, Order>> {
         if (args.quantity === 0) {
             return this.removeOrderLine(ctx, { orderLineId: args.orderLineId });
         }
@@ -265,7 +274,7 @@ export class ShopOrderResolver {
     async removeOrderLine(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationRemoveOrderLineArgs,
-    ): Promise<Order> {
+    ): Promise<ErrorResultUnion<RemoveOrderItemsResult, Order>> {
         const order = await this.getOrderFromContext(ctx, true);
         return this.orderService.removeItemFromOrder(ctx, order.id, args.orderLineId);
     }
@@ -273,7 +282,9 @@ export class ShopOrderResolver {
     @Transaction()
     @Mutation()
     @Allow(Permission.UpdateOrder, Permission.Owner)
-    async removeAllOrderLines(@Ctx() ctx: RequestContext): Promise<Order> {
+    async removeAllOrderLines(
+        @Ctx() ctx: RequestContext,
+    ): Promise<ErrorResultUnion<RemoveOrderItemsResult, Order>> {
         const order = await this.getOrderFromContext(ctx, true);
         return this.orderService.removeAllItemsFromOrder(ctx, order.id);
     }
@@ -284,7 +295,7 @@ export class ShopOrderResolver {
     async applyCouponCode(
         @Ctx() ctx: RequestContext,
         @Args() args: MutationApplyCouponCodeArgs,
-    ): Promise<Order> {
+    ): Promise<ErrorResultUnion<ApplyCouponCodeResult, Order>> {
         const order = await this.getOrderFromContext(ctx, true);
         return this.orderService.applyCouponCode(ctx, order.id, args.couponCode);
     }
@@ -303,11 +314,17 @@ export class ShopOrderResolver {
     @Transaction()
     @Mutation()
     @Allow(Permission.UpdateOrder, Permission.Owner)
-    async addPaymentToOrder(@Ctx() ctx: RequestContext, @Args() args: MutationAddPaymentToOrderArgs) {
+    async addPaymentToOrder(
+        @Ctx() ctx: RequestContext,
+        @Args() args: MutationAddPaymentToOrderArgs,
+    ): Promise<ErrorResultUnion<AddPaymentToOrderResult, Order> | undefined> {
         if (ctx.authorizedAsOwnerOnly) {
             const sessionOrder = await this.getOrderFromContext(ctx);
             if (sessionOrder) {
                 const order = await this.orderService.addPaymentToOrder(ctx, sessionOrder.id, args.input);
+                if (isGraphQlErrorResult(order)) {
+                    return order;
+                }
                 if (order.active === false) {
                     if (order.customer) {
                         const addresses = await this.customerService.findAddressesByCustomerId(
@@ -340,14 +357,20 @@ export class ShopOrderResolver {
     @Transaction()
     @Mutation()
     @Allow(Permission.Owner)
-    async setCustomerForOrder(@Ctx() ctx: RequestContext, @Args() args: MutationSetCustomerForOrderArgs) {
+    async setCustomerForOrder(
+        @Ctx() ctx: RequestContext,
+        @Args() args: MutationSetCustomerForOrderArgs,
+    ): Promise<ErrorResultUnion<SetCustomerForOrderResult, Order> | undefined> {
         if (ctx.authorizedAsOwnerOnly) {
             if (ctx.activeUserId) {
-                throw new IllegalOperationError('error.cannot-set-customer-for-order-when-logged-in');
+                return new AlreadyLoggedInError();
             }
             const sessionOrder = await this.getOrderFromContext(ctx);
             if (sessionOrder) {
                 const customer = await this.customerService.createOrUpdate(ctx, args.input, true);
+                if (isGraphQlErrorResult(customer)) {
+                    return customer;
+                }
                 return this.orderService.addCustomerToOrder(ctx, sessionOrder.id, customer);
             }
         }

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

@@ -7,7 +7,7 @@ type Query {
 
 type Mutation {
     "Create a new Asset"
-    createAssets(input: [CreateAssetInput!]!): [Asset!]!
+    createAssets(input: [CreateAssetInput!]!): [CreateAssetResult!]!
     "Update an existing Asset"
     updateAsset(input: UpdateAssetInput!): Asset!
     "Delete an Asset"
@@ -16,6 +16,15 @@ type Mutation {
     deleteAssets(ids: [ID!]!, force: Boolean): DeletionResponse!
 }
 
+type MimeTypeError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    fileName: String!
+    mimeType: String!
+}
+
+union CreateAssetResult = Asset | MimeTypeError
+
 # generated by generateListOptions function
 input AssetListOptions
 

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

@@ -4,11 +4,14 @@ type Query {
 
 type Mutation {
     "Authenticates the user using the native authentication strategy. This mutation is an alias for `authenticate({ native: { ... }})`"
-    login(username: String!, password: String!, rememberMe: Boolean): LoginResult!
+    login(username: String!, password: String!, rememberMe: Boolean): NativeAuthenticationResult!
     "Authenticates the user using a named authentication strategy"
-    authenticate(input: AuthenticationInput!, rememberMe: Boolean): LoginResult!
-    logout: Boolean!
+    authenticate(input: AuthenticationInput!, rememberMe: Boolean): AuthenticationResult!
+    logout: Success!
 }
 
 # Populated at run-time
 input AuthenticationInput
+
+union NativeAuthenticationResult = CurrentUser | InvalidCredentialsError | NativeAuthStrategyError
+union AuthenticationResult = CurrentUser | InvalidCredentialsError

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

@@ -6,10 +6,10 @@ type Query {
 
 type Mutation {
     "Create a new Channel"
-    createChannel(input: CreateChannelInput!): Channel!
+    createChannel(input: CreateChannelInput!): CreateChannelResult!
 
     "Update an existing Channel"
-    updateChannel(input: UpdateChannelInput!): Channel!
+    updateChannel(input: UpdateChannelInput!): UpdateChannelResult!
 
     "Delete a Channel"
     deleteChannel(id: ID!): DeletionResponse!
@@ -35,3 +35,13 @@ input UpdateChannelInput {
     defaultTaxZoneId: ID
     defaultShippingZoneId: ID
 }
+
+"Returned if attempting to set a Channel's defaultLanguageCode to a language which is not enabled in GlobalSettings"
+type LanguageNotAvailableError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    languageCode: String!
+}
+
+union CreateChannelResult = Channel | LanguageNotAvailableError
+union UpdateChannelResult = Channel | LanguageNotAvailableError

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

@@ -5,10 +5,10 @@ type Query {
 
 type Mutation {
     "Create a new Customer. If a password is provided, a new User will also be created an linked to the Customer."
-    createCustomer(input: CreateCustomerInput!, password: String): Customer!
+    createCustomer(input: CreateCustomerInput!, password: String): CreateCustomerResult!
 
     "Update an existing Customer"
-    updateCustomer(input: UpdateCustomerInput!): Customer!
+    updateCustomer(input: UpdateCustomerInput!): UpdateCustomerResult!
 
     "Delete a Customer"
     deleteCustomer(id: ID!): DeletionResponse!
@@ -20,7 +20,7 @@ type Mutation {
     updateCustomerAddress(input: UpdateAddressInput!): Address!
 
     "Update an existing Address"
-    deleteCustomerAddress(id: ID!): Boolean!
+    deleteCustomerAddress(id: ID!): Success!
 
     addNoteToCustomer(input: AddNoteToCustomerInput!): Customer!
     updateCustomerNote(input: UpdateCustomerNoteInput!): HistoryEntry!
@@ -56,3 +56,6 @@ input UpdateCustomerNoteInput {
     note: String!
 }
 
+union CreateCustomerResult = Customer | EmailAddressConflictError
+union UpdateCustomerResult = Customer | EmailAddressConflictError
+

packages/core/src/api/schema/admin-api/global-settings.api.graphql

@@ -3,10 +3,23 @@ type Query {
 }
 
 type Mutation {
-    updateGlobalSettings(input: UpdateGlobalSettingsInput!): GlobalSettings!
+    updateGlobalSettings(input: UpdateGlobalSettingsInput!): UpdateGlobalSettingsResult!
 }
 
 input UpdateGlobalSettingsInput {
     availableLanguages: [LanguageCode!]
     trackInventory: Boolean
 }
+
+"""
+Returned when the default LanguageCode of a Channel is no longer found in the `availableLanguages`
+of the GlobalSettings
+"""
+type ChannelDefaultLanguageError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    language: String!
+    channelCode: String!
+}
+
+union UpdateGlobalSettingsResult = GlobalSettings | ChannelDefaultLanguageError

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

@@ -4,16 +4,16 @@ type Query {
 }
 
 type Mutation {
-    settlePayment(id: ID!): Payment!
-    fulfillOrder(input: FulfillOrderInput!): Fulfillment!
-    cancelOrder(input: CancelOrderInput!): Order!
-    refundOrder(input: RefundOrderInput!): Refund!
-    settleRefund(input: SettleRefundInput!): Refund!
+    settlePayment(id: ID!): SettlePaymentResult!
+    addFulfillmentToOrder(input: FulfillOrderInput!): AddFulfillmentToOrderResult!
+    cancelOrder(input: CancelOrderInput!): CancelOrderResult!
+    refundOrder(input: RefundOrderInput!): RefundOrderResult!
+    settleRefund(input: SettleRefundInput!): SettleRefundResult!
     addNoteToOrder(input: AddNoteToOrderInput!): Order!
     updateOrderNote(input: UpdateOrderNoteInput!): HistoryEntry!
     deleteOrderNote(id: ID!): DeletionResponse!
-    transitionOrderToState(id: ID!, state: String!): Order
-    transitionFulfillmentToState(id: ID!, state: String!): Fulfillment!
+    transitionOrderToState(id: ID!, state: String!): TransitionOrderToStateResult
+    transitionFulfillmentToState(id: ID!, state: String!): TransitionFulfillmentToStateResult!
     setOrderCustomFields(input: UpdateOrderInput!): Order
 }
 
@@ -72,3 +72,117 @@ input UpdateOrderNoteInput {
     note: String
     isPublic: Boolean
 }
+
+"Returned if the Payment settlement fails"
+type SettlePaymentError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    paymentErrorMessage: String!
+}
+
+"Returned if no OrderLines have been specified for the operation"
+type EmptyOrderLineSelectionError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Returned if the specified items are already part of a Fulfillment"
+type ItemsAlreadyFulfilledError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Returned if an operation has specified OrderLines from multiple Orders"
+type MultipleOrderError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Returned if an attempting to cancel lines from an Order which is still active"
+type CancelActiveOrderError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    orderState: String!
+}
+
+"Returned if an attempting to refund a Payment against OrderLines from a different Order"
+type PaymentOrderMismatchError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Returned if an attempting to refund an Order which is not in the expected state"
+type RefundOrderStateError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    orderState: String!
+}
+
+"Returned if an attempting to refund an Order but neither items nor shipping refund was specified"
+type NothingToRefundError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Returned if an attempting to refund an OrderItem which has already been refunded"
+type AlreadyRefundedError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    refundId: ID!
+}
+
+"Returned if the specified quantity of an OrderLine is greater than the number of items in that line"
+type QuantityTooGreatError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Returned when there is an error in transitioning the Refund state"
+type RefundStateTransitionError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    transitionError: String!
+    fromState: String!
+    toState: String!
+}
+
+"Returned when there is an error in transitioning the Payment state"
+type PaymentStateTransitionError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    transitionError: String!
+    fromState: String!
+    toState: String!
+}
+
+"Returned when there is an error in transitioning the Fulfillment state"
+type FulfillmentStateTransitionError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    transitionError: String!
+    fromState: String!
+    toState: String!
+}
+
+union TransitionOrderToStateResult = Order | OrderStateTransitionError
+union SettlePaymentResult = Payment | SettlePaymentError | PaymentStateTransitionError | OrderStateTransitionError
+union AddFulfillmentToOrderResult = Fulfillment | EmptyOrderLineSelectionError | ItemsAlreadyFulfilledError
+union CancelOrderResult =
+      Order
+    | EmptyOrderLineSelectionError
+    | QuantityTooGreatError
+    | MultipleOrderError
+    | CancelActiveOrderError
+    | OrderStateTransitionError
+union RefundOrderResult =
+      Refund
+    | QuantityTooGreatError
+    | NothingToRefundError
+    | OrderStateTransitionError
+    | MultipleOrderError
+    | PaymentOrderMismatchError
+    | RefundOrderStateError
+    | AlreadyRefundedError
+    | RefundStateTransitionError
+union SettleRefundResult = Refund | RefundStateTransitionError
+union TransitionFulfillmentToStateResult = Fulfillment | FulfillmentStateTransitionError

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

@@ -20,7 +20,7 @@ type Mutation {
     addOptionGroupToProduct(productId: ID!, optionGroupId: ID!): Product!
 
     "Remove an OptionGroup from a Product"
-    removeOptionGroupFromProduct(productId: ID!, optionGroupId: ID!): Product!
+    removeOptionGroupFromProduct(productId: ID!, optionGroupId: ID!): RemoveOptionGroupFromProductResult!
 
     "Create a set of ProductVariants based on the OptionGroups assigned to the given Product"
     createProductVariants(input: [CreateProductVariantInput!]!): [ProductVariant]!
@@ -139,3 +139,12 @@ input RemoveProductsFromChannelInput {
     productIds: [ID!]!
     channelId: ID!
 }
+
+type ProductOptionInUseError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    optionGroupCode: String!
+    productVariantCount: Int!
+}
+
+union RemoveOptionGroupFromProductResult = Product | ProductOptionInUseError

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

@@ -6,8 +6,8 @@ type Query {
 }
 
 type Mutation {
-    createPromotion(input: CreatePromotionInput!): Promotion!
-    updatePromotion(input: UpdatePromotionInput!): Promotion!
+    createPromotion(input: CreatePromotionInput!): CreatePromotionResult!
+    updatePromotion(input: UpdatePromotionInput!): UpdatePromotionResult!
     deletePromotion(id: ID!): DeletionResponse!
 }
 
@@ -36,3 +36,12 @@ input UpdatePromotionInput {
     conditions: [ConfigurableOperationInput!]
     actions: [ConfigurableOperationInput!]
 }
+
+"Returned if a PromotionCondition has neither a couponCode nor any conditions set"
+type MissingConditionsError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+union CreatePromotionResult = Promotion | MissingConditionsError
+union UpdatePromotionResult = Promotion | MissingConditionsError

packages/core/src/api/schema/common/common-types.graphql

@@ -81,6 +81,15 @@ enum SortOrder {
     DESC
 }
 
+enum ErrorCode {
+    UNKNOWN_ERROR
+}
+
+interface ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
 input StringOperators {
     eq: String
     contains: String
@@ -174,3 +183,37 @@ input UpdateAddressInput {
     defaultShippingAddress: Boolean
     defaultBillingAddress: Boolean
 }
+
+"""
+Indicates that an operation succeeded, where we do not want to return any more specific information.
+"""
+type Success {
+    success: Boolean!
+}
+
+"Retured when attempting an operation that relies on the NativeAuthStrategy, if that strategy is not configured."
+type NativeAuthStrategyError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Returned if the user authentication credentials are not valid"
+type InvalidCredentialsError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Returned if there is an error in transitioning the Order state"
+type OrderStateTransitionError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    transitionError: String!
+    fromState: String!
+    toState: String!
+}
+
+"Retured when attemting to create a Customer with an email address already registered to an existing User."
+type EmailAddressConflictError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}

packages/core/src/api/schema/shop-api/shop.api.graphql

@@ -43,19 +43,19 @@ type Query {
 
 type Mutation {
     "Adds an item to the order. If custom fields are defined on the OrderLine entity, a third argument 'customFields' will be available."
-    addItemToOrder(productVariantId: ID!, quantity: Int!): Order
+    addItemToOrder(productVariantId: ID!, quantity: Int!): UpdateOrderItemsResult!
     "Remove an OrderLine from the Order"
-    removeOrderLine(orderLineId: ID!): Order
+    removeOrderLine(orderLineId: ID!): RemoveOrderItemsResult!
     "Remove all OrderLine from the Order"
-    removeAllOrderLines: Order
+    removeAllOrderLines: RemoveOrderItemsResult!
     "Adjusts an OrderLine. If custom fields are defined on the OrderLine entity, a third argument 'customFields' of type `OrderLineCustomFieldsInput` will be available."
-    adjustOrderLine(orderLineId: ID!, quantity: Int): Order
+    adjustOrderLine(orderLineId: ID!, quantity: Int): UpdateOrderItemsResult!
     "Applies the given coupon code to the active Order"
-    applyCouponCode(couponCode: String!): Order
+    applyCouponCode(couponCode: String!): ApplyCouponCodeResult!
     "Removes the given coupon code from the active Order"
     removeCouponCode(couponCode: String!): Order
     "Transitions an Order to a new state. Valid next states can be found by querying `nextOrderStates`"
-    transitionOrderToState(state: String!): Order
+    transitionOrderToState(state: String!): TransitionOrderToStateResult
     "Sets the shipping address for this order"
     setOrderShippingAddress(input: CreateAddressInput!): Order
     "Sets the billing address for this order"
@@ -63,19 +63,17 @@ type Mutation {
     "Allows any custom fields to be set for the active order"
     setOrderCustomFields(input: UpdateOrderInput!): Order
     "Sets the shipping method by id, which can be obtained with the `eligibleShippingMethods` query"
-    setOrderShippingMethod(shippingMethodId: ID!): Order
+    setOrderShippingMethod(shippingMethodId: ID!): SetOrderShippingMethodResult!
     "Add a Payment to the Order"
-    addPaymentToOrder(input: PaymentInput!): Order
+    addPaymentToOrder(input: PaymentInput!): AddPaymentToOrderResult
     "Set the Customer for the Order. Required only if the Customer is not currently logged in"
-    setCustomerForOrder(input: CreateCustomerInput!): Order
+    setCustomerForOrder(input: CreateCustomerInput!): SetCustomerForOrderResult
     "Authenticates the user using the native authentication strategy. This mutation is an alias for `authenticate({ native: { ... }})`"
-    login(username: String!, password: String!, rememberMe: Boolean): LoginResult!
+    login(username: String!, password: String!, rememberMe: Boolean): NativeAuthenticationResult!
     "Authenticates the user using a named authentication strategy"
-    authenticate(input: AuthenticationInput!, rememberMe: Boolean): LoginResult!
+    authenticate(input: AuthenticationInput!, rememberMe: Boolean): AuthenticationResult!
     "End the current authenticated session"
-    logout: Boolean!
-    "Regenerate and send a verification token for a new Customer registration. Only applicable if `authOptions.requireVerification` is set to true."
-    refreshCustomerVerification(emailAddress: String!): Boolean!
+    logout: Success!
     """
     Register a Customer account with the given credentials. There are three possible registration flows:
 
@@ -92,7 +90,9 @@ type Mutation {
 
     3. The Customer _must_ be registered _with_ a password. No further action is needed - the Customer is able to authenticate immediately.
     """
-    registerCustomerAccount(input: RegisterCustomerInput!): Boolean!
+    registerCustomerAccount(input: RegisterCustomerInput!): RegisterCustomerAccountResult!
+    "Regenerate and send a verification token for a new Customer registration. Only applicable if `authOptions.requireVerification` is set to true."
+    refreshCustomerVerification(emailAddress: String!): RefreshCustomerVerificationResult!
     "Update an existing Customer"
     updateCustomer(input: UpdateCustomerInput!): Customer!
     "Create a new Customer Address"
@@ -100,32 +100,35 @@ type Mutation {
     "Update an existing Address"
     updateCustomerAddress(input: UpdateAddressInput!): Address!
     "Delete an existing Address"
-    deleteCustomerAddress(id: ID!): Boolean!
+    deleteCustomerAddress(id: ID!): Success!
     """
     Verify a Customer email address with the token sent to that address. Only applicable if `authOptions.requireVerification` is set to true.
 
     If the Customer was not registered with a password in the `registerCustomerAccount` mutation, the a password _must_ be
     provided here.
     """
-    verifyCustomerAccount(token: String!, password: String): LoginResult!
+    verifyCustomerAccount(token: String!, password: String): VerifyCustomerAccountResult!
     "Update the password of the active Customer"
-    updateCustomerPassword(currentPassword: String!, newPassword: String!): Boolean
+    updateCustomerPassword(currentPassword: String!, newPassword: String!): UpdateCustomerPasswordResult!
     """
     Request to update the emailAddress of the active Customer. If `authOptions.requireVerification` is enabled
     (as is the default), then the `identifierChangeToken` will be assigned to the current User and
     a IdentifierChangeRequestEvent will be raised. This can then be used e.g. by the EmailPlugin to email
     that verification token to the Customer, which is then used to verify the change of email address.
     """
-    requestUpdateCustomerEmailAddress(password: String!, newEmailAddress: String!): Boolean
+    requestUpdateCustomerEmailAddress(
+        password: String!
+        newEmailAddress: String!
+    ): RequestUpdateCustomerEmailAddressResult!
     """
     Confirm the update of the emailAddress with the provided token, which has been generated by the
     `requestUpdateCustomerEmailAddress` mutation.
     """
-    updateCustomerEmailAddress(token: String!): Boolean
+    updateCustomerEmailAddress(token: String!): UpdateCustomerEmailAddressResult!
     "Requests a password reset email to be sent"
-    requestPasswordReset(emailAddress: String!): Boolean
+    requestPasswordReset(emailAddress: String!): RequestPasswordResetResult
     "Resets a Customer's password based on the provided token"
-    resetPassword(token: String!, password: String!): LoginResult!
+    resetPassword(token: String!, password: String!): ResetPasswordResult!
 }
 
 # Populated at run-time
@@ -174,3 +177,180 @@ input OrderListOptions
 
 # generated by generateListOptions function
 input ProductListOptions
+
+"Returned when attempting to modify the contents of an Order that is not in the `AddingItems` state."
+type OrderModificationError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Retured when the maximum order size limit has been reached."
+type OrderLimitError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    maxItems: Int!
+}
+
+"Retured when attemting to set a negative OrderLine quantity."
+type NegativeQuantityError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Returned when attempting to add a Payment to an Order that is not in the `ArrangingPayment` state."
+type OrderPaymentStateError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Returned when a Payment fails due to an error."
+type PaymentFailedError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    paymentErrorMessage: String!
+}
+
+"Returned when a Payment is declined by the payment provider."
+type PaymentDeclinedError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    paymentErrorMessage: String!
+}
+
+"Returned if the provided coupon code is invalid"
+type CouponCodeInvalidError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    couponCode: String!
+}
+
+"Returned if the provided coupon code is invalid"
+type CouponCodeInvalidError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    couponCode: String!
+}
+
+"Returned if the provided coupon code is invalid"
+type CouponCodeExpiredError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    couponCode: String!
+}
+
+"Returned if the provided coupon code is invalid"
+type CouponCodeLimitError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+    couponCode: String!
+    limit: Int!
+}
+
+"Retured when attemting to set the Customer for an Order when already logged in."
+type AlreadyLoggedInError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Retured when attemting to register or verify a customer account without a password, when one is required."
+type MissingPasswordError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"Retured when attemting to verify a customer account with a password, when a password has already been set."
+type PasswordAlreadySetError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"""
+Retured if the verification token (used to verify a Customer's email address) is either
+invalid or does not match any expected tokens.
+"""
+type VerificationTokenInvalidError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"""
+Returned if the verification token (used to verify a Customer's email address) is valid, but has
+expired according to the `verificationTokenDuration` setting in the AuthOptions.
+"""
+type VerificationTokenExpiredError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"""
+Retured if the token used to change a Customer's email address is either
+invalid or does not match any expected tokens.
+"""
+type IdentifierChangeTokenInvalidError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"""
+Retured if the token used to change a Customer's email address is valid, but has
+expired according to the `verificationTokenDuration` setting in the AuthOptions.
+"""
+type IdentifierChangeTokenExpiredError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"""
+Retured if the token used to reset a Customer's password is either
+invalid or does not match any expected tokens.
+"""
+type PasswordResetTokenInvalidError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+"""
+Retured if the token used to reset a Customer's password is valid, but has
+expired according to the `verificationTokenDuration` setting in the AuthOptions.
+"""
+type PasswordResetTokenExpiredError implements ErrorResult {
+    errorCode: ErrorCode!
+    message: String!
+}
+
+union UpdateOrderItemsResult = Order | OrderModificationError | OrderLimitError | NegativeQuantityError
+union RemoveOrderItemsResult = Order | OrderModificationError
+union SetOrderShippingMethodResult = Order | OrderModificationError
+union ApplyCouponCodeResult = Order | CouponCodeExpiredError | CouponCodeInvalidError | CouponCodeLimitError
+union AddPaymentToOrderResult =
+      Order
+    | OrderPaymentStateError
+    | PaymentFailedError
+    | PaymentDeclinedError
+    | OrderStateTransitionError
+union TransitionOrderToStateResult = Order | OrderStateTransitionError
+union SetCustomerForOrderResult = Order | AlreadyLoggedInError | EmailAddressConflictError
+union RegisterCustomerAccountResult = Success | MissingPasswordError | NativeAuthStrategyError
+union RefreshCustomerVerificationResult = Success | NativeAuthStrategyError
+union VerifyCustomerAccountResult =
+      CurrentUser
+    | VerificationTokenInvalidError
+    | VerificationTokenExpiredError
+    | MissingPasswordError
+    | PasswordAlreadySetError
+    | NativeAuthStrategyError
+union UpdateCustomerPasswordResult = Success | InvalidCredentialsError | NativeAuthStrategyError
+union RequestUpdateCustomerEmailAddressResult =
+      Success
+    | InvalidCredentialsError
+    | EmailAddressConflictError
+    | NativeAuthStrategyError
+union UpdateCustomerEmailAddressResult =
+      Success
+    | IdentifierChangeTokenInvalidError
+    | IdentifierChangeTokenExpiredError
+    | NativeAuthStrategyError
+union RequestPasswordResetResult = Success | NativeAuthStrategyError
+union ResetPasswordResult = CurrentUser | PasswordResetTokenInvalidError | PasswordResetTokenExpiredError | NativeAuthStrategyError
+union NativeAuthenticationResult = CurrentUser | InvalidCredentialsError | NativeAuthStrategyError
+union AuthenticationResult = CurrentUser | InvalidCredentialsError

packages/core/src/api/schema/type/auth.type.graphql

@@ -1,7 +1,3 @@
-type LoginResult {
-    user: CurrentUser!
-}
-
 type CurrentUser {
     id: ID!
     identifier: String!

packages/core/src/common/error/error-result.ts

@@ -0,0 +1,63 @@
+import { ErrorResult as GraphQLErrorResultShop } from '@vendure/common/lib/generated-shop-types';
+import { ErrorResult, ErrorResult as GraphQLErrorResultAdmin } from '@vendure/common/lib/generated-types';
+
+import { VendureEntity } from '../../entity/base/base.entity';
+
+export type GraphQLErrorResult = GraphQLErrorResultShop | GraphQLErrorResultAdmin;
+
+/**
+ * @description
+ * Takes an ErrorResult union type (i.e. a generated union type consisting of some query/mutation result
+ * plus one or more ErrorResult types) and returns a union of _just_ the ErrorResult types.
+ *
+ * @example
+ * ```TypeScript
+ * type UpdateOrderItemsResult = Order | OrderModificationError | OrderLimitError | NegativeQuantityError;
+ *
+ * type T1 = JustErrorResults<UpdateOrderItemsResult>;
+ * // T1 = OrderModificationError | OrderLimitError | NegativeQuantityError
+ * ```
+ */
+export type JustErrorResults<T extends GraphQLErrorResult | U, U = any> = Exclude<
+    T,
+    T extends GraphQLErrorResult ? never : T
+>;
+
+/**
+ * @description
+ * Used to construct a TypeScript return type for a query or mutation which, in the GraphQL schema,
+ * returns a union type composed of a success result (e.g. Order) plus one or more ErrorResult
+ * types.
+ *
+ * Since the TypeScript entities do not correspond 1-to-1 with their GraphQL type counterparts,
+ * we use this type to substitute them.
+ *
+ * @example
+ * ```TypeScript
+ * type UpdateOrderItemsResult = Order | OrderModificationError | OrderLimitError | NegativeQuantityError;
+ * type T1 = ErrorResultUnion<UpdateOrderItemsResult, VendureEntityOrder>;
+ * // T1 = VendureEntityOrder | OrderModificationError | OrderLimitError | NegativeQuantityError;
+ */
+export type ErrorResultUnion<T extends GraphQLErrorResult | U, E extends VendureEntity, U = any> =
+    | JustErrorResults<T>
+    | E;
+
+/**
+ * @description
+ * Returns true if the ErrorResultUnion is actually an ErrorResult type.
+ */
+export function isGraphQlErrorResult<T extends GraphQLErrorResult | U, U = any>(
+    input: T,
+): input is JustErrorResults<T>;
+export function isGraphQlErrorResult<T, E extends VendureEntity>(
+    input: ErrorResultUnion<T, E>,
+): input is JustErrorResults<ErrorResultUnion<T, E>> {
+    return (
+        input &&
+        !!(
+            ((input as unknown) as GraphQLErrorResult).errorCode &&
+            ((input as unknown) as GraphQLErrorResult).message != null
+        ) &&
+        (input as any).__typename
+    );
+}

packages/core/src/common/error/errors.ts

@@ -98,100 +98,6 @@ export class EntityNotFoundError extends I18nError {
     }
 }
 
-/**
- * @description
- * This error should be thrown when the verification token (used to verify a Customer's email
- * address) is either invalid or does not match any expected tokens.
- *
- * @docsCategory errors
- * @docsPage Error Types
- */
-export class VerificationTokenError extends I18nError {
-    constructor() {
-        super('error.verification-token-not-recognized', {}, 'BAD_VERIFICATION_TOKEN', LogLevel.Warn);
-    }
-}
-
-/**
- * @description
- * This error should be thrown when the verification token (used to verify a Customer's email
- * address) is valid, but has expired according to the `verificationTokenDuration` setting
- * in {@link AuthOptions}.
- *
- * @docsCategory errors
- * @docsPage Error Types
- */
-export class VerificationTokenExpiredError extends I18nError {
-    constructor() {
-        super('error.verification-token-has-expired', {}, 'EXPIRED_VERIFICATION_TOKEN', LogLevel.Warn);
-    }
-}
-
-/**
- * @description
- * This error should be thrown when an error occurs trying to reset a Customer's password.
- *
- * @docsCategory errors
- * @docsPage Error Types
- */
-export class PasswordResetTokenError extends I18nError {
-    constructor() {
-        super('error.password-reset-token-not-recognized', {}, 'BAD_PASSWORD_RESET_TOKEN', LogLevel.Warn);
-    }
-}
-
-/**
- * @description
- * This error should be thrown when an error occurs trying to reset a Customer's password
- * by reason of the token having expired.
- *
- * @docsCategory errors
- * @docsPage Error Types
- */
-export class PasswordResetTokenExpiredError extends I18nError {
-    constructor() {
-        super('error.password-reset-token-has-expired', {}, 'EXPIRED_PASSWORD_RESET_TOKEN', LogLevel.Warn);
-    }
-}
-
-/**
- * @description
- * This error should be thrown when an error occurs when attempting to update a User's identifier
- * (e.g. change email address).
- *
- * @docsCategory errors
- * @docsPage Error Types
- */
-export class IdentifierChangeTokenError extends I18nError {
-    constructor() {
-        super(
-            'error.identifier-change-token-not-recognized',
-            {},
-            'EXPIRED_IDENTIFIER_CHANGE_TOKEN',
-            LogLevel.Warn,
-        );
-    }
-}
-
-/**
- * @description
- * This error should be thrown when an error occurs when attempting to update a User's identifier
- * (e.g. change email address) by reason of the token having expired.
- *
- * @docsCategory errors
- * @docsPage Error Types
- */
-export class IdentifierChangeTokenExpiredError extends I18nError {
-    constructor() {
-        super(
-            'error.identifier-change-token-has-expired',
-            {},
-            'EXPIRED_IDENTIFIER_CHANGE_TOKEN',
-            LogLevel.Warn,
-        );
-    }
-}
-
 /**
  * @description
  * This error should be thrown when the `requireVerification` in {@link AuthOptions} is set to
@@ -205,61 +111,3 @@ export class NotVerifiedError extends I18nError {
         super('error.email-address-not-verified', {}, 'NOT_VERIFIED', LogLevel.Warn);
     }
 }
-
-/**
- * @description
- * This error should be thrown when the number or OrderItems in an Order exceeds the limit
- * specified by the `orderItemsLimit` setting in {@link OrderOptions}.
- *
- * @docsCategory errors
- * @docsPage Error Types
- */
-export class OrderItemsLimitError extends I18nError {
-    constructor(maxItems: number) {
-        super('error.order-items-limit-exceeded', { maxItems }, 'ORDER_ITEMS_LIMIT_EXCEEDED', LogLevel.Warn);
-    }
-}
-
-/**
- * @description
- * This error is thrown when the coupon code is not associated with any active Promotion.
- *
- * @docsCategory errors
- * @docsPage Error Types
- */
-export class CouponCodeInvalidError extends I18nError {
-    constructor(couponCode: string) {
-        super('error.coupon-code-not-valid', { couponCode }, 'COUPON_CODE_INVALID', LogLevel.Verbose);
-    }
-}
-
-/**
- * @description
- * This error is thrown when the coupon code is associated with a Promotion that has expired.
- *
- * @docsCategory errors
- * @docsPage Error Types
- */
-export class CouponCodeExpiredError extends I18nError {
-    constructor(couponCode: string) {
-        super('error.coupon-code-expired', { couponCode }, 'COUPON_CODE_EXPIRED', LogLevel.Verbose);
-    }
-}
-
-/**
- * @description
- * This error is thrown when the coupon code is associated with a Promotion that has expired.
- *
- * @docsCategory errors
- * @docsPage Error Types
- */
-export class CouponCodeLimitError extends I18nError {
-    constructor(limit: number) {
-        super(
-            'error.coupon-code-limit-has-been-reached',
-            { limit },
-            'COUPON_CODE_LIMIT_REACHED',
-            LogLevel.Verbose,
-        );
-    }
-}

packages/core/src/common/error/generated-graphql-admin-errors.ts

@@ -0,0 +1,361 @@
+// tslint:disable
+/** This file was generated by the graphql-errors-plugin, which is part of the "codegen" npm script. */
+
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+  DateTime: any;
+  JSON: any;
+  Upload: any;
+};
+
+export class ErrorResult {
+  readonly __typename: string;
+  readonly errorCode: string;
+  message: Scalars['String'];
+}
+
+export class AlreadyRefundedError extends ErrorResult {
+  readonly __typename = 'AlreadyRefundedError';
+  readonly errorCode = 'ALREADY_REFUNDED_ERROR' as any;
+  readonly message = 'ALREADY_REFUNDED_ERROR';
+  constructor(
+    public   refundId: Scalars['ID'],
+  ) {
+    super();
+  }
+}
+
+export class CancelActiveOrderError extends ErrorResult {
+  readonly __typename = 'CancelActiveOrderError';
+  readonly errorCode = 'CANCEL_ACTIVE_ORDER_ERROR' as any;
+  readonly message = 'CANCEL_ACTIVE_ORDER_ERROR';
+  constructor(
+    public   orderState: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class ChannelDefaultLanguageError extends ErrorResult {
+  readonly __typename = 'ChannelDefaultLanguageError';
+  readonly errorCode = 'CHANNEL_DEFAULT_LANGUAGE_ERROR' as any;
+  readonly message = 'CHANNEL_DEFAULT_LANGUAGE_ERROR';
+  constructor(
+    public   language: Scalars['String'],
+    public   channelCode: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class EmailAddressConflictError extends ErrorResult {
+  readonly __typename = 'EmailAddressConflictError';
+  readonly errorCode = 'EMAIL_ADDRESS_CONFLICT_ERROR' as any;
+  readonly message = 'EMAIL_ADDRESS_CONFLICT_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class EmptyOrderLineSelectionError extends ErrorResult {
+  readonly __typename = 'EmptyOrderLineSelectionError';
+  readonly errorCode = 'EMPTY_ORDER_LINE_SELECTION_ERROR' as any;
+  readonly message = 'EMPTY_ORDER_LINE_SELECTION_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class FulfillmentStateTransitionError extends ErrorResult {
+  readonly __typename = 'FulfillmentStateTransitionError';
+  readonly errorCode = 'FULFILLMENT_STATE_TRANSITION_ERROR' as any;
+  readonly message = 'FULFILLMENT_STATE_TRANSITION_ERROR';
+  constructor(
+    public   transitionError: Scalars['String'],
+    public   fromState: Scalars['String'],
+    public   toState: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class InvalidCredentialsError extends ErrorResult {
+  readonly __typename = 'InvalidCredentialsError';
+  readonly errorCode = 'INVALID_CREDENTIALS_ERROR' as any;
+  readonly message = 'INVALID_CREDENTIALS_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class ItemsAlreadyFulfilledError extends ErrorResult {
+  readonly __typename = 'ItemsAlreadyFulfilledError';
+  readonly errorCode = 'ITEMS_ALREADY_FULFILLED_ERROR' as any;
+  readonly message = 'ITEMS_ALREADY_FULFILLED_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class LanguageNotAvailableError extends ErrorResult {
+  readonly __typename = 'LanguageNotAvailableError';
+  readonly errorCode = 'LANGUAGE_NOT_AVAILABLE_ERROR' as any;
+  readonly message = 'LANGUAGE_NOT_AVAILABLE_ERROR';
+  constructor(
+    public   languageCode: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class MimeTypeError extends ErrorResult {
+  readonly __typename = 'MimeTypeError';
+  readonly errorCode = 'MIME_TYPE_ERROR' as any;
+  readonly message = 'MIME_TYPE_ERROR';
+  constructor(
+    public   fileName: Scalars['String'],
+    public   mimeType: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class MissingConditionsError extends ErrorResult {
+  readonly __typename = 'MissingConditionsError';
+  readonly errorCode = 'MISSING_CONDITIONS_ERROR' as any;
+  readonly message = 'MISSING_CONDITIONS_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class MultipleOrderError extends ErrorResult {
+  readonly __typename = 'MultipleOrderError';
+  readonly errorCode = 'MULTIPLE_ORDER_ERROR' as any;
+  readonly message = 'MULTIPLE_ORDER_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class NativeAuthStrategyError extends ErrorResult {
+  readonly __typename = 'NativeAuthStrategyError';
+  readonly errorCode = 'NATIVE_AUTH_STRATEGY_ERROR' as any;
+  readonly message = 'NATIVE_AUTH_STRATEGY_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class NothingToRefundError extends ErrorResult {
+  readonly __typename = 'NothingToRefundError';
+  readonly errorCode = 'NOTHING_TO_REFUND_ERROR' as any;
+  readonly message = 'NOTHING_TO_REFUND_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class OrderStateTransitionError extends ErrorResult {
+  readonly __typename = 'OrderStateTransitionError';
+  readonly errorCode = 'ORDER_STATE_TRANSITION_ERROR' as any;
+  readonly message = 'ORDER_STATE_TRANSITION_ERROR';
+  constructor(
+    public   transitionError: Scalars['String'],
+    public   fromState: Scalars['String'],
+    public   toState: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class PaymentOrderMismatchError extends ErrorResult {
+  readonly __typename = 'PaymentOrderMismatchError';
+  readonly errorCode = 'PAYMENT_ORDER_MISMATCH_ERROR' as any;
+  readonly message = 'PAYMENT_ORDER_MISMATCH_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class PaymentStateTransitionError extends ErrorResult {
+  readonly __typename = 'PaymentStateTransitionError';
+  readonly errorCode = 'PAYMENT_STATE_TRANSITION_ERROR' as any;
+  readonly message = 'PAYMENT_STATE_TRANSITION_ERROR';
+  constructor(
+    public   transitionError: Scalars['String'],
+    public   fromState: Scalars['String'],
+    public   toState: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class ProductOptionInUseError extends ErrorResult {
+  readonly __typename = 'ProductOptionInUseError';
+  readonly errorCode = 'PRODUCT_OPTION_IN_USE_ERROR' as any;
+  readonly message = 'PRODUCT_OPTION_IN_USE_ERROR';
+  constructor(
+    public   optionGroupCode: Scalars['String'],
+    public   productVariantCount: Scalars['Int'],
+  ) {
+    super();
+  }
+}
+
+export class QuantityTooGreatError extends ErrorResult {
+  readonly __typename = 'QuantityTooGreatError';
+  readonly errorCode = 'QUANTITY_TOO_GREAT_ERROR' as any;
+  readonly message = 'QUANTITY_TOO_GREAT_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class RefundOrderStateError extends ErrorResult {
+  readonly __typename = 'RefundOrderStateError';
+  readonly errorCode = 'REFUND_ORDER_STATE_ERROR' as any;
+  readonly message = 'REFUND_ORDER_STATE_ERROR';
+  constructor(
+    public   orderState: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class RefundStateTransitionError extends ErrorResult {
+  readonly __typename = 'RefundStateTransitionError';
+  readonly errorCode = 'REFUND_STATE_TRANSITION_ERROR' as any;
+  readonly message = 'REFUND_STATE_TRANSITION_ERROR';
+  constructor(
+    public   transitionError: Scalars['String'],
+    public   fromState: Scalars['String'],
+    public   toState: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class SettlePaymentError extends ErrorResult {
+  readonly __typename = 'SettlePaymentError';
+  readonly errorCode = 'SETTLE_PAYMENT_ERROR' as any;
+  readonly message = 'SETTLE_PAYMENT_ERROR';
+  constructor(
+    public   paymentErrorMessage: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+
+const errorTypeNames = new Set(['MimeTypeError', 'InvalidCredentialsError', 'NativeAuthStrategyError', 'LanguageNotAvailableError', 'EmailAddressConflictError', 'ChannelDefaultLanguageError', 'SettlePaymentError', 'PaymentStateTransitionError', 'OrderStateTransitionError', 'EmptyOrderLineSelectionError', 'ItemsAlreadyFulfilledError', 'QuantityTooGreatError', 'MultipleOrderError', 'CancelActiveOrderError', 'NothingToRefundError', 'PaymentOrderMismatchError', 'RefundOrderStateError', 'AlreadyRefundedError', 'RefundStateTransitionError', 'FulfillmentStateTransitionError', 'ProductOptionInUseError', 'MissingConditionsError']);
+function isGraphQLError(input: any): input is import('@vendure/common/lib/generated-types').ErrorResult {
+  return input instanceof ErrorResult || errorTypeNames.has(input.__typename);
+}
+
+export const adminErrorOperationTypeResolvers = {
+  CreateAssetResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Asset';
+    },
+  },
+  NativeAuthenticationResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'CurrentUser';
+    },
+  },
+  AuthenticationResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'CurrentUser';
+    },
+  },
+  CreateChannelResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Channel';
+    },
+  },
+  UpdateChannelResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Channel';
+    },
+  },
+  CreateCustomerResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Customer';
+    },
+  },
+  UpdateCustomerResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Customer';
+    },
+  },
+  UpdateGlobalSettingsResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'GlobalSettings';
+    },
+  },
+  SettlePaymentResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Payment';
+    },
+  },
+  AddFulfillmentToOrderResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Fulfillment';
+    },
+  },
+  CancelOrderResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Order';
+    },
+  },
+  RefundOrderResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Refund';
+    },
+  },
+  SettleRefundResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Refund';
+    },
+  },
+  TransitionOrderToStateResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Order';
+    },
+  },
+  TransitionFulfillmentToStateResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Fulfillment';
+    },
+  },
+  RemoveOptionGroupFromProductResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Product';
+    },
+  },
+  CreatePromotionResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Promotion';
+    },
+  },
+  UpdatePromotionResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Promotion';
+    },
+  },
+};

packages/core/src/common/error/generated-graphql-shop-errors.ts

@@ -0,0 +1,343 @@
+// tslint:disable
+/** This file was generated by the graphql-errors-plugin, which is part of the "codegen" npm script. */
+
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+  DateTime: any;
+  JSON: any;
+  Upload: any;
+};
+
+export class ErrorResult {
+  readonly __typename: string;
+  readonly errorCode: string;
+  message: Scalars['String'];
+}
+
+export class AlreadyLoggedInError extends ErrorResult {
+  readonly __typename = 'AlreadyLoggedInError';
+  readonly errorCode = 'ALREADY_LOGGED_IN_ERROR' as any;
+  readonly message = 'ALREADY_LOGGED_IN_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class CouponCodeExpiredError extends ErrorResult {
+  readonly __typename = 'CouponCodeExpiredError';
+  readonly errorCode = 'COUPON_CODE_EXPIRED_ERROR' as any;
+  readonly message = 'COUPON_CODE_EXPIRED_ERROR';
+  constructor(
+    public   couponCode: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class CouponCodeInvalidError extends ErrorResult {
+  readonly __typename = 'CouponCodeInvalidError';
+  readonly errorCode = 'COUPON_CODE_INVALID_ERROR' as any;
+  readonly message = 'COUPON_CODE_INVALID_ERROR';
+  constructor(
+    public   couponCode: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class CouponCodeLimitError extends ErrorResult {
+  readonly __typename = 'CouponCodeLimitError';
+  readonly errorCode = 'COUPON_CODE_LIMIT_ERROR' as any;
+  readonly message = 'COUPON_CODE_LIMIT_ERROR';
+  constructor(
+    public   couponCode: Scalars['String'],
+    public   limit: Scalars['Int'],
+  ) {
+    super();
+  }
+}
+
+export class EmailAddressConflictError extends ErrorResult {
+  readonly __typename = 'EmailAddressConflictError';
+  readonly errorCode = 'EMAIL_ADDRESS_CONFLICT_ERROR' as any;
+  readonly message = 'EMAIL_ADDRESS_CONFLICT_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class IdentifierChangeTokenExpiredError extends ErrorResult {
+  readonly __typename = 'IdentifierChangeTokenExpiredError';
+  readonly errorCode = 'IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR' as any;
+  readonly message = 'IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class IdentifierChangeTokenInvalidError extends ErrorResult {
+  readonly __typename = 'IdentifierChangeTokenInvalidError';
+  readonly errorCode = 'IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR' as any;
+  readonly message = 'IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class InvalidCredentialsError extends ErrorResult {
+  readonly __typename = 'InvalidCredentialsError';
+  readonly errorCode = 'INVALID_CREDENTIALS_ERROR' as any;
+  readonly message = 'INVALID_CREDENTIALS_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class MissingPasswordError extends ErrorResult {
+  readonly __typename = 'MissingPasswordError';
+  readonly errorCode = 'MISSING_PASSWORD_ERROR' as any;
+  readonly message = 'MISSING_PASSWORD_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class NativeAuthStrategyError extends ErrorResult {
+  readonly __typename = 'NativeAuthStrategyError';
+  readonly errorCode = 'NATIVE_AUTH_STRATEGY_ERROR' as any;
+  readonly message = 'NATIVE_AUTH_STRATEGY_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class NegativeQuantityError extends ErrorResult {
+  readonly __typename = 'NegativeQuantityError';
+  readonly errorCode = 'NEGATIVE_QUANTITY_ERROR' as any;
+  readonly message = 'NEGATIVE_QUANTITY_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class OrderLimitError extends ErrorResult {
+  readonly __typename = 'OrderLimitError';
+  readonly errorCode = 'ORDER_LIMIT_ERROR' as any;
+  readonly message = 'ORDER_LIMIT_ERROR';
+  constructor(
+    public   maxItems: Scalars['Int'],
+  ) {
+    super();
+  }
+}
+
+export class OrderModificationError extends ErrorResult {
+  readonly __typename = 'OrderModificationError';
+  readonly errorCode = 'ORDER_MODIFICATION_ERROR' as any;
+  readonly message = 'ORDER_MODIFICATION_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class OrderPaymentStateError extends ErrorResult {
+  readonly __typename = 'OrderPaymentStateError';
+  readonly errorCode = 'ORDER_PAYMENT_STATE_ERROR' as any;
+  readonly message = 'ORDER_PAYMENT_STATE_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class OrderStateTransitionError extends ErrorResult {
+  readonly __typename = 'OrderStateTransitionError';
+  readonly errorCode = 'ORDER_STATE_TRANSITION_ERROR' as any;
+  readonly message = 'ORDER_STATE_TRANSITION_ERROR';
+  constructor(
+    public   transitionError: Scalars['String'],
+    public   fromState: Scalars['String'],
+    public   toState: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class PasswordAlreadySetError extends ErrorResult {
+  readonly __typename = 'PasswordAlreadySetError';
+  readonly errorCode = 'PASSWORD_ALREADY_SET_ERROR' as any;
+  readonly message = 'PASSWORD_ALREADY_SET_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class PasswordResetTokenExpiredError extends ErrorResult {
+  readonly __typename = 'PasswordResetTokenExpiredError';
+  readonly errorCode = 'PASSWORD_RESET_TOKEN_EXPIRED_ERROR' as any;
+  readonly message = 'PASSWORD_RESET_TOKEN_EXPIRED_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class PasswordResetTokenInvalidError extends ErrorResult {
+  readonly __typename = 'PasswordResetTokenInvalidError';
+  readonly errorCode = 'PASSWORD_RESET_TOKEN_INVALID_ERROR' as any;
+  readonly message = 'PASSWORD_RESET_TOKEN_INVALID_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class PaymentDeclinedError extends ErrorResult {
+  readonly __typename = 'PaymentDeclinedError';
+  readonly errorCode = 'PAYMENT_DECLINED_ERROR' as any;
+  readonly message = 'PAYMENT_DECLINED_ERROR';
+  constructor(
+    public   paymentErrorMessage: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class PaymentFailedError extends ErrorResult {
+  readonly __typename = 'PaymentFailedError';
+  readonly errorCode = 'PAYMENT_FAILED_ERROR' as any;
+  readonly message = 'PAYMENT_FAILED_ERROR';
+  constructor(
+    public   paymentErrorMessage: Scalars['String'],
+  ) {
+    super();
+  }
+}
+
+export class VerificationTokenExpiredError extends ErrorResult {
+  readonly __typename = 'VerificationTokenExpiredError';
+  readonly errorCode = 'VERIFICATION_TOKEN_EXPIRED_ERROR' as any;
+  readonly message = 'VERIFICATION_TOKEN_EXPIRED_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+export class VerificationTokenInvalidError extends ErrorResult {
+  readonly __typename = 'VerificationTokenInvalidError';
+  readonly errorCode = 'VERIFICATION_TOKEN_INVALID_ERROR' as any;
+  readonly message = 'VERIFICATION_TOKEN_INVALID_ERROR';
+  constructor(
+  ) {
+    super();
+  }
+}
+
+
+const errorTypeNames = new Set(['OrderModificationError', 'OrderLimitError', 'NegativeQuantityError', 'CouponCodeExpiredError', 'CouponCodeInvalidError', 'CouponCodeLimitError', 'OrderStateTransitionError', 'OrderPaymentStateError', 'PaymentFailedError', 'PaymentDeclinedError', 'AlreadyLoggedInError', 'EmailAddressConflictError', 'InvalidCredentialsError', 'NativeAuthStrategyError', 'MissingPasswordError', 'VerificationTokenInvalidError', 'VerificationTokenExpiredError', 'PasswordAlreadySetError', 'IdentifierChangeTokenInvalidError', 'IdentifierChangeTokenExpiredError', 'PasswordResetTokenInvalidError', 'PasswordResetTokenExpiredError']);
+function isGraphQLError(input: any): input is import('@vendure/common/lib/generated-types').ErrorResult {
+  return input instanceof ErrorResult || errorTypeNames.has(input.__typename);
+}
+
+export const shopErrorOperationTypeResolvers = {
+  UpdateOrderItemsResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Order';
+    },
+  },
+  RemoveOrderItemsResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Order';
+    },
+  },
+  ApplyCouponCodeResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Order';
+    },
+  },
+  TransitionOrderToStateResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Order';
+    },
+  },
+  SetOrderShippingMethodResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Order';
+    },
+  },
+  AddPaymentToOrderResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Order';
+    },
+  },
+  SetCustomerForOrderResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Order';
+    },
+  },
+  NativeAuthenticationResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'CurrentUser';
+    },
+  },
+  AuthenticationResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'CurrentUser';
+    },
+  },
+  RegisterCustomerAccountResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Success';
+    },
+  },
+  RefreshCustomerVerificationResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Success';
+    },
+  },
+  VerifyCustomerAccountResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'CurrentUser';
+    },
+  },
+  UpdateCustomerPasswordResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Success';
+    },
+  },
+  RequestUpdateCustomerEmailAddressResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Success';
+    },
+  },
+  UpdateCustomerEmailAddressResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Success';
+    },
+  },
+  RequestPasswordResetResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'Success';
+    },
+  },
+  ResetPasswordResult: {
+    __resolveType(value: any) {
+      return isGraphQLError(value) ? (value as any).__typename : 'CurrentUser';
+    },
+  },
+};

packages/core/src/common/index.ts

@@ -2,6 +2,8 @@ export * from './finite-state-machine/finite-state-machine';
 export * from './finite-state-machine/types';
 export * from './async-queue';
 export * from './error/errors';
+export * from './error/error-result';
+export * from './error/generated-graphql-admin-errors';
 export * from './injector';
 export * from './ttl-cache';
 export * from './utils';

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

@@ -51,7 +51,7 @@ export interface ListQueryOptions<T extends VendureEntity> {
  * nullable fields have the type `field?: <type> | null`.
  */
 export type NullOptionals<T> = {
-    [K in keyof T]: undefined extends T[K] ? NullOptionals<T[K]> | null : NullOptionals<T[K]>
+    [K in keyof T]: undefined extends T[K] ? NullOptionals<T[K]> | null : NullOptionals<T[K]>;
 };
 
 export type SortOrder = 'ASC' | 'DESC';

packages/core/src/common/utils.ts

@@ -14,7 +14,7 @@ export function not(predicate: (...args: any[]) => boolean) {
  * as determined by a === equality check on the given compareBy property.
  */
 export function foundIn<T>(set: T[], compareBy: keyof T) {
-    return (item: T) => set.some((t) => t[compareBy] === item[compareBy]);
+    return (item: T) => set.some(t => t[compareBy] === item[compareBy]);
 }
 
 /**

packages/core/src/config/auth/native-authentication-strategy.ts

@@ -49,6 +49,9 @@ export class NativeAuthenticationStrategy implements AuthenticationStrategy<Nati
 
     async authenticate(ctx: RequestContext, data: NativeAuthenticationData): Promise<User | false> {
         const user = await this.getUserFromIdentifier(ctx, data.username);
+        if (!user) {
+            return false;
+        }
         const passwordMatch = await this.verifyUserPassword(ctx, user.id, data.password);
         if (!passwordMatch) {
             return false;
@@ -56,15 +59,11 @@ export class NativeAuthenticationStrategy implements AuthenticationStrategy<Nati
         return user;
     }
 
-    private async getUserFromIdentifier(ctx: RequestContext, identifier: string): Promise<User> {
-        const user = await this.connection.getRepository(ctx, User).findOne({
+    private getUserFromIdentifier(ctx: RequestContext, identifier: string): Promise<User | undefined> {
+        return this.connection.getRepository(ctx, User).findOne({
             where: { identifier },
             relations: ['roles', 'roles.channels'],
         });
-        if (!user) {
-            throw new UnauthorizedError();
-        }
-        return user;
     }
 
     /**

packages/core/src/config/payment-method/payment-method-handler.ts

@@ -29,8 +29,24 @@ export type OnPaymentTransitionStartReturnType = ReturnType<
 export interface CreatePaymentResult {
     amount: number;
     state: Exclude<PaymentState, 'Refunded' | 'Error'>;
+    /**
+     * @description
+     * The unique payment reference code typically assigned by
+     * the payment provider.
+     */
     transactionId?: string;
+    /**
+     * @description
+     * If the payment is declined or fails for ome other reason, pass the
+     * relevant error message here, and it gets returned with the
+     * ErrorResponse of the `addPaymentToOrder` mutation.
+     */
     errorMessage?: string;
+    /**
+     * @description
+     * This field can be used to store other relevant data which is often
+     * provided by the payment provider.
+     */
     metadata?: PaymentMetadata;
 }
 

packages/core/src/data-import/providers/asset-importer/asset-importer.ts

@@ -33,7 +33,7 @@ export class AssetImporter {
                     if (fileStat.isFile()) {
                         try {
                             const stream = fs.createReadStream(filename);
-                            const asset = await this.assetService.createFromFileStream(stream);
+                            const asset = (await this.assetService.createFromFileStream(stream)) as Asset;
                             this.assetMap.set(assetPath, asset);
                             assets.push(asset);
                         } catch (err) {

packages/core/src/i18n/i18n.service.ts

@@ -7,6 +7,7 @@ import ICU from 'i18next-icu';
 import Backend from 'i18next-node-fs-backend';
 import path from 'path';
 
+import { GraphQLErrorResult } from '../common/error/error-result';
 import { ConfigService } from '../config/config.service';
 
 import { I18nError } from './i18n-error';
@@ -69,4 +70,19 @@ export class I18nService implements OnModuleInit {
 
         return error;
     }
+
+    /**
+     * Translates the message of an ErrorResult
+     */
+    translateErrorResult(req: I18nRequest, error: GraphQLErrorResult) {
+        const t: TFunction = req.t;
+        let translation: string = error.message;
+        const key = `errorResult.${error.message}`;
+        try {
+            translation = t(key, error as any);
+        } catch (e) {
+            translation += ` (Translation format error: ${e.message})`;
+        }
+        error.message = translation;
+    }
 }

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

@@ -1,45 +1,18 @@
 {
   "error": {
-    "cancel-order-lines-invalid-order-state": "Cannot cancel OrderLines from an Order in the \"{ state }\" state",
-    "cancel-order-lines-nothing-to-cancel": "Nothing to cancel",
-    "cancel-order-lines-quantity-too-high": "Quantity to cancel is greater than existing OrderLine quantity",
     "cannot-delete-role": "The role '{ roleCode }' cannot be deleted",
     "cannot-locate-customer-for-user": "Cannot locate a Customer for the user",
     "cannot-modify-role": "The role '{ roleCode }' cannot be modified",
     "cannot-create-sales-for-active-order": "Cannot create a Sale for an Order which is still active",
     "cannot-move-collection-into-self": "Cannot move a Collection into itself",
-    "cannot-remove-option-group-due-to-variants": "Cannot remove ProductOptionGroup \"{ code }\" as it is used by {count, plural, one {1 ProductVariant} other {# ProductVariants}}",
-    "cannot-remove-tax-category-due-to-tax-rates": "Cannot remove TaxCategory \"{ name }\" as it is referenced by {count, plural, one {1 TaxRate} other {# TaxRates}}",
-    "cannot-set-customer-for-order-when-logged-in": "Cannot set a Customer for the Order when already logged in",
-    "cannot-set-default-language-as-unavailable": "Cannot remove make language \"{ language }\" unavailable as it is used as the defaultLanguage by the channel \"{channelCode}\"",
-    "cannot-transition-order-from-to": "Cannot transition Order from \"{ fromState }\" to \"{ toState }\"",
     "cannot-transition-payment-from-to": "Cannot transition Payment from \"{ fromState }\" to \"{ toState }\"",
     "cannot-transition-refund-from-to": "Cannot transition Refund from \"{ fromState }\" to \"{ toState }\"",
     "cannot-transition-fulfillment-from-to": "Cannot transition Fulfillment from \"{ fromState }\" to \"{ toState }\"",
-    "cannot-transition-to-shipping-when-order-is-empty": "Cannot transition Order to the \"ArrangingShipping\" state when it is empty",
-    "cannot-transition-to-payment-without-customer": "Cannot transition Order to the \"ArrangingPayment\" state without Customer details",
-    "cannot-transition-unless-all-cancelled": "Cannot transition Order to the \"Cancelled\" state unless all OrderItems are cancelled",
-    "cannot-transition-unless-all-order-items-delivered": "Cannot transition Order to the \"Delivered\" state unless all OrderItems are delivered",
-    "cannot-transition-unless-some-order-items-delivered": "Cannot transition Order to the \"PartiallyDelivered\" state unless some OrderItems are delivered",
-    "cannot-transition-unless-some-order-items-shipped": "Cannot transition Order to the \"PartiallyShipped\" state unless some OrderItems are shipped",
-    "cannot-transition-unless-all-order-items-shipped": "Cannot transition Order to the \"Shipped\" state unless all OrderItems are shipped",
-    "cannot-transition-without-authorized-payments": "Cannot transition Order to the \"PaymentAuthorized\" state when the total is not covered by authorized Payments",
-    "cannot-transition-without-settled-payments": "Cannot transition Order to the \"PaymentSettled\" state when the total is not covered by settled Payments",
-    "cannot-use-registered-email-address-for-guest-order":  "Cannot use a registered email address for a guest order. Please log in first",
-    "channel-not-found":  "No channel with the token \"{ token }\" exists",
     "collection-id-or-slug-must-be-provided": "Either the Collection id or slug must be provided",
     "collection-id-slug-mismatch": "The provided id and slug refer to different Collections",
-    "country-code-not-valid":  "The countryCode \"{ countryCode }\" was not recognized",
-    "coupon-code-expired":  "Coupon code \"{ couponCode }\" has expired",
-    "coupon-code-limit-has-been-reached":  "Coupon code cannot be used more than {limit, plural, one {once} other {# times}} per customer",
-    "coupon-code-not-valid":  "Coupon code \"{ couponCode }\" is not valid",
-    "create-fulfillment-items-already-fulfilled": "One or more OrderItems have already been fulfilled",
-    "create-fulfillment-orders-must-be-settled": "One or more OrderItems belong to an Order which is in an invalid state",
-    "create-fulfillment-nothing-to-fulfill": "Nothing to fulfill",
+    "country-code-not-valid": "The countryCode \"{ countryCode }\" was not recognized",
     "customer-does-not-belong-to-customer-group": "Customer does not belong to this CustomerGroup",
-    "default-channel-not-found":  "Default channel not found",
-    "email-address-must-be-unique": "The email address must be unique",
-    "email-address-not-available": "This email address is not available",
+    "default-channel-not-found": "Default channel not found",
     "email-address-not-verified": "Please verify this email address before logging in",
     "entity-has-no-translation-in-language": "Translatable entity '{ entityName }' has not been translated into the requested language ({ languageCode })",
     "entity-with-id-not-found": "No { entityName } with the id '{ id }' could be found",
@@ -52,44 +25,70 @@
     "field-invalid-string-option": "The custom field '{ name }' value ['{ value }'] is invalid. Valid options are [{ validOptions }]",
     "field-invalid-string-pattern": "The custom field '{ name }' value ['{ value }'] does not match the pattern [{ pattern }]",
     "forbidden": "You are not currently authorized to perform this action",
-    "identifier-change-token-not-recognized": "Identifier change token not recognized",
-    "identifier-change-token-has-expired": "Identifier change token has expired",
     "invalid-sort-field": "The sort field '{ fieldName }' is invalid. Valid fields are: { validFields }",
-    "language-not-available-in-global-settings": "Language \"{code}\" is not available. First enable it via GlobalSettings and try again.",
-    "mime-type-not-permitted": "The MIME type '{ mimetype }' is not permitted.",
-    "missing-password-on-registration": "A password must be provided when `authOptions.requireVerification` is set to \"false\"",
     "no-active-tax-zone": "The active tax zone could not be determined. Ensure a default tax zone is set for the current channel.",
     "no-search-plugin-configured": "No search plugin has been configured",
-    "no-valid-channel-specified": "No valid channel was specified (ensure the 'vendure-token' header was specified in the request)",
-    "order-contents-may-only-be-modified-in-addingitems-state": "Order contents may only be modified when in the \"AddingItems\" state",
     "order-does-not-contain-line-with-id": "This order does not contain an OrderLine with the id { id }",
-    "order-item-quantity-must-be-positive": "{ quantity } is not a valid quantity for an OrderItem",
-    "order-items-limit-exceeded": "Cannot add items. An order may consist of a maximum of { maxItems } items",
-    "order-lines-must-belong-to-same-order": "OrderLines must all belong to a single Order",
-    "payment-may-only-be-added-in-arrangingpayment-state": "A Payment may only be added when Order is in \"ArrangingPayment\" state",
-    "password-already-set-during-registration": "A password has already been set during registration",
-    "password-reset-token-has-expired": "Password reset token has expired.",
-    "password-reset-token-not-recognized": "Password reset token not recognized",
-    "password-required-for-verification": "A password must be provided as it was not set during registration",
+    "pending-identifier-missing": "Could not find the pending email address to update",
     "permission-invalid": "The permission \"{ permission }\" is not valid",
     "products-cannot-be-removed-from-default-channel": "Products cannot be removed from the default Channel",
     "product-id-or-slug-must-be-provided": "Either the Product id or slug must be provided",
     "product-id-slug-mismatch": "The provided id and slug refer to different Products",
     "product-variant-option-ids-not-compatible": "ProductVariant optionIds must include one optionId from each of the groups: {groupNames}",
     "product-variant-options-combination-already-exists": "A ProductVariant already exists with the options: {optionNames}",
-    "promotion-must-have-conditions-or-coupon-code": "A Promotion must have either at least one condition or a coupon code set",
-    "refund-order-item-already-refunded": "Cannot refund an OrderItem which has already been refunded",
-    "refund-order-lines-invalid-order-state": "Cannot refund an Order in the \"{ state }\" state",
-    "refund-order-lines-nothing-to-refund": "Nothing to refund",
-    "refund-order-lines-quantity-too-high": "Quantity to refund is greater than existing OrderLine quantity",
-    "refund-order-payment-lines-mismatch": "The Payment and OrderLines do not belong to the same Order",
     "stockonhand-cannot-be-negative": "stockOnHand cannot be a negative value",
-    "verification-token-has-expired": "Verification token has expired. Use refreshCustomerVerification to send a new token.",
-    "verification-token-not-recognized": "Verification token not recognized",
     "unauthorized": "The credentials did not match. Please check and try again"
   },
+  "errorResult": {
+    "ALREADY_CANCELLED_ERROR": "Quantity to cancel is greater than existing OrderLine quantity",
+    "ALREADY_LOGGED_IN_ERROR": "Cannot set a Customer for the Order when already logged in",
+    "ALREADY_REFUNDED_ERROR": "Cannot refund an OrderItem which has already been refunded",
+    "CANCEL_ACTIVE_ORDER_ERROR": "Cannot cancel OrderLines from an Order in the \"{ orderState }\" state",
+    "CHANNEL_DEFAULT_LANGUAGE_ERROR": "Cannot make language \"{ language }\" unavailable as it is used as the defaultLanguage by the channel \"{ channelCode }\"",
+    "COUPON_CODE_EXPIRED_ERROR": "Coupon code \"{ couponCode }\" has expired",
+    "COUPON_CODE_INVALID_ERROR": "Coupon code \"{ couponCode }\" is not valid",
+    "COUPON_CODE_LIMIT_ERROR": "Coupon code cannot be used more than {limit, plural, one {once} other {# times}} per customer",
+    "EMAIL_ADDRESS_CONFLICT_ERROR": "The email address is not available.",
+    "EMPTY_ORDER_LINE_SELECTION_ERROR": "At least one OrderLine must be specified",
+    "IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR": "Identifier change token not recognized",
+    "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",
+    "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.",
+    "NEGATIVE_QUANTITY_ERROR": "The quantity for an OrderItem cannot be negative",
+    "NOTHING_TO_REFUND_ERROR": "Nothing to refund",
+    "ORDER_LIMIT_ERROR": "Cannot add items. An order may consist of a maximum of { maxItems } items",
+    "ORDER_MODIFICATION_ERROR": "Order contents may only be modified when in the \"AddingItems\" state",
+    "ORDER_PAYMENT_STATE_ERROR": "A Payment may only be added when Order is in \"ArrangingPayment\" state",
+    "ORDER_STATE_TRANSITION_ERROR": "Cannot transition Order from \"{ fromState }\" to \"{ toState }\"",
+    "PASSWORD_ALREADY_SET_ERROR": "A password has already been set during registration",
+    "PASSWORD_RESET_TOKEN_EXPIRED_ERROR": "Password reset token has expired",
+    "PASSWORD_RESET_TOKEN_INVALID_ERROR": "Password reset token not recognized",
+    "PAYMENT_DECLINED_ERROR": "The payment was declined",
+    "PAYMENT_FAILED_ERROR": "The payment failed",
+    "PAYMENT_ORDER_MISMATCH_ERROR": "The Payment and OrderLines do not belong to the same Order",
+    "PRODUCT_OPTION_IN_USE_ERROR": "Cannot remove ProductOptionGroup \"{ optionGroupCode }\" as it is used by {productVariantCount, plural, one {1 ProductVariant} other {# ProductVariants}}",
+    "QUANTITY_TOO_GREAT_ERROR": "The specified quantity is greater than the available OrderItems",
+    "REFUND_ORDER_STATE_ERROR": "Cannot refund an Order in the \"{ orderState }\" state",
+    "SETTLE_PAYMENT_ERROR": "Settling the payment failed",
+    "VERIFICATION_TOKEN_EXPIRED_ERROR": "Verification token has expired. Use refreshCustomerVerification to send a new token.",
+    "VERIFICATION_TOKEN_INVALID_ERROR": "Verification token not recognized"
+  },
   "message": {
     "asset-to-be-deleted-is-featured": "The selected {assetCount, plural, one {Asset is} other {Assets are}} featured by {products, plural, =0 {} one {1 Product} other {# Products}} {variants, plural, =0 {} one { 1 ProductVariant} other { # ProductVariants}} {collections, plural, =0 {} one { 1 Collection} other { # Collections}}",
+    "cannot-remove-tax-category-due-to-tax-rates": "Cannot remove TaxCategory \"{ name }\" as it is referenced by {count, plural, one {1 TaxRate} other {# TaxRates}}",
+    "cannot-transition-order-from-to": "Cannot transition Order from \"{ fromState }\" to \"{ toState }\"",
+    "cannot-transition-to-shipping-when-order-is-empty": "Cannot transition Order to the \"ArrangingShipping\" state when it is empty",
+    "cannot-transition-to-payment-without-customer": "Cannot transition Order to the \"ArrangingPayment\" state without Customer details",
+    "cannot-transition-unless-all-cancelled": "Cannot transition Order to the \"Cancelled\" state unless all OrderItems are cancelled",
+    "cannot-transition-unless-all-order-items-delivered": "Cannot transition Order to the \"Delivered\" state unless all OrderItems are delivered",
+    "cannot-transition-unless-some-order-items-delivered": "Cannot transition Order to the \"PartiallyDelivered\" state unless some OrderItems are delivered",
+    "cannot-transition-unless-some-order-items-shipped": "Cannot transition Order to the \"PartiallyShipped\" state unless some OrderItems are shipped",
+    "cannot-transition-unless-all-order-items-shipped": "Cannot transition Order to the \"Shipped\" state unless all OrderItems are shipped",
+    "cannot-transition-without-authorized-payments": "Cannot transition Order to the \"PaymentAuthorized\" state when the total is not covered by authorized Payments",
+    "cannot-transition-without-settled-payments": "Cannot transition Order to the \"PaymentSettled\" state when the total is not covered by settled Payments",
     "country-used-in-addresses": "The selected Country cannot be deleted as it is used in {count, plural, one {1 Address} other {# Addresses}}",
     "facet-force-deleted": "The Facet was deleted and its FacetValues were removed from {products, plural, =0 {} one {1 Product} other {# Products}}{both, select, both { , } single {}}{variants, plural, =0 {} one {1 ProductVariant} other {# ProductVariants}}",
     "facet-used": "The selected Facet includes FacetValues which are assigned to {products, plural, =0 {} one {1 Product} other {# Products}}{both, select, both { , } single {}}{variants, plural, =0 {} one {1 ProductVariant} other {# ProductVariants}}",

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

@@ -17,7 +17,7 @@
     "no-valid-channel-specified": "No se ha especificado ningún canal válido (asegúrate de que el encabezado 'vendure-token'  sea especificado en el requisito)",
     "order-contents-may-only-be-modified-in-addingitems-state": "Los contenidos de un pedido solo pueden ser modificados durante el \"AddingItems\" estado ",
     "order-does-not-contain-line-with-id": "Este pedido no contiene una línea de pedido con el id { id }",
-    "order-item-quantity-must-be-positive": "{ quantity } no es una cantidad válida para una linea de pedido",
+    "order-item-quantity-must-be-positive": "no es una cantidad válida para una linea de pedido",
     "order-items-limit-exceeded": "No es posible añadir artículos, Un pedido puede consistir de un máximo de { maxItems } artículos ",
     "payment-may-only-be-added-in-arrangingpayment-state": "Un pago sólo puede ser añadido cuando el pedido se encuentra en el estado de \"ArrangingPayment\"",
     "password-reset-token-has-expired": "Este token de restablecimiento de contraseña ha expirado.",

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

@@ -61,7 +61,7 @@
     "no-valid-channel-specified": "Nenhum canal válido foi especificado (verifique se o cabeçalho 'token' foi especificado na solicitação)",
     "order-contents-may-only-be-modified-in-addingitems-state": "O conteúdo do pedido pode ser modificado apenas no estado \"AddingItems\"",
     "order-does-not-contain-line-with-id": "Este pedido não contém um OrderLine com o ID { id }",
-    "order-item-quantity-must-be-positive": "{ quantity } não é uma quantidade válida para um OrderItem",
+    "order-item-quantity-must-be-positive": "não é uma quantidade válida para um OrderItem",
     "order-items-limit-exceeded": "Não é possível adicionar itens. Um pedido pode consistir em no máximo { maxItems } itens",
     "order-lines-must-belong-to-same-order": "Todos os OrderLines devem pertencer a um único pedido",
     "payment-may-only-be-added-in-arrangingpayment-state": "Um pagamento pode ser adicionado apenas quando o pedido estiver no estado \"ArrangingPayment\"",

packages/core/src/plugin/default-search-plugin/search-strategy/search-strategy-utils.ts

@@ -22,15 +22,15 @@ export function mapToSearchResult(raw: any, currencyCode: CurrencyCode): SearchR
             ? ({ min: raw.minPriceWithTax, max: raw.maxPriceWithTax } as PriceRange)
             : ({ value: raw.si_priceWithTax } as SinglePrice);
 
-    const productAsset: SearchResultAsset | null = !raw.si_productAssetId
-        ? null
+    const productAsset: SearchResultAsset | undefined = !raw.si_productAssetId
+        ? undefined
         : {
               id: raw.si_productAssetId,
               preview: raw.si_productPreview,
               focalPoint: parseFocalPoint(raw.si_productPreviewFocalPoint),
           };
-    const productVariantAsset: SearchResultAsset | null = !raw.si_productVariantAssetId
-        ? null
+    const productVariantAsset: SearchResultAsset | undefined = !raw.si_productVariantAssetId
+        ? undefined
         : {
               id: raw.si_productVariantAssetId,
               preview: raw.si_productVariantPreview,
@@ -79,7 +79,7 @@ export function createFacetIdCountMap(facetValuesResult: Array<{ facetValues: st
     return result;
 }
 
-function parseFocalPoint(focalPoint: any): Coordinate | null {
+function parseFocalPoint(focalPoint: any): Coordinate | undefined {
     if (focalPoint && typeof focalPoint === 'string') {
         try {
             return JSON.parse(focalPoint);
@@ -87,5 +87,5 @@ function parseFocalPoint(focalPoint: any): Coordinate | null {
             // fall though
         }
     }
-    return null;
+    return;
 }

packages/core/src/service/helpers/order-state-machine/order-state-machine.ts

@@ -72,45 +72,45 @@ export class OrderStateMachine {
     private async onTransitionStart(fromState: OrderState, toState: OrderState, data: OrderTransitionData) {
         if (toState === 'ArrangingPayment') {
             if (data.order.lines.length === 0) {
-                return `error.cannot-transition-to-payment-when-order-is-empty`;
+                return `message.cannot-transition-to-payment-when-order-is-empty`;
             }
             if (!data.order.customer) {
-                return `error.cannot-transition-to-payment-without-customer`;
+                return `message.cannot-transition-to-payment-without-customer`;
             }
         }
         if (toState === 'PaymentAuthorized' && !orderTotalIsCovered(data.order, 'Authorized')) {
-            return `error.cannot-transition-without-authorized-payments`;
+            return `message.cannot-transition-without-authorized-payments`;
         }
         if (toState === 'PaymentSettled' && !orderTotalIsCovered(data.order, 'Settled')) {
-            return `error.cannot-transition-without-settled-payments`;
+            return `message.cannot-transition-without-settled-payments`;
         }
         if (toState === 'Cancelled' && fromState !== 'AddingItems' && fromState !== 'ArrangingPayment') {
             if (!orderItemsAreAllCancelled(data.order)) {
-                return `error.cannot-transition-unless-all-cancelled`;
+                return `message.cannot-transition-unless-all-cancelled`;
             }
         }
         if (toState === 'PartiallyShipped') {
             const orderWithFulfillments = await this.findOrderWithFulfillments(data.ctx, data.order.id);
             if (!orderItemsArePartiallyShipped(orderWithFulfillments)) {
-                return `error.cannot-transition-unless-some-order-items-shipped`;
+                return `message.cannot-transition-unless-some-order-items-shipped`;
             }
         }
         if (toState === 'Shipped') {
             const orderWithFulfillments = await this.findOrderWithFulfillments(data.ctx, data.order.id);
             if (!orderItemsAreShipped(orderWithFulfillments)) {
-                return `error.cannot-transition-unless-all-order-items-shipped`;
+                return `message.cannot-transition-unless-all-order-items-shipped`;
             }
         }
         if (toState === 'PartiallyDelivered') {
             const orderWithFulfillments = await this.findOrderWithFulfillments(data.ctx, data.order.id);
             if (!orderItemsArePartiallyDelivered(orderWithFulfillments)) {
-                return `error.cannot-transition-unless-some-order-items-delivered`;
+                return `message.cannot-transition-unless-some-order-items-delivered`;
             }
         }
         if (toState === 'Delivered') {
             const orderWithFulfillments = await this.findOrderWithFulfillments(data.ctx, data.order.id);
             if (!orderItemsAreDelivered(orderWithFulfillments)) {
-                return `error.cannot-transition-unless-all-order-items-delivered`;
+                return `message.cannot-transition-unless-all-order-items-delivered`;
             }
         }
     }
@@ -181,7 +181,7 @@ export class OrderStateMachine {
                         );
                     }
                 }
-                throw new IllegalOperationError(message || 'error.cannot-transition-order-from-to', {
+                throw new IllegalOperationError(message || 'message.cannot-transition-order-from-to', {
                     fromState,
                     toState,
                 });

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

@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
 import {
     AssetType,
     CreateAssetInput,
+    CreateAssetResult,
     DeletionResponse,
     DeletionResult,
     UpdateAssetInput,
@@ -14,7 +15,9 @@ import path from 'path';
 import { Stream } from 'stream';
 
 import { RequestContext } from '../../api/common/request-context';
-import { InternalServerError, UserInputError } from '../../common/error/errors';
+import { isGraphQlErrorResult } from '../../common/error/error-result';
+import { InternalServerError } from '../../common/error/errors';
+import { MimeTypeError } from '../../common/error/generated-graphql-admin-errors';
 import { ListQueryOptions } from '../../common/types/common-types';
 import { getAssetType, idsAreEqual } from '../../common/utils';
 import { ConfigService } from '../../config/config.service';
@@ -149,24 +152,18 @@ export class AssetService {
         return entity;
     }
 
-    async validateInputMimeTypes(inputs: CreateAssetInput[]): Promise<void> {
-        for (const input of inputs) {
-            const { mimetype } = await input.file;
-            if (!this.validateMimeType(mimetype)) {
-                throw new UserInputError('error.mime-type-not-permitted', { mimetype });
-            }
-        }
-    }
-
     /**
      * Create an Asset based on a file uploaded via the GraphQL API.
      */
-    async create(ctx: RequestContext, input: CreateAssetInput): Promise<Asset> {
+    async create(ctx: RequestContext, input: CreateAssetInput): Promise<CreateAssetResult> {
         const { createReadStream, filename, mimetype } = await input.file;
         const stream = createReadStream();
-        const asset = await this.createAssetInternal(ctx, stream, filename, mimetype);
-        this.eventBus.publish(new AssetEvent(ctx, asset, 'created'));
-        return asset;
+        const result = await this.createAssetInternal(ctx, stream, filename, mimetype);
+        if (isGraphQlErrorResult(result)) {
+            return result;
+        }
+        this.eventBus.publish(new AssetEvent(ctx, result, 'created'));
+        return result;
     }
 
     async update(ctx: RequestContext, input: UpdateAssetInput): Promise<Asset> {
@@ -228,7 +225,7 @@ export class AssetService {
     /**
      * Create an Asset from a file stream created during data import.
      */
-    async createFromFileStream(stream: ReadStream): Promise<Asset> {
+    async createFromFileStream(stream: ReadStream): Promise<CreateAssetResult> {
         const filePath = stream.path;
         if (typeof filePath === 'string') {
             const filename = path.basename(filePath);
@@ -244,10 +241,10 @@ export class AssetService {
         stream: Stream,
         filename: string,
         mimetype: string,
-    ): Promise<Asset> {
+    ): Promise<CreateAssetResult> {
         const { assetOptions } = this.configService;
         if (!this.validateMimeType(mimetype)) {
-            throw new UserInputError('error.mime-type-not-permitted', { mimetype });
+            return new MimeTypeError(filename, mimetype);
         }
         const { assetPreviewStrategy, assetStorageStrategy } = assetOptions;
         const sourceFileName = await this.getSourceFileName(filename);

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

@@ -3,7 +3,9 @@ import { ID } from '@vendure/common/lib/shared-types';
 
 import { ApiType } from '../../api/common/get-api-type';
 import { RequestContext } from '../../api/common/request-context';
-import { InternalServerError, NotVerifiedError, UnauthorizedError } from '../../common/error/errors';
+import { InternalServerError, NotVerifiedError } from '../../common/error/errors';
+import { InvalidCredentialsError } from '../../common/error/generated-graphql-admin-errors';
+import { InvalidCredentialsError as ShopInvalidCredentialsError } from '../../common/error/generated-graphql-shop-errors';
 import { AuthenticationStrategy } from '../../config/auth/authentication-strategy';
 import {
     NATIVE_AUTH_STRATEGY_NAME,
@@ -41,7 +43,7 @@ export class AuthService {
         apiType: ApiType,
         authenticationMethod: string,
         authenticationData: any,
-    ): Promise<AuthenticatedSession> {
+    ): Promise<AuthenticatedSession | InvalidCredentialsError> {
         this.eventBus.publish(
             new AttemptedLoginEvent(
                 ctx,
@@ -54,7 +56,7 @@ export class AuthService {
         const authenticationStrategy = this.getAuthenticationStrategy(apiType, authenticationMethod);
         const user = await authenticationStrategy.authenticate(ctx, authenticationData);
         if (!user) {
-            throw new UnauthorizedError();
+            return new InvalidCredentialsError();
         }
         return this.createAuthenticatedSessionForUser(ctx, user, authenticationStrategy.name);
     }
@@ -95,14 +97,18 @@ export class AuthService {
     /**
      * Verify the provided password against the one we have for the given user.
      */
-    async verifyUserPassword(ctx: RequestContext, userId: ID, password: string): Promise<boolean> {
+    async verifyUserPassword(
+        ctx: RequestContext,
+        userId: ID,
+        password: string,
+    ): Promise<boolean | InvalidCredentialsError | ShopInvalidCredentialsError> {
         const nativeAuthenticationStrategy = this.getAuthenticationStrategy(
             'shop',
             NATIVE_AUTH_STRATEGY_NAME,
         );
         const passwordMatches = await nativeAuthenticationStrategy.verifyUserPassword(ctx, userId, password);
         if (!passwordMatches) {
-            throw new UnauthorizedError();
+            return new InvalidCredentialsError();
         }
         return true;
     }

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

@@ -1,22 +1,21 @@
 import { Injectable } from '@nestjs/common';
 import {
     CreateChannelInput,
+    CreateChannelResult,
     CurrencyCode,
     DeletionResponse,
     DeletionResult,
     UpdateChannelInput,
+    UpdateChannelResult,
 } from '@vendure/common/lib/generated-types';
 import { DEFAULT_CHANNEL_CODE } from '@vendure/common/lib/shared-constants';
 import { ID, Type } from '@vendure/common/lib/shared-types';
 import { unique } from '@vendure/common/lib/unique';
 
 import { RequestContext } from '../../api/common/request-context';
-import {
-    ChannelNotFoundError,
-    EntityNotFoundError,
-    InternalServerError,
-    UserInputError,
-} from '../../common/error/errors';
+import { ErrorResultUnion, isGraphQlErrorResult } from '../../common/error/error-result';
+import { ChannelNotFoundError, EntityNotFoundError, InternalServerError } from '../../common/error/errors';
+import { LanguageNotAvailableError } from '../../common/error/generated-graphql-admin-errors';
 import { ChannelAware } from '../../common/types/common-types';
 import { assertFound, idsAreEqual } from '../../common/utils';
 import { ConfigService } from '../../config/config.service';
@@ -136,8 +135,15 @@ export class ChannelService {
             .findOne(id, { relations: ['defaultShippingZone', 'defaultTaxZone'] });
     }
 
-    async create(ctx: RequestContext, input: CreateChannelInput): Promise<Channel> {
+    async create(
+        ctx: RequestContext,
+        input: CreateChannelInput,
+    ): Promise<ErrorResultUnion<CreateChannelResult, Channel>> {
         const channel = new Channel(input);
+        const defaultLanguageValidationResult = await this.validateDefaultLanguageCode(ctx, input);
+        if (isGraphQlErrorResult(defaultLanguageValidationResult)) {
+            return defaultLanguageValidationResult;
+        }
         if (input.defaultTaxZoneId) {
             channel.defaultTaxZone = await this.connection.getEntityOrThrow(
                 ctx,
@@ -157,20 +163,17 @@ export class ChannelService {
         return channel;
     }
 
-    async update(ctx: RequestContext, input: UpdateChannelInput): Promise<Channel> {
+    async update(
+        ctx: RequestContext,
+        input: UpdateChannelInput,
+    ): Promise<ErrorResultUnion<UpdateChannelResult, Channel>> {
         const channel = await this.findOne(ctx, input.id);
         if (!channel) {
             throw new EntityNotFoundError('Channel', input.id);
         }
-        if (input.defaultLanguageCode) {
-            const availableLanguageCodes = await this.globalSettingsService
-                .getSettings(ctx)
-                .then(s => s.availableLanguages);
-            if (!availableLanguageCodes.includes(input.defaultLanguageCode)) {
-                throw new UserInputError('error.language-not-available-in-global-settings', {
-                    code: input.defaultLanguageCode,
-                });
-            }
+        const defaultLanguageValidationResult = await this.validateDefaultLanguageCode(ctx, input);
+        if (isGraphQlErrorResult(defaultLanguageValidationResult)) {
+            return defaultLanguageValidationResult;
         }
         const updatedChannel = patchEntity(channel, input);
         if (input.defaultTaxZoneId) {
@@ -230,6 +233,20 @@ export class ChannelService {
         }
     }
 
+    private async validateDefaultLanguageCode(
+        ctx: RequestContext,
+        input: CreateChannelInput | UpdateChannelInput,
+    ): Promise<LanguageNotAvailableError | undefined> {
+        if (input.defaultLanguageCode) {
+            const availableLanguageCodes = await this.globalSettingsService
+                .getSettings(ctx)
+                .then(s => s.availableLanguages);
+            if (!availableLanguageCodes.includes(input.defaultLanguageCode)) {
+                return new LanguageNotAvailableError(input.defaultLanguageCode);
+            }
+        }
+    }
+
     private async updateAllChannels(ctx?: RequestContext) {
         this.allChannels = await this.findAll(ctx || RequestContext.empty());
     }

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

@@ -1,25 +1,37 @@
 import { Injectable } from '@nestjs/common';
-import { RegisterCustomerInput } from '@vendure/common/lib/generated-shop-types';
+import {
+    RegisterCustomerAccountResult,
+    RegisterCustomerInput,
+    UpdateCustomerInput as UpdateCustomerShopInput,
+    VerifyCustomerAccountResult,
+} from '@vendure/common/lib/generated-shop-types';
 import {
     AddNoteToCustomerInput,
     CreateAddressInput,
     CreateCustomerInput,
+    CreateCustomerResult,
     DeletionResponse,
     DeletionResult,
     HistoryEntryType,
     UpdateAddressInput,
     UpdateCustomerInput,
     UpdateCustomerNoteInput,
+    UpdateCustomerResult,
 } from '@vendure/common/lib/generated-types';
 import { ID, PaginatedList } from '@vendure/common/lib/shared-types';
 
 import { RequestContext } from '../../api/common/request-context';
+import { ErrorResultUnion, isGraphQlErrorResult } from '../../common/error/error-result';
+import { EntityNotFoundError, InternalServerError } from '../../common/error/errors';
+import { EmailAddressConflictError as EmailAddressConflictAdminError } from '../../common/error/generated-graphql-admin-errors';
 import {
-    EntityNotFoundError,
-    IllegalOperationError,
-    InternalServerError,
-    UserInputError,
-} from '../../common/error/errors';
+    EmailAddressConflictError,
+    IdentifierChangeTokenExpiredError,
+    IdentifierChangeTokenInvalidError,
+    MissingPasswordError,
+    PasswordResetTokenExpiredError,
+    PasswordResetTokenInvalidError,
+} from '../../common/error/generated-graphql-shop-errors';
 import { ListQueryOptions } from '../../common/types/common-types';
 import { assertFound, idsAreEqual, normalizeEmailAddress } from '../../common/utils';
 import { NATIVE_AUTH_STRATEGY_NAME } from '../../config/auth/native-authentication-strategy';
@@ -131,7 +143,11 @@ export class CustomerService {
         }
     }
 
-    async create(ctx: RequestContext, input: CreateCustomerInput, password?: string): Promise<Customer> {
+    async create(
+        ctx: RequestContext,
+        input: CreateCustomerInput,
+        password?: string,
+    ): Promise<ErrorResultUnion<CreateCustomerResult, Customer>> {
         input.emailAddress = normalizeEmailAddress(input.emailAddress);
         const customer = new Customer(input);
 
@@ -145,7 +161,7 @@ export class CustomerService {
             .getOne();
 
         if (existingCustomerInChannel) {
-            throw new UserInputError(`error.email-address-must-be-unique`);
+            return new EmailAddressConflictAdminError();
         }
 
         const existingCustomer = await this.connection.getRepository(ctx, Customer).findOne({
@@ -169,14 +185,21 @@ export class CustomerService {
             return this.connection.getRepository(Customer).save(updatedCustomer);
         } else if (existingCustomer || existingUser) {
             // Not sure when this situation would occur
-            throw new UserInputError(`error.email-address-must-be-unique`);
+            return new EmailAddressConflictAdminError();
         }
         customer.user = await this.userService.createCustomerUser(ctx, input.emailAddress, password);
 
         if (password && password !== '') {
             const verificationToken = customer.user.getNativeAuthenticationMethod().verificationToken;
             if (verificationToken) {
-                customer.user = await this.userService.verifyUserByToken(ctx, verificationToken);
+                const result = await this.userService.verifyUserByToken(ctx, verificationToken);
+                if (isGraphQlErrorResult(result)) {
+                    // In theory this should never be reached, so we will just
+                    // throw the result
+                    throw result;
+                } else {
+                    customer.user = result;
+                }
             }
         } else {
             this.eventBus.publish(new AccountRegistrationEvent(ctx, customer.user));
@@ -206,10 +229,57 @@ export class CustomerService {
         return createdCustomer;
     }
 
-    async registerCustomerAccount(ctx: RequestContext, input: RegisterCustomerInput): Promise<boolean> {
+    async update(ctx: RequestContext, input: UpdateCustomerShopInput & { id: ID }): Promise<Customer>;
+    async update(
+        ctx: RequestContext,
+        input: UpdateCustomerInput,
+    ): Promise<ErrorResultUnion<UpdateCustomerResult, Customer>>;
+    async update(
+        ctx: RequestContext,
+        input: UpdateCustomerInput | (UpdateCustomerShopInput & { id: ID }),
+    ): Promise<ErrorResultUnion<UpdateCustomerResult, Customer>> {
+        const hasEmailAddress = (i: any): i is UpdateCustomerInput & { emailAddress: string } =>
+            i.hasOwnProperty('emailAddress');
+
+        if (hasEmailAddress(input)) {
+            const existingCustomerInChannel = await this.connection
+                .getRepository(ctx, Customer)
+                .createQueryBuilder('customer')
+                .leftJoin('customer.channels', 'channel')
+                .where('channel.id = :channelId', { channelId: ctx.channelId })
+                .andWhere('customer.emailAddress = :emailAddress', { emailAddress: input.emailAddress })
+                .andWhere('customer.id != :customerId', { customerId: input.id })
+                .andWhere('customer.deletedAt is null')
+                .getOne();
+
+            if (existingCustomerInChannel) {
+                return new EmailAddressConflictAdminError();
+            }
+        }
+
+        const customer = await this.connection.getEntityOrThrow(ctx, Customer, input.id, {
+            channelId: ctx.channelId,
+        });
+        const updatedCustomer = patchEntity(customer, input);
+        await this.connection.getRepository(ctx, Customer).save(updatedCustomer, { reload: false });
+        await this.historyService.createHistoryEntryForCustomer({
+            customerId: customer.id,
+            ctx,
+            type: HistoryEntryType.CUSTOMER_DETAIL_UPDATED,
+            data: {
+                input,
+            },
+        });
+        return assertFound(this.findOne(ctx, customer.id));
+    }
+
+    async registerCustomerAccount(
+        ctx: RequestContext,
+        input: RegisterCustomerInput,
+    ): Promise<RegisterCustomerAccountResult | EmailAddressConflictError> {
         if (!this.configService.authOptions.requireVerification) {
             if (!input.password) {
-                throw new UserInputError(`error.missing-password-on-registration`);
+                return new MissingPasswordError();
             }
         }
         let user = await this.userService.getUserByEmailAddress(ctx, input.emailAddress);
@@ -220,7 +290,7 @@ export class CustomerService {
             if (hasNativeAuthMethod) {
                 // If the user has already been verified and has already
                 // registered with the native authentication strategy, do nothing.
-                return false;
+                return { success: true };
             }
         }
         const customFields = (input as any).customFields;
@@ -232,6 +302,9 @@ export class CustomerService {
             phoneNumber: input.phoneNumber || '',
             ...(customFields ? { customFields } : {}),
         });
+        if (isGraphQlErrorResult(customer)) {
+            return customer;
+        }
         await this.historyService.createHistoryEntryForCustomer({
             customerId: customer.id,
             ctx,
@@ -272,7 +345,7 @@ export class CustomerService {
                 },
             });
         }
-        return true;
+        return { success: true };
     }
 
     async refreshVerificationToken(ctx: RequestContext, emailAddress: string): Promise<void> {
@@ -289,23 +362,24 @@ export class CustomerService {
         ctx: RequestContext,
         verificationToken: string,
         password?: string,
-    ): Promise<Customer | undefined> {
-        const user = await this.userService.verifyUserByToken(ctx, verificationToken, password);
-        if (user) {
-            const customer = await this.findOneByUserId(ctx, user.id);
-            if (!customer) {
-                throw new InternalServerError('error.cannot-locate-customer-for-user');
-            }
-            await this.historyService.createHistoryEntryForCustomer({
-                customerId: customer.id,
-                ctx,
-                type: HistoryEntryType.CUSTOMER_VERIFIED,
-                data: {
-                    strategy: NATIVE_AUTH_STRATEGY_NAME,
-                },
-            });
-            return this.findOneByUserId(ctx, user.id);
+    ): Promise<ErrorResultUnion<VerifyCustomerAccountResult, Customer>> {
+        const result = await this.userService.verifyUserByToken(ctx, verificationToken, password);
+        if (isGraphQlErrorResult(result)) {
+            return result;
+        }
+        const customer = await this.findOneByUserId(ctx, result.id);
+        if (!customer) {
+            throw new InternalServerError('error.cannot-locate-customer-for-user');
         }
+        await this.historyService.createHistoryEntryForCustomer({
+            customerId: customer.id,
+            ctx,
+            type: HistoryEntryType.CUSTOMER_VERIFIED,
+            data: {
+                strategy: NATIVE_AUTH_STRATEGY_NAME,
+            },
+        });
+        return assertFound(this.findOneByUserId(ctx, result.id));
     }
 
     async requestPasswordReset(ctx: RequestContext, emailAddress: string): Promise<void> {
@@ -329,34 +403,35 @@ export class CustomerService {
         ctx: RequestContext,
         passwordResetToken: string,
         password: string,
-    ): Promise<Customer | undefined> {
-        const user = await this.userService.resetPasswordByToken(ctx, passwordResetToken, password);
-        if (user) {
-            const customer = await this.findOneByUserId(ctx, user.id);
-            if (!customer) {
-                throw new InternalServerError('error.cannot-locate-customer-for-user');
-            }
-            await this.historyService.createHistoryEntryForCustomer({
-                customerId: customer.id,
-                ctx,
-                type: HistoryEntryType.CUSTOMER_PASSWORD_RESET_VERIFIED,
-                data: {},
-            });
-            return customer;
+    ): Promise<User | PasswordResetTokenExpiredError | PasswordResetTokenInvalidError> {
+        const result = await this.userService.resetPasswordByToken(ctx, passwordResetToken, password);
+        if (isGraphQlErrorResult(result)) {
+            return result;
         }
+        const customer = await this.findOneByUserId(ctx, result.id);
+        if (!customer) {
+            throw new InternalServerError('error.cannot-locate-customer-for-user');
+        }
+        await this.historyService.createHistoryEntryForCustomer({
+            customerId: customer.id,
+            ctx,
+            type: HistoryEntryType.CUSTOMER_PASSWORD_RESET_VERIFIED,
+            data: {},
+        });
+        return result;
     }
 
     async requestUpdateEmailAddress(
         ctx: RequestContext,
         userId: ID,
         newEmailAddress: string,
-    ): Promise<boolean> {
+    ): Promise<boolean | EmailAddressConflictError> {
         const userWithConflictingIdentifier = await this.userService.getUserByEmailAddress(
             ctx,
             newEmailAddress,
         );
         if (userWithConflictingIdentifier) {
-            throw new UserInputError('error.email-address-not-available');
+            return new EmailAddressConflictError();
         }
         const user = await this.userService.getUserById(ctx, userId);
         if (!user) {
@@ -401,8 +476,15 @@ export class CustomerService {
         }
     }
 
-    async updateEmailAddress(ctx: RequestContext, token: string): Promise<boolean> {
-        const { user, oldIdentifier } = await this.userService.changeIdentifierByToken(ctx, token);
+    async updateEmailAddress(
+        ctx: RequestContext,
+        token: string,
+    ): Promise<boolean | IdentifierChangeTokenInvalidError | IdentifierChangeTokenExpiredError> {
+        const result = await this.userService.changeIdentifierByToken(ctx, token);
+        if (isGraphQlErrorResult(result)) {
+            return result;
+        }
+        const { user, oldIdentifier } = result;
         if (!user) {
             return false;
         }
@@ -425,31 +507,14 @@ export class CustomerService {
         return true;
     }
 
-    async update(ctx: RequestContext, input: UpdateCustomerInput): Promise<Customer> {
-        const customer = await this.connection.getEntityOrThrow(ctx, Customer, input.id, {
-            channelId: ctx.channelId,
-        });
-        const updatedCustomer = patchEntity(customer, input);
-        await this.connection.getRepository(ctx, Customer).save(updatedCustomer, { reload: false });
-        await this.historyService.createHistoryEntryForCustomer({
-            customerId: customer.id,
-            ctx,
-            type: HistoryEntryType.CUSTOMER_DETAIL_UPDATED,
-            data: {
-                input,
-            },
-        });
-        return assertFound(this.findOne(ctx, customer.id));
-    }
-
     /**
      * For guest checkouts, we assume that a matching email address is the same customer.
      */
     async createOrUpdate(
         ctx: RequestContext,
         input: Partial<CreateCustomerInput> & { emailAddress: string },
-        throwOnExistingUser: boolean = false,
-    ): Promise<Customer> {
+        errorOnExistingUser: boolean = false,
+    ): Promise<Customer | EmailAddressConflictError> {
         input.emailAddress = normalizeEmailAddress(input.emailAddress);
         let customer: Customer;
         const existing = await this.connection.getRepository(ctx, Customer).findOne({
@@ -460,9 +525,9 @@ export class CustomerService {
             },
         });
         if (existing) {
-            if (existing.user && throwOnExistingUser) {
+            if (existing.user && errorOnExistingUser) {
                 // It is not permitted to modify an existing *registered* Customer
-                throw new IllegalOperationError('error.cannot-use-registered-email-address-for-guest-order');
+                return new EmailAddressConflictError();
             }
             customer = patchEntity(existing, input);
             customer.channels.push(await this.connection.getEntityOrThrow(ctx, Channel, ctx.channelId));

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

@@ -1,4 +1,5 @@
 import { Injectable } from '@nestjs/common';
+import { UpdateCustomerInput as UpdateCustomerShopInput } from '@vendure/common/lib/generated-shop-types';
 import {
     HistoryEntryListOptions,
     HistoryEntryType,
@@ -29,7 +30,7 @@ export type CustomerHistoryEntryData = {
         strategy: string;
     };
     [HistoryEntryType.CUSTOMER_DETAIL_UPDATED]: {
-        input: UpdateCustomerInput;
+        input: UpdateCustomerInput | UpdateCustomerShopInput;
     };
     [HistoryEntryType.CUSTOMER_ADDRESS_CREATED]: {
         address: string;

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

@@ -1,8 +1,17 @@
 import { Injectable } from '@nestjs/common';
-import { PaymentInput } from '@vendure/common/lib/generated-shop-types';
 import {
+    AddPaymentToOrderResult,
+    ApplyCouponCodeResult,
+    PaymentInput,
+    RemoveOrderItemsResult,
+    SetOrderShippingMethodResult,
+    UpdateOrderItemsResult,
+} from '@vendure/common/lib/generated-shop-types';
+import {
+    AddFulfillmentToOrderResult,
     AddNoteToOrderInput,
     CancelOrderInput,
+    CancelOrderResult,
     CreateAddressInput,
     DeletionResponse,
     DeletionResult,
@@ -11,6 +20,8 @@ import {
     OrderLineInput,
     OrderProcessState,
     RefundOrderInput,
+    RefundOrderResult,
+    SettlePaymentResult,
     SettleRefundInput,
     ShippingMethodQuote,
     UpdateOrderNoteInput,
@@ -20,13 +31,35 @@ import { notNullOrUndefined } from '@vendure/common/lib/shared-utils';
 import { unique } from '@vendure/common/lib/unique';
 
 import { RequestContext } from '../../api/common/request-context';
+import { ErrorResultUnion, isGraphQlErrorResult } from '../../common/error/error-result';
 import {
     EntityNotFoundError,
     IllegalOperationError,
     InternalServerError,
-    OrderItemsLimitError,
     UserInputError,
 } from '../../common/error/errors';
+import {
+    AlreadyRefundedError,
+    CancelActiveOrderError,
+    EmptyOrderLineSelectionError,
+    ItemsAlreadyFulfilledError,
+    MultipleOrderError,
+    NothingToRefundError,
+    PaymentOrderMismatchError,
+    PaymentStateTransitionError,
+    QuantityTooGreatError,
+    RefundOrderStateError,
+    SettlePaymentError,
+} from '../../common/error/generated-graphql-admin-errors';
+import {
+    NegativeQuantityError,
+    OrderLimitError,
+    OrderModificationError,
+    OrderPaymentStateError,
+    OrderStateTransitionError,
+    PaymentDeclinedError,
+    PaymentFailedError,
+} from '../../common/error/generated-graphql-shop-errors';
 import { ListQueryOptions } from '../../common/types/common-types';
 import { assertFound, idsAreEqual } from '../../common/utils';
 import { ConfigService } from '../../config/config.service';
@@ -276,11 +309,15 @@ export class OrderService {
         productVariantId: ID,
         quantity: number,
         customFields?: { [key: string]: any },
-    ): Promise<Order> {
-        this.assertQuantityIsPositive(quantity);
+    ): Promise<ErrorResultUnion<UpdateOrderItemsResult, Order>> {
         const order = await this.getOrderOrThrow(ctx, orderId);
-        this.assertAddingItemsState(order);
-        this.assertNotOverOrderItemsLimit(order, quantity);
+        const validationError =
+            this.assertQuantityIsPositive(quantity) ||
+            this.assertAddingItemsState(order) ||
+            this.assertNotOverOrderItemsLimit(order, quantity);
+        if (validationError) {
+            return validationError;
+        }
         const productVariant = await this.getProductVariantOrThrow(ctx, productVariantId);
         let orderLine = order.lines.find(line => {
             return (
@@ -304,7 +341,7 @@ export class OrderService {
         orderLineId: ID,
         quantity?: number | null,
         customFields?: { [key: string]: any },
-    ): Promise<Order> {
+    ): Promise<ErrorResultUnion<UpdateOrderItemsResult, Order>> {
         const { priceCalculationStrategy } = this.configService.orderOptions;
         const order =
             orderIdOrOrder instanceof Order
@@ -314,11 +351,15 @@ export class OrderService {
         if (customFields != null) {
             orderLine.customFields = customFields;
         }
-        this.assertAddingItemsState(order);
         if (quantity != null) {
-            this.assertQuantityIsPositive(quantity);
             const currentQuantity = orderLine.quantity;
-            this.assertNotOverOrderItemsLimit(order, quantity - currentQuantity);
+            const validationError =
+                this.assertAddingItemsState(order) ||
+                this.assertQuantityIsPositive(quantity) ||
+                this.assertNotOverOrderItemsLimit(order, quantity - currentQuantity);
+            if (validationError) {
+                return validationError;
+            }
             if (currentQuantity < quantity) {
                 if (!orderLine.items) {
                     orderLine.items = [];
@@ -349,9 +390,16 @@ export class OrderService {
         return this.applyPriceAdjustments(ctx, order, orderLine);
     }
 
-    async removeItemFromOrder(ctx: RequestContext, orderId: ID, orderLineId: ID): Promise<Order> {
+    async removeItemFromOrder(
+        ctx: RequestContext,
+        orderId: ID,
+        orderLineId: ID,
+    ): Promise<ErrorResultUnion<RemoveOrderItemsResult, Order>> {
         const order = await this.getOrderOrThrow(ctx, orderId);
-        this.assertAddingItemsState(order);
+        const validationError = this.assertAddingItemsState(order);
+        if (validationError) {
+            return validationError;
+        }
         const orderLine = this.getOrderLineOrThrow(order, orderLineId);
         order.lines = order.lines.filter(line => !idsAreEqual(line.id, orderLineId));
         const updatedOrder = await this.applyPriceAdjustments(ctx, order);
@@ -359,31 +407,44 @@ export class OrderService {
         return updatedOrder;
     }
 
-    async removeAllItemsFromOrder(ctx: RequestContext, orderId: ID): Promise<Order> {
+    async removeAllItemsFromOrder(
+        ctx: RequestContext,
+        orderId: ID,
+    ): Promise<ErrorResultUnion<RemoveOrderItemsResult, Order>> {
         const order = await this.getOrderOrThrow(ctx, orderId);
-        this.assertAddingItemsState(order);
+        const validationError = this.assertAddingItemsState(order);
+        if (validationError) {
+            return validationError;
+        }
         await this.connection.getRepository(ctx, OrderLine).remove(order.lines);
         order.lines = [];
         const updatedOrder = await this.applyPriceAdjustments(ctx, order);
         return updatedOrder;
     }
 
-    async applyCouponCode(ctx: RequestContext, orderId: ID, couponCode: string) {
+    async applyCouponCode(
+        ctx: RequestContext,
+        orderId: ID,
+        couponCode: string,
+    ): Promise<ErrorResultUnion<ApplyCouponCodeResult, Order>> {
         const order = await this.getOrderOrThrow(ctx, orderId);
         if (order.couponCodes.includes(couponCode)) {
             return order;
         }
-        const promotion = await this.promotionService.validateCouponCode(
+        const validationResult = await this.promotionService.validateCouponCode(
             ctx,
             couponCode,
             order.customer && order.customer.id,
         );
+        if (isGraphQlErrorResult(validationResult)) {
+            return validationResult;
+        }
         order.couponCodes.push(couponCode);
         await this.historyService.createHistoryEntryForOrder({
             ctx,
             orderId: order.id,
             type: HistoryEntryType.ORDER_COUPON_APPLIED,
-            data: { couponCode, promotionId: promotion.id },
+            data: { couponCode, promotionId: validationResult.id },
         });
         return this.applyPriceAdjustments(ctx, order);
     }
@@ -442,9 +503,16 @@ export class OrderService {
         }));
     }
 
-    async setShippingMethod(ctx: RequestContext, orderId: ID, shippingMethodId: ID): Promise<Order> {
+    async setShippingMethod(
+        ctx: RequestContext,
+        orderId: ID,
+        shippingMethodId: ID,
+    ): Promise<ErrorResultUnion<SetOrderShippingMethodResult, Order>> {
         const order = await this.getOrderOrThrow(ctx, orderId);
-        this.assertAddingItemsState(order);
+        const validationError = this.assertAddingItemsState(order);
+        if (validationError) {
+            return validationError;
+        }
         const eligibleMethods = await this.shippingCalculator.getEligibleShippingMethods(ctx, order);
         const selectedMethod = eligibleMethods.find(m => idsAreEqual(m.method.id, shippingMethodId));
         if (!selectedMethod) {
@@ -456,11 +524,20 @@ export class OrderService {
         return this.connection.getRepository(ctx, Order).save(order);
     }
 
-    async transitionToState(ctx: RequestContext, orderId: ID, state: OrderState): Promise<Order> {
+    async transitionToState(
+        ctx: RequestContext,
+        orderId: ID,
+        state: OrderState,
+    ): Promise<Order | OrderStateTransitionError> {
         const order = await this.getOrderOrThrow(ctx, orderId);
         order.payments = await this.getOrderPayments(ctx, orderId);
         const fromState = order.state;
-        await this.orderStateMachine.transition(ctx, order, state);
+        try {
+            await this.orderStateMachine.transition(ctx, order, state);
+        } catch (e) {
+            const transitionError = ctx.translate(e.message, { fromState, toState: state });
+            return new OrderStateTransitionError(transitionError, fromState, state);
+        }
         await this.connection.getRepository(ctx, Order).save(order, { reload: false });
         this.eventBus.publish(new OrderStateTransitionEvent(fromState, state, ctx, order));
         return order;
@@ -511,10 +588,14 @@ export class OrderService {
         }
     }
 
-    async addPaymentToOrder(ctx: RequestContext, orderId: ID, input: PaymentInput): Promise<Order> {
+    async addPaymentToOrder(
+        ctx: RequestContext,
+        orderId: ID,
+        input: PaymentInput,
+    ): Promise<ErrorResultUnion<AddPaymentToOrderResult, Order>> {
         const order = await this.getOrderOrThrow(ctx, orderId);
         if (order.state !== 'ArrangingPayment') {
-            throw new IllegalOperationError(`error.payment-may-only-be-added-in-arrangingpayment-state`);
+            return new OrderPaymentStateError();
         }
         const payment = await this.paymentMethodService.createPayment(
             ctx,
@@ -528,10 +609,10 @@ export class OrderService {
         await this.connection.getRepository(ctx, Order).save(order, { reload: false });
 
         if (payment.state === 'Error') {
-            // TODO: we need to return an Error response as per
-            // https://github.com/vendure-ecommerce/vendure/issues/437
-            // Throwing an error rolls back all changes, which we do not want.
-            // throw new InternalServerError(payment.errorMessage);
+            return new PaymentFailedError(payment.errorMessage);
+        }
+        if (payment.state === 'Declined') {
+            return new PaymentDeclinedError(payment.errorMessage);
         }
 
         if (orderTotalIsCovered(order, 'Settled')) {
@@ -543,7 +624,10 @@ export class OrderService {
         return order;
     }
 
-    async settlePayment(ctx: RequestContext, paymentId: ID): Promise<Payment> {
+    async settlePayment(
+        ctx: RequestContext,
+        paymentId: ID,
+    ): Promise<ErrorResultUnion<SettlePaymentResult, Payment>> {
         const payment = await this.connection.getEntityOrThrow(ctx, Payment, paymentId, {
             relations: ['order'],
         });
@@ -555,46 +639,56 @@ export class OrderService {
         if (settlePaymentResult.success) {
             const fromState = payment.state;
             const toState = 'Settled';
-            await this.paymentStateMachine.transition(ctx, payment.order, payment, toState);
+            try {
+                await this.paymentStateMachine.transition(ctx, payment.order, payment, toState);
+            } catch (e) {
+                const transitionError = ctx.translate(e.message, { fromState, toState });
+                return new PaymentStateTransitionError(transitionError, fromState, toState);
+            }
             payment.metadata = { ...payment.metadata, ...settlePaymentResult.metadata };
             await this.connection.getRepository(ctx, Payment).save(payment, { reload: false });
             this.eventBus.publish(
                 new PaymentStateTransitionEvent(fromState, toState, ctx, payment, payment.order),
             );
             if (payment.amount === payment.order.total) {
-                await this.transitionToState(ctx, payment.order.id, 'PaymentSettled');
+                const orderTransitionResult = await this.transitionToState(
+                    ctx,
+                    payment.order.id,
+                    'PaymentSettled',
+                );
+                if (isGraphQlErrorResult(orderTransitionResult)) {
+                    return orderTransitionResult;
+                }
             }
+        } else {
+            return new SettlePaymentError(settlePaymentResult.errorMessage || '');
         }
         return payment;
     }
 
-    async createFulfillment(ctx: RequestContext, input: FulfillOrderInput) {
+    async createFulfillment(
+        ctx: RequestContext,
+        input: FulfillOrderInput,
+    ): Promise<ErrorResultUnion<AddFulfillmentToOrderResult, Fulfillment>> {
         if (
             !input.lines ||
             input.lines.length === 0 ||
             input.lines.reduce((total, line) => total + line.quantity, 0) === 0
         ) {
-            throw new UserInputError('error.create-fulfillment-nothing-to-fulfill');
+            return new EmptyOrderLineSelectionError();
         }
-        const { items, orders } = await this.getOrdersAndItemsFromLines(
-            ctx,
-            input.lines,
-            i => !i.fulfillment,
-            'error.create-fulfillment-items-already-fulfilled',
-        );
-
-        for (const order of orders) {
-            if (order.state !== 'PaymentSettled' && order.state !== 'PartiallyDelivered') {
-                throw new IllegalOperationError('error.create-fulfillment-orders-must-be-settled');
-            }
+        const ordersAndItems = await this.getOrdersAndItemsFromLines(ctx, input.lines, i => !i.fulfillment);
+        if (!ordersAndItems) {
+            return new ItemsAlreadyFulfilledError();
         }
+
         const fulfillment = await this.fulfillmentService.create(ctx, {
             trackingCode: input.trackingCode,
             method: input.method,
-            orderItems: items,
+            orderItems: ordersAndItems.items,
         });
 
-        for (const order of orders) {
+        for (const order of ordersAndItems.orders) {
             await this.historyService.createHistoryEntryForOrder({
                 ctx,
                 orderId: order.id,
@@ -627,20 +721,33 @@ export class OrderService {
         const items = lines.reduce((acc, l) => [...acc, ...l.items], [] as OrderItem[]);
         return unique(items.map(i => i.fulfillment).filter(notNullOrUndefined), 'id');
     }
-    async cancelOrder(ctx: RequestContext, input: CancelOrderInput): Promise<Order> {
+
+    async cancelOrder(
+        ctx: RequestContext,
+        input: CancelOrderInput,
+    ): Promise<ErrorResultUnion<CancelOrderResult, Order>> {
         let allOrderItemsCancelled = false;
-        if (input.lines != null) {
-            allOrderItemsCancelled = await this.cancelOrderByOrderLines(ctx, input, input.lines);
+        const cancelResult =
+            input.lines != null
+                ? await this.cancelOrderByOrderLines(ctx, input, input.lines)
+                : await this.cancelOrderById(ctx, input);
+
+        if (isGraphQlErrorResult(cancelResult)) {
+            return cancelResult;
         } else {
-            allOrderItemsCancelled = await this.cancelOrderById(ctx, input);
+            allOrderItemsCancelled = cancelResult;
         }
+
         if (allOrderItemsCancelled) {
-            await this.transitionToState(ctx, input.orderId, 'Cancelled');
+            const transitionResult = await this.transitionToState(ctx, input.orderId, 'Cancelled');
+            if (isGraphQlErrorResult(transitionResult)) {
+                return transitionResult;
+            }
         }
         return assertFound(this.findOne(ctx, input.orderId));
     }
 
-    private async cancelOrderById(ctx: RequestContext, input: CancelOrderInput): Promise<boolean> {
+    private async cancelOrderById(ctx: RequestContext, input: CancelOrderInput) {
         const order = await this.getOrderOrThrow(ctx, input.orderId);
         if (order.state === 'AddingItems' || order.state === 'ArrangingPayment') {
             return true;
@@ -657,27 +764,24 @@ export class OrderService {
         ctx: RequestContext,
         input: CancelOrderInput,
         lines: OrderLineInput[],
-    ): Promise<boolean> {
+    ) {
         if (lines.length === 0 || lines.reduce((total, line) => total + line.quantity, 0) === 0) {
-            throw new UserInputError('error.cancel-order-lines-nothing-to-cancel');
+            return new EmptyOrderLineSelectionError();
         }
-        const { items, orders } = await this.getOrdersAndItemsFromLines(
-            ctx,
-            lines,
-            i => !i.cancelled,
-            'error.cancel-order-lines-quantity-too-high',
-        );
-        if (1 < orders.length) {
-            throw new IllegalOperationError('error.order-lines-must-belong-to-same-order');
+        const ordersAndItems = await this.getOrdersAndItemsFromLines(ctx, lines, i => !i.cancelled);
+        if (!ordersAndItems) {
+            return new QuantityTooGreatError();
         }
+        if (1 < ordersAndItems.orders.length) {
+            return new MultipleOrderError();
+        }
+        const { orders, items } = ordersAndItems;
         const order = orders[0];
         if (!idsAreEqual(order.id, input.orderId)) {
-            throw new IllegalOperationError('error.order-lines-must-belong-to-same-order');
+            return new MultipleOrderError();
         }
         if (order.state === 'AddingItems' || order.state === 'ArrangingPayment') {
-            throw new IllegalOperationError('error.cancel-order-lines-invalid-order-state', {
-                state: order.state,
-            });
+            return new CancelActiveOrderError(order.state);
         }
 
         // Perform the cancellation
@@ -685,12 +789,9 @@ export class OrderService {
         items.forEach(i => (i.cancelled = true));
         await this.connection.getRepository(ctx, OrderItem).save(items, { reload: false });
 
-        const orderWithItems = await this.connection.getRepository(ctx, Order).findOne(order.id, {
+        const orderWithItems = await this.connection.getEntityOrThrow(ctx, Order, order.id, {
             relations: ['lines', 'lines.items'],
         });
-        if (!orderWithItems) {
-            throw new InternalServerError('error.could-not-find-order');
-        }
         await this.historyService.createHistoryEntryForOrder({
             ctx,
             orderId: order.id,
@@ -703,29 +804,31 @@ export class OrderService {
         return orderItemsAreAllCancelled(orderWithItems);
     }
 
-    async refundOrder(ctx: RequestContext, input: RefundOrderInput): Promise<Refund> {
+    async refundOrder(
+        ctx: RequestContext,
+        input: RefundOrderInput,
+    ): Promise<ErrorResultUnion<RefundOrderResult, Refund>> {
         if (
             (!input.lines ||
                 input.lines.length === 0 ||
                 input.lines.reduce((total, line) => total + line.quantity, 0) === 0) &&
             input.shipping === 0
         ) {
-            throw new UserInputError('error.refund-order-lines-nothing-to-refund');
+            return new NothingToRefundError();
         }
-        const { items, orders } = await this.getOrdersAndItemsFromLines(
-            ctx,
-            input.lines,
-            i => !i.cancelled,
-            'error.refund-order-lines-quantity-too-high',
-        );
+        const ordersAndItems = await this.getOrdersAndItemsFromLines(ctx, input.lines, i => !i.cancelled);
+        if (!ordersAndItems) {
+            return new QuantityTooGreatError();
+        }
+        const { orders, items } = ordersAndItems;
         if (1 < orders.length) {
-            throw new IllegalOperationError('error.order-lines-must-belong-to-same-order');
+            return new MultipleOrderError();
         }
         const payment = await this.connection.getEntityOrThrow(ctx, Payment, input.paymentId, {
             relations: ['order'],
         });
         if (orders && orders.length && !idsAreEqual(payment.order.id, orders[0].id)) {
-            throw new IllegalOperationError('error.refund-order-payment-lines-mismatch');
+            return new PaymentOrderMismatchError();
         }
         const order = payment.order;
         if (
@@ -733,12 +836,11 @@ export class OrderService {
             order.state === 'ArrangingPayment' ||
             order.state === 'PaymentAuthorized'
         ) {
-            throw new IllegalOperationError('error.refund-order-lines-invalid-order-state', {
-                state: order.state,
-            });
+            return new RefundOrderStateError(order.state);
         }
-        if (items.some(i => !!i.refundId)) {
-            throw new IllegalOperationError('error.refund-order-item-already-refunded');
+        const alreadyRefunded = items.find(i => !!i.refundId);
+        if (alreadyRefunded) {
+            return new AlreadyRefundedError(alreadyRefunded.refundId as string);
         }
 
         return await this.paymentMethodService.createRefund(ctx, input, order, items, payment);
@@ -768,9 +870,12 @@ export class OrderService {
         if (order.couponCodes) {
             let codesRemoved = false;
             for (const couponCode of order.couponCodes.slice()) {
-                try {
-                    await this.promotionService.validateCouponCode(ctx, couponCode, customer.id);
-                } catch (err) {
+                const validationResult = await this.promotionService.validateCouponCode(
+                    ctx,
+                    couponCode,
+                    customer.id,
+                );
+                if (isGraphQlErrorResult(validationResult)) {
                     order.couponCodes = order.couponCodes.filter(c => c !== couponCode);
                     codesRemoved = true;
                 }
@@ -844,8 +949,12 @@ export class OrderService {
             await this.connection.getRepository(ctx, Order).delete(orderToDelete.id);
         }
         if (order && linesToInsert) {
+            const orderId = order.id;
             for (const line of linesToInsert) {
-                order = await this.addItemToOrder(ctx, order.id, line.productVariantId, line.quantity);
+                const result = await this.addItemToOrder(ctx, orderId, line.productVariantId, line.quantity);
+                if (!isGraphQlErrorResult(result)) {
+                    order = result;
+                }
             }
         }
         const customer = await this.customerService.findOneByUserId(ctx, user.id);
@@ -896,20 +1005,20 @@ export class OrderService {
     }
 
     /**
-     * Throws if quantity is negative.
+     * Returns error if quantity is negative.
      */
     private assertQuantityIsPositive(quantity: number) {
         if (quantity < 0) {
-            throw new IllegalOperationError(`error.order-item-quantity-must-be-positive`, { quantity });
+            return new NegativeQuantityError();
         }
     }
 
     /**
-     * Throws if the Order is not in the "AddingItems" state.
+     * Returns error if the Order is not in the "AddingItems" state.
      */
     private assertAddingItemsState(order: Order) {
         if (order.state !== 'AddingItems') {
-            throw new IllegalOperationError(`error.order-contents-may-only-be-modified-in-addingitems-state`);
+            return new OrderModificationError();
         }
     }
 
@@ -921,7 +1030,7 @@ export class OrderService {
         const currentItemsCount = order.lines.reduce((count, line) => count + line.quantity, 0);
         const { orderItemsLimit } = this.configService.orderOptions;
         if (orderItemsLimit < currentItemsCount + quantityToAdd) {
-            throw new OrderItemsLimitError(orderItemsLimit);
+            return new OrderLimitError(orderItemsLimit);
         }
     }
 
@@ -958,8 +1067,7 @@ export class OrderService {
         ctx: RequestContext,
         orderLinesInput: OrderLineInput[],
         itemMatcher: (i: OrderItem) => boolean,
-        noMatchesError: string,
-    ): Promise<{ orders: Order[]; items: OrderItem[] }> {
+    ): Promise<{ orders: Order[]; items: OrderItem[] } | false> {
         const orders = new Map<ID, Order>();
         const items = new Map<ID, OrderItem>();
 
@@ -984,7 +1092,7 @@ export class OrderService {
             }
             const matchingItems = line.items.sort((a, b) => (a.id < b.id ? -1 : 1)).filter(itemMatcher);
             if (matchingItems.length < inputLine.quantity) {
-                throw new IllegalOperationError(noMatchesError);
+                return false;
             }
             matchingItems.slice(0, inputLine.quantity).forEach(item => {
                 items.set(item.id, item);