@unchainedshop/api 2.0.0-beta7 → 2.0.0-beta9

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(
@@ -7,26 +15,40 @@ export default async function loginWithPassword(
   params: {
     username?: string;
     email?: string;
-    password?: string;
     plainPassword?: string;
     totpCode?: string;
   },
   context: Context,
 ) {
   const { modules } = context;
-  const { username, email, password: hashedPassword, plainPassword, totpCode } = params;
+  const { username, email, plainPassword, totpCode } = params;
 
   log('mutation loginWithPassword', { username, email });
 
-  if (!hashedPassword && !plainPassword) {
+  if (!plainPassword) {
     throw new Error('Password is required');
   }
 
   const mappedUserLoginParams = {
     user: email ? { email } : { username },
-    password: hashedPassword || hashPassword(plainPassword),
+    password: hashPassword(plainPassword),
     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', {

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

@@ -6,7 +6,13 @@ export default async function logoutAllSessions(root: Root, _: any, context: Con
 
   log('mutation logoutAllSessions', { userId });
 
-  const loggedOut = await modules.accounts.logout({}, context);
+  const loggedOut = await modules.accounts.logout(
+    {
+      loginToken: context.loginToken,
+      userId: context.userId,
+    },
+    context,
+  );
 
   if (loggedOut.error) {
     log('Error while logging out', {

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

@@ -1,20 +1,36 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api';
+import {
+  AuthOperationFailedError,
+  InvalidResetTokenError,
+  NoEmailSetError,
+  ResetPasswordLinkExpiredError,
+  ResetPasswordLinkUnknownAddressError,
+} from '../../../errors';
 
 export default async function resetPassword(
   root: Root,
-  params: { newPassword?: string; newPlainPassword?: string; token: string },
+  params: { newPlainPassword?: string; token: string },
   context: Context,
 ) {
   const { modules, userId } = context;
 
   log('mutation resetPassword', { userId });
 
-  if (!params.newPassword && !params.newPlainPassword) {
+  if (!params.newPlainPassword) {
     throw new Error('Password is required');
   }
+  try {
+    const userWithNewPassword = await modules.accounts.resetPassword(params, context);
 
-  const userWithNewPassword = await modules.accounts.resetPassword(params, context);
-
-  return modules.accounts.createLoginToken(userWithNewPassword.id, context);
+    const result = await modules.accounts.createLoginToken(userWithNewPassword.id, context);
+    return result;
+  } catch (e) {
+    if (e.code === 'InvalidToken') throw new InvalidResetTokenError({});
+    if (e.code === 'ResetPasswordLinkExpired') throw new ResetPasswordLinkExpiredError({});
+    if (e.code === 'ResetPasswordLinkUnknownAddress​')
+      throw new ResetPasswordLinkUnknownAddressError({});
+    if (e.code === 'NoEmailSet') throw new NoEmailSetError({});
+    throw new AuthOperationFailedError({});
+  }
 }

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

@@ -4,7 +4,7 @@ import { UserNotFoundError, InvalidIdError } from '../../../errors';
 
 export default async function setPassword(
   root: Root,
-  params: { newPassword: string; newPlainPassword: string; userId: string },
+  params: { newPlainPassword: string; userId: string },
   { modules, userId }: Context,
 ) {
   const normalizedUserId = params.userId || userId;
@@ -12,7 +12,7 @@ export default async function setPassword(
   log(`mutation setPassword ${normalizedUserId}`, { userId });
 
   if (!normalizedUserId) throw new InvalidIdError({ userId: normalizedUserId });
-  if (!params.newPassword && !params.newPlainPassword) {
+  if (!params.newPlainPassword) {
     throw new Error('Password is required');
   }
   if (!(await modules.users.userExists({ userId: normalizedUserId })))

package/src/resolvers/mutations/assortments/addAssortmentFilter.ts

@@ -20,13 +20,9 @@ export default async function addAssortmentFilter(
 
   if (!(await modules.filters.filterExists({ filterId }))) throw new FilterNotFoundError({ filterId });
 
-  return modules.assortments.filters.create(
-    {
-      assortmentId,
-      filterId,
-      authorId: userId,
-      ...assortmentFilter,
-    },
-    userId,
-  );
+  return modules.assortments.filters.create({
+    assortmentId,
+    filterId,
+    ...assortmentFilter,
+  });
 }

package/src/resolvers/mutations/assortments/addAssortmentLink.ts

@@ -1,7 +1,11 @@
 import { Context, Root } from '@unchainedshop/types/api';
 import { AssortmentLink } from '@unchainedshop/types/assortments';
 import { log } from '@unchainedshop/logger';
-import { AssortmentNotFoundError, InvalidIdError } from '../../../errors';
+import {
+  AssortmentNotFoundError,
+  CyclicAssortmentLinkNotSupportedError,
+  InvalidIdError,
+} from '../../../errors';
 
 export default async function addAssortmentLink(
   root: Root,
@@ -29,17 +33,21 @@ export default async function addAssortmentLink(
     throw new AssortmentNotFoundError({
       assortmentId: childAssortmentId,
     });
-
-  return modules.assortments.links.create(
-    {
-      parentAssortmentId,
-      childAssortmentId,
-      authorId: userId,
-      ...assortmentLink,
-    },
-    {
-      skipInvalidation: false,
-    },
-    userId,
-  );
+  try {
+    const result = await modules.assortments.links.create(
+      {
+        parentAssortmentId,
+        childAssortmentId,
+        ...assortmentLink,
+      },
+      {
+        skipInvalidation: false,
+      },
+    );
+    return result;
+  } catch (e) {
+    if (e?.message === 'CyclicGraphNotSupported')
+      throw new CyclicAssortmentLinkNotSupportedError({ parentAssortmentId, childAssortmentId });
+    throw e;
+  }
 }

package/src/resolvers/mutations/assortments/addAssortmentMedia.ts

@@ -15,16 +15,12 @@ export default async function addAssortmentMedia(root: Root, { media, assortment
     {
       directoryName: 'assortment-media',
       rawFile: media,
-      meta: { authorId: userId },
-      userId,
+      meta: {},
     },
     context,
   );
 
-  const assortmentMedia = await modules.assortments.media.create(
-    { assortmentId, mediaId: file._id },
-    userId,
-  );
+  const assortmentMedia = await modules.assortments.media.create({ assortmentId, mediaId: file._id });
 
   return assortmentMedia;
 }

package/src/resolvers/mutations/assortments/addAssortmentProduct.ts

@@ -27,10 +27,8 @@ export default async function addAssortmentProduct(
     {
       assortmentId,
       productId,
-      authorId: userId,
       ...assortmentProduct,
     },
     { skipInvalidation: false },
-    userId,
   );
 }

package/src/resolvers/mutations/assortments/createAssortment.ts

@@ -9,14 +9,10 @@ export default async function createAssortment(
 ) {
   log('mutation createAssortment', { userId });
 
-  const assortmentId = await modules.assortments.create(
-    {
-      ...assortment,
-      locale: localeContext.language,
-      authorId: userId,
-    },
-    userId,
-  );
+  const assortmentId = await modules.assortments.create({
+    ...assortment,
+    locale: localeContext.language,
+  });
 
   return modules.assortments.findAssortment({ assortmentId });
 }

package/src/resolvers/mutations/assortments/prepareAssortmentMediaUpload.ts

@@ -14,7 +14,6 @@ export default async function prepareAssortmentMediaUpload(
       directoryName: 'assortment-media',
       fileName: mediaName,
       meta: { assortmentId },
-      userId,
     },
     context,
   );

package/src/resolvers/mutations/assortments/removeAssortment.ts

@@ -14,7 +14,7 @@ export default async function removeAssortment(
   const assortment = await modules.assortments.findAssortment({ assortmentId });
   if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
 
-  await modules.assortments.delete(assortmentId, { skipInvalidation: false }, userId);
+  await modules.assortments.delete(assortmentId, { skipInvalidation: false });
 
   return assortment;
 }

package/src/resolvers/mutations/assortments/removeAssortmentFilter.ts

@@ -18,7 +18,7 @@ export default async function removeAssortmentFilter(
 
   if (!assortmentFilter) throw new AssortmentFilterNotFoundError({ assortmentFilterId });
 
-  await modules.assortments.filters.delete(assortmentFilterId, userId);
+  await modules.assortments.filters.delete(assortmentFilterId);
 
   return assortmentFilter;
 }

package/src/resolvers/mutations/assortments/removeAssortmentLink.ts

@@ -16,7 +16,7 @@ export default async function removeAssortmentLink(
 
   if (!assortmentLink) throw new AssortmentLinkNotFoundError({ assortmentLinkId });
 
-  await modules.assortments.links.delete(assortmentLinkId, { skipInvalidation: false }, userId);
+  await modules.assortments.links.delete(assortmentLinkId, { skipInvalidation: false });
 
   return assortmentLink;
 }

package/src/resolvers/mutations/assortments/removeAssortmentMedia.ts

@@ -18,8 +18,8 @@ export default async function removeAssortmentMedia(
   });
   if (!assortmentMedia) throw new AssortmentMediaNotFoundError({ assortmentMediaId });
 
-  await modules.files.delete(assortmentMedia.mediaId, userId);
-  await modules.assortments.media.delete(assortmentMediaId, userId);
+  await modules.files.delete(assortmentMedia.mediaId);
+  await modules.assortments.media.delete(assortmentMediaId);
 
   return assortmentMedia;
 }

package/src/resolvers/mutations/assortments/removeAssortmentProduct.ts

@@ -18,7 +18,7 @@ export default async function removeAssortmentProduct(
   });
   if (!assortmentProduct) throw new AssortmentProductNotFoundError({ assortmentProductId });
 
-  await modules.assortments.products.delete(assortmentProductId, { skipInvalidation: false }, userId);
+  await modules.assortments.products.delete(assortmentProductId, { skipInvalidation: false });
 
   return assortmentProduct;
 }

package/src/resolvers/mutations/assortments/reorderAssortmentFilters.ts

@@ -8,10 +8,7 @@ export default async function reorderAssortmentFilters(
 ) {
   log('mutation reorderAssortmentFilters', { userId });
 
-  return modules.assortments.filters.updateManualOrder(
-    {
-      sortKeys: params.sortKeys,
-    },
-    userId,
-  );
+  return modules.assortments.filters.updateManualOrder({
+    sortKeys: params.sortKeys,
+  });
 }

package/src/resolvers/mutations/assortments/reorderAssortmentLinks.ts

@@ -12,6 +12,5 @@ export default async function reorderAssortmentLinks(
       sortKeys: params.sortKeys,
     },
     { skipInvalidation: false },
-    userId,
   );
 }

package/src/resolvers/mutations/assortments/reorderAssortmentMedia.ts

@@ -7,10 +7,7 @@ export default async function reorderAssortmentMedia(
   { modules, userId }: Context,
 ) {
   log('mutation reorderAssortmentMedia', { userId });
-  return modules.assortments.media.updateManualOrder(
-    {
-      sortKeys: params.sortKeys,
-    },
-    userId,
-  );
+  return modules.assortments.media.updateManualOrder({
+    sortKeys: params.sortKeys,
+  });
 }

package/src/resolvers/mutations/assortments/reorderAssortmentProducts.ts

@@ -12,6 +12,5 @@ export default async function reorderAssortmentProducts(
       sortKeys: params.sortKeys,
     },
     { skipInvalidation: false },
-    userId,
   );
 }

package/src/resolvers/mutations/assortments/setBaseAssortment.ts

@@ -14,7 +14,7 @@ export default async function setBaseAssortment(
   if (!(await modules.assortments.assortmentExists({ assortmentId })))
     throw new AssortmentNotFoundError({ assortmentId });
 
-  await modules.assortments.setBase(assortmentId, userId);
+  await modules.assortments.setBase(assortmentId);
 
   return modules.assortments.findAssortment({ assortmentId });
 }

package/src/resolvers/mutations/assortments/updateAssortment.ts

@@ -17,7 +17,7 @@ export default async function updateAssortment(
   if (!(await modules.assortments.assortmentExists({ assortmentId })))
     throw new AssortmentNotFoundError({ assortmentId });
 
-  await modules.assortments.update(assortmentId, assortment, userId);
+  await modules.assortments.update(assortmentId, assortment);
 
   return modules.assortments.findAssortment({ assortmentId });
 }

package/src/resolvers/mutations/assortments/updateAssortmentMediaTexts.ts

@@ -20,5 +20,5 @@ export default async function updateAssortmentMediaTexts(
 
   if (!assortmentMedia) throw new AssortmentMediaNotFoundError({ assortmentMediaId });
 
-  return modules.assortments.media.texts.updateMediaTexts(assortmentMediaId, texts, userId);
+  return modules.assortments.media.texts.updateMediaTexts(assortmentMediaId, texts);
 }

package/src/resolvers/mutations/assortments/updateAssortmentTexts.ts

@@ -15,5 +15,5 @@ export default async function updateAssortmentTexts(
   if (!(await modules.assortments.assortmentExists({ assortmentId })))
     throw new AssortmentNotFoundError({ assortmentId });
 
-  return modules.assortments.texts.updateTexts(assortmentId, texts, userId);
+  return modules.assortments.texts.updateTexts(assortmentId, texts);
 }

package/src/resolvers/mutations/bookmarks/bookmark.ts

@@ -22,13 +22,10 @@ export default async function bookmark(
   if (bookmarked) {
     if (foundBookmark) return foundBookmark;
 
-    const bookmarkId = await modules.bookmarks.create(
-      {
-        productId,
-        userId,
-      },
+    const bookmarkId = await modules.bookmarks.create({
+      productId,
       userId,
-    );
+    });
 
     return modules.bookmarks.findById(bookmarkId);
   }
@@ -37,7 +34,7 @@ export default async function bookmark(
     throw new BookmarkNotFoundError({ productId, userId });
   }
 
-  await modules.bookmarks.delete(foundBookmark._id, userId);
+  await modules.bookmarks.delete(foundBookmark._id);
 
   return foundBookmark;
 }

package/src/resolvers/mutations/bookmarks/createBookmark.ts

@@ -22,13 +22,10 @@ export default async function createBookmark(
 
   if (bookmark) throw new BookmarkAlreadyExistsError({ bookmarkId: bookmark._id });
 
-  const bookmarkId = await modules.bookmarks.create(
-    {
-      userId,
-      productId,
-    },
-    currenctUserId,
-  );
+  const bookmarkId = await modules.bookmarks.create({
+    userId,
+    productId,
+  });
 
   return modules.bookmarks.findById(bookmarkId);
 }

package/src/resolvers/mutations/countries/createCountry.ts

@@ -9,13 +9,9 @@ export default async function createCountry(
 ) {
   log('mutation createCountry', { userId });
 
-  const countryId = await modules.countries.create(
-    {
-      ...country,
-      authorId: userId,
-    },
-    userId,
-  );
+  const countryId = await modules.countries.create({
+    ...country,
+  });
 
   return modules.countries.findCountry({ countryId });
 }

package/src/resolvers/mutations/countries/removeCountry.ts

@@ -14,7 +14,7 @@ export default async function removeCountry(
   if (!(await modules.countries.countryExists({ countryId })))
     throw new CountryNotFoundError({ countryId });
 
-  await modules.countries.delete(countryId, userId);
+  await modules.countries.delete(countryId);
 
   return modules.countries.findCountry({ countryId });
 }

package/src/resolvers/mutations/countries/updateCountry.ts

@@ -15,7 +15,7 @@ export default async function updateCountry(
   if (!(await modules.countries.countryExists({ countryId })))
     throw new CountryNotFoundError({ countryId });
 
-  await modules.countries.update(countryId, country, userId);
+  await modules.countries.update(countryId, country);
 
   return modules.countries.findCountry({ countryId });
 }

package/src/resolvers/mutations/currencies/createCurrency.ts

@@ -8,13 +8,9 @@ export default async function createCurrency(
   { userId, modules }: Context,
 ) {
   log('mutation createCurrency', { userId });
-  const currencyId = await modules.currencies.create(
-    {
-      ...currency,
-      authorId: userId,
-    },
-    userId,
-  );
+  const currencyId = await modules.currencies.create({
+    ...currency,
+  });
 
   return modules.currencies.findCurrency({ currencyId });
 }

package/src/resolvers/mutations/currencies/removeCurrency.ts

@@ -14,7 +14,7 @@ export default async function removeCurrency(
   if (!(await modules.currencies.currencyExists({ currencyId })))
     throw new CurrencyNotFoundError({ currencyId });
 
-  await modules.currencies.delete(currencyId, userId);
+  await modules.currencies.delete(currencyId);
 
   return modules.currencies.findCurrency({ currencyId });
 }

package/src/resolvers/mutations/currencies/updateCurrency.ts

@@ -14,7 +14,7 @@ export default async function updateCurrency(
   if (!(await modules.currencies.currencyExists({ currencyId })))
     throw new CurrencyNotFoundError({ currencyId });
 
-  await modules.currencies.update(currencyId, currency, userId);
+  await modules.currencies.update(currencyId, currency);
 
   return modules.currencies.findCurrency({ currencyId });
 }

package/src/resolvers/mutations/delivery/createDeliveryProvider.ts

@@ -10,13 +10,9 @@ export default async function createDeliveryProvider(
 ) {
   log('mutation createDeliveryProvider', { userId });
 
-  const provider = await modules.delivery.create(
-    {
-      ...deliveryProvider,
-      authorId: userId,
-    },
-    userId,
-  );
+  const provider = await modules.delivery.create({
+    ...deliveryProvider,
+  });
 
   if (!provider) throw new ProviderConfigurationInvalid(deliveryProvider);
 

package/src/resolvers/mutations/delivery/removeDeliveryProvider.ts

@@ -14,5 +14,5 @@ export default async function removeDeliveryProvider(
   const provider = await modules.delivery.findProvider({ deliveryProviderId });
   if (!provider) throw new DeliverProviderNotFoundError({ deliveryProviderId });
 
-  return modules.delivery.delete(deliveryProviderId, userId);
+  return modules.delivery.delete(deliveryProviderId);
 }

package/src/resolvers/mutations/delivery/updateDeliveryProvider.ts

@@ -17,5 +17,5 @@ export default async function updateDeliveryProvider(
   if (!(await modules.delivery.providerExists({ deliveryProviderId })))
     throw new DeliverProviderNotFoundError({ deliveryProviderId });
 
-  return modules.delivery.update(deliveryProviderId, deliveryProvider, userId);
+  return modules.delivery.update(deliveryProviderId, deliveryProvider);
 }

package/src/resolvers/mutations/enrollments/activateEnrollment.ts

@@ -28,5 +28,5 @@ export default async function activateEnrollment(
     throw new EnrollmentWrongStatusError({ status: enrollment.status });
   }
 
-  return modules.enrollments.activateEnrollment(enrollment, {}, context);
+  return modules.enrollments.activateEnrollment(enrollment, context);
 }

package/src/resolvers/mutations/enrollments/terminateEnrollment.ts

@@ -25,5 +25,5 @@ export default async function terminateEnrollment(
     throw new EnrollmentWrongStatusError({ status: enrollment.status });
   }
 
-  return modules.enrollments.terminateEnrollment(enrollment, {}, context);
+  return modules.enrollments.terminateEnrollment(enrollment, context);
 }

package/src/resolvers/mutations/enrollments/updateEnrollment.ts

@@ -38,23 +38,23 @@ export default async function updateEnrollment(
   }
 
   if (meta) {
-    enrollment = await modules.enrollments.updateContext(enrollmentId, meta, userId);
+    enrollment = await modules.enrollments.updateContext(enrollmentId, meta);
   }
 
   if (billingAddress) {
-    enrollment = await modules.enrollments.updateBillingAddress(enrollmentId, billingAddress, userId);
+    enrollment = await modules.enrollments.updateBillingAddress(enrollmentId, billingAddress);
   }
 
   if (contact) {
-    enrollment = await modules.enrollments.updateContact(enrollmentId, contact, userId);
+    enrollment = await modules.enrollments.updateContact(enrollmentId, contact);
   }
 
   if (payment) {
-    enrollment = await modules.enrollments.updatePayment(enrollmentId, payment, userId);
+    enrollment = await modules.enrollments.updatePayment(enrollmentId, payment);
   }
 
   if (delivery) {
-    enrollment = await modules.enrollments.updateDelivery(enrollmentId, delivery, userId);
+    enrollment = await modules.enrollments.updateDelivery(enrollmentId, delivery);
   }
 
   if (plan) {