@unchainedshop/api 2.12.2 → 3.0.0-alpha2

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

@@ -1,54 +1,51 @@
 import { log } from '@unchainedshop/logger';
+
 import { Context, Root } from '@unchainedshop/types/api.js';
-import {
-  AuthenticationFailedError,
-  AuthOperationFailedError,
-  InvalidCredentialsError,
-  TwoFactorCodeDidNotMatchError,
-  TwoFactorCodeRequiredError,
-  UserDeactivatedError,
-} from '../../../errors.js';
-import { hashPassword } from '../../../hashPassword.js';
+import { InvalidCredentialsError } from '../../../errors.js';
 
 export default async function loginWithPassword(
   root: Root,
   params: {
     username?: string;
     email?: string;
-    plainPassword?: string;
-    totpCode?: string;
+    password?: string;
   },
   context: Context,
 ) {
-  const { modules } = context;
-  const { username, email, plainPassword, totpCode } = params;
-
+  const { username, email, password } = params;
   log('mutation loginWithPassword', { username, email });
 
-  if (!plainPassword) {
+  if (!password) {
     throw new Error('Password is required');
   }
 
-  const mappedUserLoginParams = {
-    user: email ? { email } : { username },
-    password: hashPassword(plainPassword),
-    code: totpCode,
-  };
-
-  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 });
+  let user = username
+    ? await context.modules.users.findUserByUsername(username)
+    : await context.modules.users.findUserByEmail(email);
+
+  const verified =
+    user.services?.password &&
+    (await context.modules.users.verifyPassword(user.services.password, password));
+
+  if (!verified) throw new InvalidCredentialsError({ username, email });
+
+  if (user.guest) {
+    await context.modules.users.updateGuest(user, false);
+  }
+
+  user = await context.modules.users.updateHeartbeat(user._id, {
+    remoteAddress: context.remoteAddress,
+    remotePort: context.remotePort,
+    userAgent: context.userAgent,
+    locale: context.localeContext.normalized,
+    countryCode: context.countryContext,
+  });
+
+  if (context.userId) {
+    await context.services.users.migrateUserData(context.userId, user._id, context);
   }
+
+  await context.services.orders.nextUserCart({ user, countryCode: context.countryContext }, context);
+
+  return context.login(user);
 }

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

@@ -1,10 +1,5 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api.js';
-import {
-  AuthenticationFailedError,
-  AuthOperationFailedError,
-  UserDeactivatedError,
-} from '../../../errors.js';
 
 export default async function loginWithWebAuthn(
   root: Root,
@@ -13,15 +8,27 @@ export default async function loginWithWebAuthn(
   },
   context: Context,
 ) {
-  const { modules } = context;
-
   log('mutation loginWithWebAuthn');
-  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({});
-  }
+
+  const username =
+    Buffer.from(params.webAuthnPublicKeyCredentials?.response?.userHandle, 'base64').toString() || '';
+
+  let user = await context.modules.users.findUserByUsername(username);
+  if (!user) throw new Error('User not found');
+
+  await context.modules.users.webAuthn.verifyCredentialRequest(
+    user.services?.webAuthn,
+    user.username,
+    params.webAuthnPublicKeyCredentials,
+  );
+
+  user = await context.modules.users.updateHeartbeat(user._id, {
+    remoteAddress: context.remoteAddress,
+    remotePort: context.remotePort,
+    userAgent: context.userAgent,
+    locale: context.localeContext.normalized,
+    countryCode: context.countryContext,
+  });
+
+  return context.login(user);
 }

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

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

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

@@ -14,7 +14,7 @@ export default async function removeEmail(
   if (!(await modules.users.userExists({ userId: normalizedUserId })))
     throw new UserNotFoundError({ userId: normalizedUserId });
 
-  await modules.accounts.removeEmail(normalizedUserId, params.email);
+  await modules.users.removeEmail(normalizedUserId, params.email);
 
   return modules.users.findUserById(normalizedUserId);
 }

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

@@ -1,71 +1,68 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api.js';
-import { emailRegexOperator } from '@unchainedshop/mongodb';
-import {
-  AuthOperationFailedError,
-  InvalidResetTokenError,
-  NoEmailSetError,
-  ResetPasswordLinkExpiredError,
-  ResetPasswordLinkUnknownAddressError,
-} from '../../../errors.js';
+import { InvalidResetTokenError, PasswordInvalidError } from '../../../errors.js';
 
 export default async function resetPassword(
   root: Root,
-  params: { newPlainPassword?: string; token: string },
+  params: { newPassword?: string; token: string },
   context: Context,
 ) {
   const { modules, userId } = context;
 
   log('mutation resetPassword', { userId });
 
-  if (!params.newPlainPassword) {
+  if (!params.newPassword) {
     throw new Error('Password is required');
   }
-  try {
-    const userWithNewPassword = await modules.accounts.resetPassword(params, context);
+  let user = await modules.users.findUserByResetToken(params.token);
+
+  if (!user) throw new InvalidResetTokenError({});
 
-    const resetTicket = userWithNewPassword?.services?.password?.reset?.find(
-      (t) => t.token === params.token,
-    );
-    if (resetTicket.address) {
-      // Try verifying the E-Mail along the way
-      try {
-        const updatedUser = await modules.users.updateUser(
-          {
-            _id: userWithNewPassword.id,
-            emails: {
-              $elemMatch: {
-                address: emailRegexOperator(resetTicket.address),
-                verified: false,
-              },
-            },
-          },
-          {
-            $set: {
-              'emails.$[email].verified': true,
-            },
-          },
-          {
-            arrayFilters: [{ 'email.address': resetTicket.address }],
-          },
-        );
-        if (updatedUser) {
-          await modules.accounts.emit('VerifyEmailSuccess', updatedUser);
-        }
-      } catch (e) {
-        /* */
-      }
-    }
+  try {
+    await modules.users.setPassword(user._id, params.newPassword);
 
-    const result = await modules.accounts.createLoginToken(userWithNewPassword.id, context);
-    return result;
+    // TODO: Verify E-Mail after reset!
+    // if (resetTicket.address) {
+    //   // Try verifying the E-Mail along the way
+    //   try {
+    //     const updatedUser = await modules.users.updateUser(
+    //       {
+    //         _id: userWithNewPassword.id,
+    //         emails: {
+    //           $elemMatch: {
+    //             address: emailRegexOperator(resetTicket.address),
+    //             verified: false,
+    //           },
+    //         },
+    //       },
+    //       {
+    //         $set: {
+    //           'emails.$[email].verified': true,
+    //         },
+    //       },
+    //       {
+    //         arrayFilters: [{ 'email.address': resetTicket.address }],
+    //       },
+    //     );
+    //     if (updatedUser) {
+    //       await modules.accounts.emit('VerifyEmailSuccess', updatedUser);
+    //     }
+    //   } catch (e) {
+    //     /* */
+    //   }
+    // }
   } catch (e) {
-    log(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({});
+    if (e.cause === 'PASSWORD_INVALID') throw new PasswordInvalidError({ userId: user._id });
+    else throw e;
   }
+
+  user = await context.modules.users.updateHeartbeat(user._id, {
+    remoteAddress: context.remoteAddress,
+    remotePort: context.remotePort,
+    userAgent: context.userAgent,
+    locale: context.localeContext.normalized,
+    countryCode: context.countryContext,
+  });
+
+  return context.login(user);
 }

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

@@ -1,5 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api.js';
+import { UserNotFoundError } from '../../../errors.js';
 
 export default async function sendEnrollmentEmail(
   root: Root,
@@ -8,8 +9,11 @@ export default async function sendEnrollmentEmail(
 ) {
   log('mutation sendEnrollmentEmail', { email, userId });
 
+  const user = await modules.users.findUserByEmail(email);
+  if (!user) throw new UserNotFoundError({ email });
+
   try {
-    await modules.accounts.sendEnrollmentEmail(email);
+    await modules.users.sendResetPasswordEmail(user._id, email, true);
     return {
       success: true,
     };

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

@@ -1,5 +1,6 @@
 import { Context, Root } from '@unchainedshop/types/api.js';
 import { log } from '@unchainedshop/logger';
+import { UserNotFoundError } from '../../../errors.js';
 
 export default async function sendVerificationEmail(
   root: Root,
@@ -8,9 +9,17 @@ export default async function sendVerificationEmail(
 ) {
   log('mutation sendVerificationEmail', { email, userId });
 
-  await modules.accounts.sendVerificationEmail(email);
+  const user = await modules.users.findUserByEmail(email);
+  if (!user) throw new UserNotFoundError({ email });
 
-  return {
-    success: true,
-  };
+  try {
+    await modules.users.sendVerificationEmail(user._id, email);
+    return {
+      success: true,
+    };
+  } catch (e) {
+    return {
+      success: false,
+    };
+  }
 }

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

@@ -1,10 +1,10 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api.js';
-import { UserNotFoundError, InvalidIdError } from '../../../errors.js';
+import { UserNotFoundError, InvalidIdError, PasswordInvalidError } from '../../../errors.js';
 
 export default async function setPassword(
   root: Root,
-  params: { newPlainPassword: string; userId: string },
+  params: { newPassword: string; userId: string },
   { modules, userId }: Context,
 ) {
   const normalizedUserId = params.userId || userId;
@@ -12,13 +12,18 @@ export default async function setPassword(
   log(`mutation setPassword ${normalizedUserId}`, { userId });
 
   if (!normalizedUserId) throw new InvalidIdError({ userId: normalizedUserId });
-  if (!params.newPlainPassword) {
+  if (!params.newPassword) {
     throw new Error('Password is required');
   }
   if (!(await modules.users.userExists({ userId: normalizedUserId })))
     throw new UserNotFoundError({ userId: normalizedUserId });
 
-  await modules.accounts.setPassword(normalizedUserId, params);
+  try {
+    await modules.users.setPassword(normalizedUserId, params.newPassword);
+  } catch (e) {
+    if (e.cause === 'PASSWORD_INVALID') throw new PasswordInvalidError({ userId: normalizedUserId });
+    else throw e;
+  }
 
   return modules.users.findUserById(normalizedUserId);
 }

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

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api.js';
-import { UserNotFoundError, InvalidIdError } from '../../../errors.js';
+import { UserNotFoundError, InvalidIdError, UsernameAlreadyExistsError } from '../../../errors.js';
 
 export default async function setUsername(
   root: Root,
@@ -15,7 +15,13 @@ export default async function setUsername(
   if (!(await modules.users.userExists({ userId: normalizedUserId })))
     throw new UserNotFoundError({ userId: normalizedUserId });
 
-  await modules.accounts.setUsername(normalizedUserId, params.username);
+  try {
+    await modules.users.setUsername(normalizedUserId, params.username);
+  } catch (e) {
+    if (e.cause === 'USERNAME_INVALID')
+      throw new UsernameAlreadyExistsError({ userId: normalizedUserId });
+    else throw e;
+  }
 
   return modules.users.findUserById(normalizedUserId);
 }

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

@@ -1,18 +1,27 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api.js';
+import { InvalidEmailVerificationTokenError } from '../../../errors.js';
 
 export default async function verifyEmail(root: Root, { token }: { token: any }, context: Context) {
   const { modules, userId } = context;
 
   log(`mutation verifyEmail ${userId}`, { userId });
 
-  const unverifiedUser = await modules.accounts.findUnverifiedUserByToken(token);
+  const unverifiedToken = await modules.users.findUnverifiedEmailToken(token);
 
-  await modules.accounts.verifyEmail(token);
-  const verifiedUser = await modules.users.findUserById(unverifiedUser.id);
-  await modules.accounts.emit('VerifyEmailSuccess', verifiedUser);
+  if (!unverifiedToken) {
+    throw new InvalidEmailVerificationTokenError({ token });
+  }
 
-  const tokenData = await modules.accounts.createLoginToken(unverifiedUser.id, context);
+  await modules.users.verifyEmail(unverifiedToken.userId, unverifiedToken.address);
 
-  return tokenData;
+  const user = await context.modules.users.updateHeartbeat(unverifiedToken.userId, {
+    remoteAddress: context.remoteAddress,
+    remotePort: context.remotePort,
+    userAgent: context.userAgent,
+    locale: context.localeContext.normalized,
+    countryCode: context.countryContext,
+  });
+
+  return context.login(user);
 }

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

@@ -1,18 +1,27 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api.js';
-import { Assortment } from '@unchainedshop/types/assortments.js';
+import { Assortment, AssortmentText } from '@unchainedshop/types/assortments.js';
 
 export default async function createAssortment(
   root: Root,
-  { assortment }: { assortment: Assortment & { title: string; locale?: string } },
-  { modules, userId, localeContext }: Context,
+  {
+    texts,
+    assortment: assortmentData,
+  }: {
+    assortment: Assortment;
+    texts?: AssortmentText[];
+  },
+  { modules, userId }: Context,
 ) {
   log('mutation createAssortment', { userId });
 
-  const assortmentId = await modules.assortments.create({
-    ...assortment,
-    locale: localeContext.language,
+  const assortment = await modules.assortments.create({
+    ...assortmentData,
   });
 
-  return modules.assortments.findAssortment({ assortmentId });
+  if (texts) {
+    await modules.assortments.texts.updateTexts(assortment._id, texts);
+  }
+
+  return assortment;
 }

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

@@ -5,7 +5,7 @@ import { CountryNotFoundError, InvalidIdError } from '../../../errors.js';
 
 export default async function updateCountry(
   root: Root,
-  { country, countryId }: { country: Country; countryId: string },
+  { country, countryId }: { country: Country & { defaultCurrencyId: string }; countryId: string },
   { userId, modules }: Context,
 ) {
   log(`mutation updateCountry ${countryId}`, { userId });
@@ -15,7 +15,12 @@ export default async function updateCountry(
   if (!(await modules.countries.countryExists({ countryId })))
     throw new CountryNotFoundError({ countryId });
 
-  await modules.countries.update(countryId, country);
+  const currencyObject = await modules.currencies.findCurrency({
+    currencyId: country.defaultCurrencyId,
+  });
+  const defaultCurrencyCode = country?.defaultCurrencyCode || currencyObject?.isoCode;
+
+  await modules.countries.update(countryId, { ...country, defaultCurrencyCode });
 
   return modules.countries.findCountry({ countryId });
 }

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

@@ -13,7 +13,7 @@ export default async function createEnrollment(
   { contact, plan, billingAddress, payment, delivery, meta },
   context: Context,
 ) {
-  const { countryContext, modules, userId } = context;
+  const { countryContext, currencyContext, modules, userId } = context;
 
   log('mutation createEnrollment', { userId });
 
@@ -40,6 +40,7 @@ export default async function createEnrollment(
       configuration,
       contact,
       countryCode: countryContext,
+      currencyCode: currencyContext,
       delivery,
       meta,
       payment,

package/src/resolvers/mutations/filters/createFilter.ts

@@ -1,20 +1,25 @@
 import { log } from '@unchainedshop/logger';
 import { Root, Context } from '@unchainedshop/types/api.js';
-import { Filter } from '@unchainedshop/types/filters.js';
+import { Filter, FilterInputText } from '@unchainedshop/types/filters.js';
 
 export default async function createFilter(
   root: Root,
-  { filter }: { filter: Filter & { title: string } },
+  { filter, texts }: { filter: Filter; texts: FilterInputText[] },
   context: Context,
 ) {
   const { modules, localeContext, userId } = context;
   log('mutation createFilter', { userId });
 
-  return modules.filters.create(
+  const newFilter = await modules.filters.create(
     {
       ...filter,
+      title: '',
       locale: localeContext.language,
     },
     context,
   );
+  if (texts) {
+    await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
+  }
+  return newFilter;
 }

package/src/resolvers/mutations/filters/createFilterOption.ts

@@ -1,14 +1,15 @@
 import { Context, Root } from '@unchainedshop/types/api.js';
 import { log } from '@unchainedshop/logger';
+import { FilterInputText } from '@unchainedshop/types/filters.js';
 import { FilterNotFoundError, InvalidIdError } from '../../../errors.js';
 
 export default async function createFilterOption(
   root: Root,
-  params: { filterId: string; option: { value: string; title: string } },
+  params: { filterId: string; option: string; texts?: FilterInputText[] },
   context: Context,
 ) {
   const { modules, userId } = context;
-  const { filterId, option } = params;
+  const { filterId, option, texts } = params;
 
   log(`mutation createFilterOption ${filterId}`, { userId });
 
@@ -16,10 +17,11 @@ export default async function createFilterOption(
 
   if (!(await modules.filters.filterExists({ filterId }))) throw new FilterNotFoundError({ filterId });
 
-  const filter = await modules.filters.createFilterOption(
-    filterId,
-    { ...option, locale: context.localeContext.language },
-    context,
-  );
+  const filter = await modules.filters.createFilterOption(filterId, { value: option }, context);
+
+  if (texts) {
+    await modules.filters.texts.updateTexts({ filterId, filterOptionValue: option }, texts);
+  }
+
   return filter;
 }