@unchainedshop/api 2.0.0-beta8 → 2.0.0-beta9

package/lib/schema/types/user.js

@@ -86,6 +86,9 @@ export default [
 
     type User {
       _id: ID!
+      created: DateTime!
+      updated: DateTime
+      deleted: DateTime
       username: String
       isGuest: Boolean!
       isTwoFactorEnabled: Boolean!

package/lib/schema/types/user.js.map

@@ -1 +1 @@
-{"version":3,"file":"user.js","sourceRoot":"","sources":["../../../src/schema/types/user.js"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHb;CACF,CAAC"}
+{"version":3,"file":"user.js","sourceRoot":"","sources":["../../../src/schema/types/user.js"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqHb;CACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/api",
-  "version": "2.0.0-beta8",
+  "version": "2.0.0-beta9",
   "main": "lib/api-index.js",
   "exports": {
     ".": "./lib/api-index.js",
@@ -21,7 +21,8 @@
     "clean": "rm -rf lib",
     "build": "npm run clean && tsc",
     "watch": "tsc -w",
-    "test": "jest --watch"
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --forceExit",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --detectOpenHandles --forceExit"
   },
   "repository": {
     "type": "git",
@@ -39,7 +40,7 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "peerDependencies": {
-    "@apollo/server": "^4.2.1",
+    "@apollo/server": "^4.2.2",
     "cookie": "^0.5.0",
     "graphql": "^16.6.0"
   },
@@ -48,11 +49,11 @@
   },
   "dependencies": {
     "@metamask/eth-sig-util": "^5.0.2",
-    "@unchainedshop/core": "^2.0.0-beta8",
-    "@unchainedshop/events": "^2.0.0-beta8",
-    "@unchainedshop/logger": "^2.0.0-beta8",
-    "@unchainedshop/roles": "^2.0.0-beta8",
-    "@unchainedshop/utils": "^2.0.0-beta8",
+    "@unchainedshop/core": "^2.0.0-beta9",
+    "@unchainedshop/events": "^2.0.0-beta9",
+    "@unchainedshop/logger": "^2.0.0-beta9",
+    "@unchainedshop/roles": "^2.0.0-beta9",
+    "@unchainedshop/utils": "^2.0.0-beta9",
     "accounting": "0.4.1",
     "dataloader": "^2.1.0",
     "graphql-scalars": "^1.20.1",
@@ -64,12 +65,12 @@
   "devDependencies": {
     "@types/graphql-upload": "^8.0.12",
     "@types/locale": "^0.1.1",
-    "@types/node": "^18.11.9",
-    "@unchainedshop/types": "^2.0.0-beta8",
+    "@types/node": "^18.11.12",
+    "@unchainedshop/types": "^2.0.0-beta9",
     "express": "^4.18.2",
     "graphql": "^16.6.0",
     "jest": "^29.3.1",
     "ts-jest": "^29.0.3",
-    "typescript": "^4.9.3"
+    "typescript": "^4.9.4"
   }
 }

package/src/acl.ts

@@ -10,13 +10,13 @@ const defaultOptions = {
 const emptyObject = {};
 const emptyArray: CheckPermissionArgs = [];
 
-const ensureActionExists = (action, userOptions) => {
+export const ensureActionExists = (action, userOptions) => {
   if (!action) {
     throw new PermissionSystemError({ userOptions });
   }
 };
 
-const ensureIsFunction = (fn, action, options, key) => {
+export const ensureIsFunction = (fn, action, options, key) => {
   if (typeof fn !== 'function') {
     throw new PermissionSystemError({
       action,

package/src/api-index.ts

@@ -13,7 +13,7 @@ export { hashPassword } from './hashPassword';
 export * as roles from './roles';
 export { createContextResolver, getCurrentContextResolver, setCurrentContextResolver };
 
-const loadJSON = (filename) => {
+export const loadJSON = (filename) => {
   try {
     const base = typeof __filename !== 'undefined' && __filename;
     if (!base)

package/src/createGraphQLServer.ts

@@ -1,27 +1,30 @@
 import { ApolloServer } from '@apollo/server';
-import { GraphQLError } from 'graphql';
 import { log, LogLevel } from '@unchainedshop/logger';
+import { GraphQLFormattedError } from 'graphql';
 import typeDefs from './schema';
 import resolvers from './resolvers';
 
 const { APOLLO_ENGINE_KEY } = process.env;
 
-const logGraphQLServerError = (error) => {
+const logGraphQLServerError = (error: GraphQLFormattedError) => {
   try {
     const {
       message,
-      extensions: {
-        exception: { stacktrace, ...parameters },
-        ...extensions
-      },
+      extensions: { stacktrace, ...parameters },
       ...rest
     } = error;
-    log(`${message} ${extensions && extensions.code}`, {
+    log(`${message} ${parameters && parameters.code}`, {
       level: LogLevel.Error,
-      ...extensions,
+      ...parameters,
       ...rest,
     });
-    console.error(stacktrace, parameters); // eslint-disable-line
+    if (stacktrace && process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test') {
+      const nativeError = new Error(message);
+      nativeError.stack = (stacktrace as string[]).join('\n');
+      nativeError.name = parameters.code as string;
+      // eslint-disable-next-line
+      console.error(nativeError);
+    }
   } catch (e) {} // eslint-disable-line
 };
 
@@ -38,21 +41,7 @@ export default async (options) => {
     resolvers: [resolvers, ...additionalResolvers],
     formatError: (error) => {
       logGraphQLServerError(error);
-      const {
-        message,
-        path,
-        extensions: { exception, code, ...extensions }, // eslint-disable-line
-      } = error;
-      const apolloError = new GraphQLError(message, {
-        extensions: {
-          code,
-          ...extensions,
-        },
-      });
-      // eslint-disable-next-line
-      // @ts-ignore
-      apolloError.path = path;
-      return apolloError;
+      return error;
     },
     apollo: APOLLO_ENGINE_KEY
       ? {

package/src/errors.ts

@@ -202,3 +202,88 @@ export const TokenWrongStatusError = createError(
   'TokenWrongStatusError',
   'The current status of the token does not allow this operation',
 );
+
+export const CyclicAssortmentLinkNotSupportedError = createError(
+  'CyclicAssortmentLinkNotSupported',
+  'Cyclic assortment link detected, make sure child assortment is not assigned as a parent on the assortment graph',
+);
+
+export const EmailAlreadyExistsError = createError(
+  'EmailAlreadyExists',
+  'Email already exist in the database',
+);
+
+export const UsernameAlreadyExistsError = createError(
+  'UsernameAlreadyExists',
+  'Username already exist in the database',
+);
+
+export const UsernameOrEmailRequiredError = createError(
+  'UsernameOrEmailRequired',
+  'No username or email is provided.',
+);
+
+export const TwoFactorCodeDidNotMatchError = createError(
+  'TwoFactorCodeDidNotMatch',
+  "2FA code didn't match",
+);
+
+export const TwoFactorCodeRequiredError = createError('TwoFactorCodeRequired', '2FA code required');
+
+export const TwoFactorAlreadySetError = createError('TwoFactorAlreadySet', '2FA already set for user');
+
+export const TwoFactorNotSetError = createError('TwoFactorNotSet', '2FA not set for user');
+
+export const InvalidCredentialsError = createError(
+  'InvalidCredentials',
+  'Incorrect credential provided',
+);
+
+export const InvalidResetTokenError = createError('InvalidResetTokenError', 'Token validation failed');
+
+export const NoEmailSetError = createError('NoEmailSet', 'User has no email set');
+
+export const ResetPasswordLinkExpiredError = createError(
+  'ResetPasswordLinkExpired',
+  'Token does not exist or is expired',
+);
+
+export const ResetPasswordLinkUnknownAddressError = createError(
+  'ResetPasswordLinkUnknownAddress',
+  'Valid token but no email address found for the entry',
+);
+
+export const AuthenticationFailedError = createError(
+  'AuthenticationFailed',
+  'Failed to authenticate the user',
+);
+
+export const UserDeactivatedError = createError(
+  'UserDeactivatedError',
+  'User is deactivated, so not allowed to login',
+);
+
+export const AuthOperationFailedError = createError(
+  'AuthOperationFailed',
+  'Operation failed, please make sure you have provided all required parameters',
+);
+
+export const ProductLinkedToActiveVariationError = createError(
+  'ProductLinkedToActiveVariation',
+  'Product is part of a active variation, remove it from any active/draft variation before deleting',
+);
+
+export const ProductLinkedToActiveBundleError = createError(
+  'ProductLinkedToActiveBundle',
+  'Product is part of a active/draft bundle item, remove it from any active/draft bundle item before deleting',
+);
+
+export const ProductLinkedToEnrollmentError = createError(
+  'ProductLinkedToEnrollment',
+  'Product is part of a active/paused subscriptions item, remove it from any active/paused subscriptions item before deleting',
+);
+
+export const ProductLinkedToQuotationError = createError(
+  'ProductLinkedToQuotation',
+  'Product is part of a requested/proposed quotations item, remove it from any requested/proposed quotations item before deleting',
+);

package/src/express/createBulkImportMiddleware.ts

@@ -68,15 +68,12 @@ export default function bulkImportMiddleware(contextResolver: UnchainedContextRe
               input.payloadId = file._id;
               input.payloadSize = file.length;
             }
-            const work = await context.modules.worker.addWork(
-              {
-                type: 'BULK_IMPORT',
-                input: Object.fromEntries(Object.entries(input).filter(([, value]) => Boolean(value))),
-                retries: 0,
-                priority: 10,
-              },
-              context.userId,
-            );
+            const work = await context.modules.worker.addWork({
+              type: 'BULK_IMPORT',
+              input: Object.fromEntries(Object.entries(input).filter(([, value]) => Boolean(value))),
+              retries: 0,
+              priority: 10,
+            });
             res.writeHead(200);
             res.end(JSON.stringify(work));
           } catch (e) {

package/src/express/createERCMetadataMiddleware.ts

@@ -54,9 +54,10 @@ export default function ercMetadataMiddleware(contextResolver: UnchainedContextR
         {
           token,
           product,
+          locale: new Locale(locale),
           referenceDate: new Date(),
         },
-        { ...context, localeContext: new Locale(locale) },
+        context,
       );
 
       const body = JSON.stringify(ercMetadata);

package/src/express/createSingleSignOnMiddleware.ts

@@ -1,14 +1,15 @@
 /// <reference lib="dom" />
 import { createLogger } from '@unchainedshop/logger';
-import { Context, UnchainedContextResolver } from '@unchainedshop/types/api';
+import { UnchainedContextResolver } from '@unchainedshop/types/api';
 import { IncomingMessage } from 'http';
 import cookie from 'cookie';
+import { UnchainedCore } from '@unchainedshop/types/core';
 
 const { ROOT_URL, NODE_ENV, UNCHAINED_CLOUD_ENDPOINT } = process.env;
 
 const logger = createLogger('unchained:unchained-cloud-sso');
 
-const loginWithSingleSignOn = async (remoteToken, context: Context) => {
+const loginWithSingleSignOn = async (remoteToken, context: UnchainedCore) => {
   const domain = process.env.UNCHAINED_COOKIE_DOMAIN || new URL(ROOT_URL).hostname || 'localhost';
   const result = await fetch(UNCHAINED_CLOUD_ENDPOINT, {
     method: 'POST',

package/src/loaders/index.ts

@@ -17,27 +17,22 @@ export default async (
   unchainedAPI: UnchainedCore,
 ): Promise<UnchainedLoaders['loaders']> => {
   return {
-    assortmentLoader: new DataLoader<{ assortmentId: string; includeInactive: boolean }, Assortment>(
-      async (queries) => {
-        const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+    assortmentLoader: new DataLoader<{ assortmentId: string }, Assortment>(async (queries) => {
+      const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
 
-        const assortments = await unchainedAPI.modules.assortments.findAssortments({
-          assortmentIds,
-          includeInactive: true,
-          includeLeaves: true,
-        });
+      const assortments = await unchainedAPI.modules.assortments.findAssortments({
+        assortmentIds,
+        includeInactive: true,
+        includeLeaves: true,
+      });
 
-        return queries.map(({ assortmentId, includeInactive }) => {
-          return assortments.find((assortment) => {
-            if (assortment._id !== assortmentId) return false;
-            if (!includeInactive) {
-              return assortment.isActive === true;
-            }
-            return true;
-          });
+      return queries.map(({ assortmentId }) => {
+        return assortments.find((assortment) => {
+          if (assortment._id !== assortmentId) return false;
+          return true;
         });
-      },
-    ),
+      });
+    }),
 
     assortmentTextLoader: new DataLoader<{ assortmentId: string; locale: string }, AssortmentText>(
       async (queries) => {
@@ -118,26 +113,23 @@ export default async (
       });
     }),
 
-    productLoader: new DataLoader<{ productId: string; includeDrafts: boolean }, Product>(
-      async (queries) => {
-        const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+    productLoader: new DataLoader<{ productId: string }, Product>(async (queries) => {
+      const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
 
-        const products = await unchainedAPI.modules.products.findProducts({
-          productIds,
-          includeDrafts: true,
-        });
+      const products = await unchainedAPI.modules.products.findProducts({
+        productIds,
+        productSelector: {
+          status: { $in: [null, ProductStatus.ACTIVE, ProductStatus.DELETED] },
+        },
+      });
 
-        return queries.map(({ productId, includeDrafts }) => {
-          return products.find((product) => {
-            if (product._id !== productId) return false;
-            if (!includeDrafts) {
-              return product.status === ProductStatus.ACTIVE;
-            }
-            return true;
-          });
+      return queries.map(({ productId }) => {
+        return products.find((product) => {
+          if (product._id !== productId) return false;
+          return true;
         });
-      },
-    ),
+      });
+    }),
 
     productTextLoader: new DataLoader<{ productId: string; locale: string }, ProductText>(
       async (queries) => {

package/src/resolvers/mutations/accounts/changePassword.ts

@@ -1,5 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api';
+import { AuthOperationFailedError, InvalidCredentialsError } from '../../../errors';
 
 export default async function changePassword(
   root: Root,
@@ -17,8 +18,14 @@ export default async function changePassword(
   if (!params.oldPlainPassword) {
     throw new Error('Old password is required');
   }
-
-  const success = await modules.accounts.changePassword(userId, params);
+  let success = false;
+  try {
+    success = await modules.accounts.changePassword(userId, params);
+  } catch (e) {
+    success = false;
+    if (e.code === 'InvalidCredentials') throw new InvalidCredentialsError({});
+    else throw new AuthOperationFailedError({});
+  }
 
   return { success };
 }

package/src/resolvers/mutations/accounts/createUser.ts

@@ -2,6 +2,12 @@ import { UserData } from '@unchainedshop/types/accounts';
 import { Context, Root } from '@unchainedshop/types/api';
 import { log } from '@unchainedshop/logger';
 import { hashPassword } from '../../../hashPassword';
+import {
+  AuthOperationFailedError,
+  EmailAlreadyExistsError,
+  UsernameAlreadyExistsError,
+  UsernameOrEmailRequiredError,
+} from '../../../errors';
 
 export default async function createUser(root: Root, params: UserData, context: Context) {
   const { modules, userId } = context;
@@ -25,10 +31,19 @@ export default async function createUser(root: Root, params: UserData, context:
       params.username,
       params.webAuthnPublicKeyCredentials,
     ));
-
-  const newUserId = await modules.accounts.createUser(mappedUser, {
-    skipPasswordEnrollment: !!webAuthnService,
-  });
+  let newUserId;
+  try {
+    newUserId = await modules.accounts.createUser(mappedUser, {
+      skipPasswordEnrollment: !!webAuthnService,
+    });
+  } catch (e) {
+    if (e.code === 'EmailAlreadyExists') throw new EmailAlreadyExistsError({ email: params?.email });
+    else if (e.code === 'UsernameAlreadyExists')
+      throw new UsernameAlreadyExistsError({ username: params?.username });
+    else if (e.code === 'UsernameOrEmailRequired')
+      throw new UsernameOrEmailRequiredError({ username: params?.username });
+    else throw new AuthOperationFailedError({ username: params?.username, email: params.email });
+  }
 
   if (newUserId && webAuthnService) {
     await modules.users.updateUser(

package/src/resolvers/mutations/accounts/disableTOTP.ts

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api';
-import { UserNotFoundError } from '../../../errors';
+import { TwoFactorCodeDidNotMatchError, TwoFactorNotSetError, UserNotFoundError } from '../../../errors';
 
 export default async function disableTOTP(
   root: Root,
@@ -15,8 +15,18 @@ export default async function disableTOTP(
 
   const user = await modules.users.findUserById(normalizedUserId);
   if (!user) throw new UserNotFoundError({ userId: normalizedUserId });
-
-  await modules.accounts.disableTOTP(normalizedUserId, params.code);
+  try {
+    await modules.accounts.disableTOTP(normalizedUserId, params.code);
+  } catch (e) {
+    if (e?.message?.includes("2FA code didn't match"))
+      throw new TwoFactorCodeDidNotMatchError({
+        submittedCode: params.code,
+        userId: params?.userId || userId,
+      });
+    else if (e?.message?.includes('2FA not set'))
+      throw new TwoFactorNotSetError({ userId: params?.userId || userId });
+    else throw e;
+  }
 
   return user;
 }

package/src/resolvers/mutations/accounts/enableTOTP.ts

@@ -1,5 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api';
+import { TwoFactorAlreadySetError, TwoFactorCodeDidNotMatchError } from '../../../errors';
 
 export default async function enableTOTP(
   root: Root,
@@ -9,8 +10,14 @@ export default async function enableTOTP(
   log(`mutation enableTOTP ${params.code}`, {
     userId,
   });
-
-  await modules.accounts.enableTOTP(userId, params.secretBase32, params.code);
+  try {
+    await modules.accounts.enableTOTP(userId, params.secretBase32, params.code);
+  } catch (e) {
+    if (e?.message?.includes("2FA code didn't match"))
+      throw new TwoFactorCodeDidNotMatchError({ submittedCode: params.code, userId });
+    else if (e?.message?.includes('2FA already set')) throw new TwoFactorAlreadySetError({ userId });
+    else throw e;
+  }
 
   return modules.users.findUserById(userId);
 }

package/src/resolvers/mutations/accounts/enrollUser.ts

@@ -2,6 +2,12 @@ import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api';
 import { UserData } from '@unchainedshop/types/accounts';
 import { hashPassword } from '../../../hashPassword';
+import {
+  AuthOperationFailedError,
+  EmailAlreadyExistsError,
+  UsernameAlreadyExistsError,
+  UsernameOrEmailRequiredError,
+} from '../../../errors';
 
 export default async function enrollUser(root: Root, params: UserData, context: Context) {
   const { modules } = context;
@@ -17,9 +23,18 @@ export default async function enrollUser(root: Root, params: UserData, context:
 
   // Skip Messaging when password is set so we
   // don't send a verification e-mail after enrollment
-  const userId = await modules.accounts.createUser(mappedUserData, {
-    skipMessaging: !!mappedUserData.password,
-  });
+  try {
+    const userId = await modules.accounts.createUser(mappedUserData, {
+      skipMessaging: !!mappedUserData.password,
+    });
 
-  return modules.users.findUserById(userId);
+    return modules.users.findUserById(userId);
+  } catch (e) {
+    if (e.code === 'EmailAlreadyExists') throw new EmailAlreadyExistsError({ email: params?.email });
+    else if (e.code === 'UsernameAlreadyExists')
+      throw new UsernameAlreadyExistsError({ username: params?.username, email: params.email });
+    else if (e.code === 'UsernameOrEmailRequired')
+      throw new UsernameOrEmailRequiredError({ username: params?.username, email: params.email });
+    else throw new AuthOperationFailedError({ username: params?.username, email: params.email });
+  }
 }

package/src/resolvers/mutations/accounts/forgotPassword.ts

@@ -1,5 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api';
+import { AuthOperationFailedError, UserNotFoundError } from '../../../errors';
 
 export default async function forgotPassword(
   root: Root,
@@ -8,7 +9,13 @@ export default async function forgotPassword(
 ) {
   log('mutation forgotPassword', { email, userId });
 
-  const success = await modules.accounts.sendResetPasswordEmail(email);
+  let success = false;
+  try {
+    success = await modules.accounts.sendResetPasswordEmail(email);
+  } catch (e) {
+    if (e.code === 'UserNotFound') throw new UserNotFoundError({ email });
+    else throw new AuthOperationFailedError({ email });
+  }
 
   return { success };
 }

package/src/resolvers/mutations/accounts/impersonate.ts

@@ -8,7 +8,7 @@ const impersonate = async (root, { userId }, context: Context) => {
   const userToImpersonate = await context.modules.users.findUserById(userId);
 
   if (!userToImpersonate) {
-    throw new UserNotFoundError(`No user with id ${userId}`);
+    throw new UserNotFoundError({ userId });
   }
 
   if ((userToImpersonate.roles || []).includes('admin')) {

package/src/resolvers/mutations/accounts/loginWithPassword.ts

@@ -1,5 +1,13 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api';
+import {
+  AuthenticationFailedError,
+  AuthOperationFailedError,
+  InvalidCredentialsError,
+  TwoFactorCodeDidNotMatchError,
+  TwoFactorCodeRequiredError,
+  UserDeactivatedError,
+} from '../../../errors';
 import { hashPassword } from '../../../hashPassword';
 
 export default async function loginWithPassword(
@@ -27,5 +35,20 @@ export default async function loginWithPassword(
     code: totpCode,
   };
 
-  return modules.accounts.loginWithService({ service: 'password', ...mappedUserLoginParams }, context);
+  try {
+    const result = await modules.accounts.loginWithService(
+      { service: 'password', ...mappedUserLoginParams },
+      context,
+    );
+    return result;
+  } catch (e) {
+    if (e.code === 'AuthenticationFailed') throw new AuthenticationFailedError({ username, email });
+    else if (e.code === 'UserDeactivated') throw new UserDeactivatedError({ username, email });
+    else if (e.code === 'InvalidCredentials') throw new InvalidCredentialsError({ username, email });
+    else if (e?.message?.includes('2FA code required'))
+      throw new TwoFactorCodeRequiredError({ username, email });
+    else if (e?.message?.includes("2FA code didn't match"))
+      throw new TwoFactorCodeDidNotMatchError({ submittedCode: params.totpCode, username, email });
+    else throw new AuthOperationFailedError({ submittedCode: params.totpCode, username, email });
+  }
 }

package/src/resolvers/mutations/accounts/loginWithWebAuthn.ts

@@ -1,5 +1,10 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api';
+import {
+  AuthenticationFailedError,
+  AuthOperationFailedError,
+  UserDeactivatedError,
+} from '../../../errors';
 
 export default async function loginWithWebAuthn(
   root: Root,
@@ -11,6 +16,12 @@ export default async function loginWithWebAuthn(
   const { modules } = context;
 
   log('mutation loginWithWebAuthn');
-
-  return modules.accounts.loginWithService({ service: 'webAuthn', ...params }, context);
+  try {
+    const result = await modules.accounts.loginWithService({ service: 'webAuthn', ...params }, context);
+    return result;
+  } catch (e) {
+    if (e.code === 'AuthenticationFailed') throw new AuthenticationFailedError({});
+    else if (e.code === 'UserDeactivated') throw new UserDeactivatedError({});
+    else throw new AuthOperationFailedError({});
+  }
 }

package/src/resolvers/mutations/accounts/logout.ts

@@ -1,12 +1,19 @@
 import { Context, Root } from '@unchainedshop/types/api';
 import { log, LogLevel } from '@unchainedshop/logger';
 
-export default async function logout(root: Root, params: { token: string }, context: Context) {
+export default async function logout(root: Root, { token }: { token: string }, context: Context) {
   const { modules, userId, setLoginToken } = context;
 
   log('mutation logout', { userId });
 
-  const loggedOut = await modules.accounts.logout(params, context);
+  const loggedOut = await modules.accounts.logout(
+    {
+      token,
+      loginToken: context.loginToken,
+      userId: context.userId,
+    },
+    context,
+  );
 
   if (loggedOut.error) {
     log('Error while logging out', {