@unchainedshop/api 2.14.2 → 3.0.0-alpha3

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

@@ -1,17 +1,17 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
+import { Context } from '../../../types.js';
 
 export default async function createWebAuthnCredentialCreationOptions(
-  root: Root,
+  root: never,
   { extensionOptions, username }: { username: string; extensionOptions: any },
-  { modules, userId, req }: Context,
+  { modules, userId, getHeader }: Context,
 ) {
   log(`mutation createWebAuthnCredentialCreationOptions ${username}`, {
     userId,
   });
 
-  const options = await modules.accounts.webAuthn.createCredentialCreationOptions(
-    req.headers.origin,
+  const options = await modules.users.webAuthn.createCredentialCreationOptions(
+    getHeader('origin') as string,
     username,
     extensionOptions,
   );

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

@@ -1,23 +1,23 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
+import { Context } from '../../../types.js';
 
 export default async function createWebAuthnCredentialRequestOptions(
-  root: Root,
+  root: never,
   { extensionOptions, username }: { username: string; extensionOptions: any },
-  { modules, userId, req }: Context,
+  { modules, userId, getHeader }: Context,
 ) {
   log(`mutation createWebAuthnCredentialRequestOptions ${username}`, {
     userId,
   });
 
-  const options = await modules.accounts.webAuthn.createCredentialRequestOptions(
-    req.headers.origin,
+  const options = await modules.users.webAuthn.createCredentialRequestOptions(
+    getHeader('origin') as string,
     username,
     extensionOptions,
   );
 
   if (username) {
-    const user = await modules.users.findUser({ username });
+    const user = await modules.users.findUserByUsername(username);
     options.allowCredentials = user?.services?.webAuthn?.map(({ id, type }) => ({
       id,
       type: type || options.type || 'public-key',

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

@@ -1,40 +1,42 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
-import { UserData } from '@unchainedshop/types/accounts.js';
-import { hashPassword } from '../../../hashPassword.js';
+import { Context } from '../../../types.js';
+
+import { UserData } from '@unchainedshop/core-users';
 import {
   AuthOperationFailedError,
   EmailAlreadyExistsError,
+  PasswordInvalidError,
   UsernameAlreadyExistsError,
   UsernameOrEmailRequiredError,
 } from '../../../errors.js';
 
-export default async function enrollUser(root: Root, params: UserData, context: Context) {
+export default async function enrollUser(root: never, params: UserData, context: Context) {
   const { modules } = context;
 
   log('mutation enrollUser', { email: params.email, userId: context.userId });
 
-  const mappedUserData = params;
-  mappedUserData.initialPassword = true;
-  if (mappedUserData.plainPassword) {
-    mappedUserData.password = hashPassword(mappedUserData.plainPassword);
+  if (!params.username && !params.email) {
+    throw new UsernameOrEmailRequiredError({});
   }
-  delete mappedUserData.plainPassword;
 
-  // Skip Messaging when password is set so we
-  // don't send a verification e-mail after enrollment
   try {
-    const userId = await modules.accounts.createUser(mappedUserData, {
-      skipMessaging: !!mappedUserData.password,
-    });
+    const userId = await modules.users.createUser(
+      {
+        ...params,
+        initialPassword: true,
+      },
+      {
+        skipMessaging: !!params.password,
+      },
+    );
 
     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 });
+    if (e.cause === 'EMAIL_INVALID') throw new EmailAlreadyExistsError({ email: params?.email });
+    else if (e.cause === 'USERNAME_INVALID')
+      throw new UsernameAlreadyExistsError({ username: params?.username });
+    else if (e.cause === 'PASSWORD_INVALID')
+      throw new PasswordInvalidError({ username: params?.username });
     else throw new AuthOperationFailedError({ username: params?.username, email: params.email });
   }
 }

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

@@ -1,21 +1,25 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
-import { AuthOperationFailedError, UserNotFoundError } from '../../../errors.js';
+import { UserNotFoundError } from '../../../errors.js';
+import { Context } from '../../../types.js';
 
 export default async function forgotPassword(
-  root: Root,
+  root: never,
   { email }: { email: string },
   { modules, userId }: Context,
 ) {
   log('mutation forgotPassword', { email, userId });
 
-  let success = false;
+  const user = await modules.users.findUserByEmail(email);
+  if (!user) throw new UserNotFoundError({ email });
+
   try {
-    success = await modules.accounts.sendResetPasswordEmail(email);
-  } catch (e) {
-    if (e.code === 'UserNotFound') throw new UserNotFoundError({ email });
-    else throw new AuthOperationFailedError({ email });
+    await modules.users.sendResetPasswordEmail(user._id, email);
+    return {
+      success: true,
+    };
+  } catch {
+    return {
+      success: false,
+    };
   }
-
-  return { success };
 }

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

@@ -1,12 +1,31 @@
-import { Context, Root } from '@unchainedshop/types/api.js';
 import { log } from '@unchainedshop/logger';
+import moniker from 'moniker';
+import { randomValueHex } from '@unchainedshop/utils';
+import { Context } from '../../../types.js';
 
-export default async function loginAsGuest(root: Root, _: any, context: Context) {
-  const { modules } = context;
-
+export default async function loginAsGuest(root: never, _: any, context: Context) {
   log('mutation loginAsGuest');
 
-  const loginToken = await modules.accounts.loginWithService({ service: 'guest' }, context);
+  const guestname = `${moniker.choose()}-${randomValueHex(5)}`;
+  const guestUserId = await context.modules.users.createUser(
+    {
+      email: `${guestname}@unchained.local`,
+      guest: true,
+      password: null,
+      initialPassword: true,
+    },
+    { skipMessaging: true },
+  );
+
+  let user = await context.modules.users.findUserById(guestUserId);
+
+  user = await context.modules.users.updateHeartbeat(user._id, {
+    remoteAddress: context.remoteAddress,
+    remotePort: context.remotePort,
+    userAgent: context.userAgent,
+    locale: context.localeContext.baseName,
+    countryCode: context.countryContext,
+  });
 
-  return loginToken;
+  return context.login(user);
 }

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

@@ -1,54 +1,50 @@
 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';
+import { Context } from '../../../types.js';
 
 export default async function loginWithPassword(
-  root: Root,
+  root: never,
   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.baseName,
+    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,27 +1,34 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
-import {
-  AuthenticationFailedError,
-  AuthOperationFailedError,
-  UserDeactivatedError,
-} from '../../../errors.js';
+import { Context } from '../../../types.js';
 
 export default async function loginWithWebAuthn(
-  root: Root,
+  root: never,
   params: {
     webAuthnPublicKeyCredentials?: any;
   },
   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.baseName,
+    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';
+import { Context } from '../../../types.js';
 
-export default async function logout(root: Root, { token }: { token: string }, context: Context) {
-  const { modules, userId, setLoginToken } = context;
+export default async function logout(root: never, _: 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(context.res, null);
-  }
-
-  return { success: loggedOut.success };
+  return { success };
 }

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

@@ -1,9 +1,9 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
 import { UserNotFoundError } from '../../../errors.js';
+import { Context } from '../../../types.js';
 
 export default async function removeEmail(
-  root: Root,
+  root: never,
   params: { email: string; userId?: string },
   { modules, userId }: Context,
 ) {
@@ -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/removeWeb3Address.ts

@@ -1,9 +1,9 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
 import { UserWeb3AddressNotFoundError } from '../../../errors.js';
+import { Context } from '../../../types.js';
 
 export default async function removeWeb3Address(
-  root: Root,
+  root: never,
   { address }: { address: string },
   { modules, userId, user }: Context,
 ) {

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

@@ -1,9 +1,9 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
 import { UserWebAuthnCredentialsNotFoundError } from '../../../errors.js';
+import { Context } from '../../../types.js';
 
 export default async function removeWebAuthnCredentials(
-  root: Root,
+  root: never,
   { credentialsId }: { credentialsId: string },
   { modules, userId, user }: Context,
 ) {

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';
+import { Context } from '../../../types.js';
 
 export default async function resetPassword(
-  root: Root,
-  params: { newPlainPassword?: string; token: string },
+  root: never,
+  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 {
-        /* */
-      }
-    }
+  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.baseName,
+    countryCode: context.countryContext,
+  });
+
+  return context.login(user);
 }

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

@@ -1,15 +1,19 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
+import { UserNotFoundError } from '../../../errors.js';
+import { Context } from '../../../types.js';
 
 export default async function sendEnrollmentEmail(
-  root: Root,
+  root: never,
   { email }: { email: string },
   { modules, userId }: Context,
 ) {
   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,16 +1,25 @@
-import { Context, Root } from '@unchainedshop/types/api.js';
 import { log } from '@unchainedshop/logger';
+import { UserNotFoundError } from '../../../errors.js';
+import { Context } from '../../../types.js';
 
 export default async function sendVerificationEmail(
-  root: Root,
+  root: never,
   { email }: { email: string },
   { modules, userId }: Context,
 ) {
   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 {
+    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';
+import { Context } from '../../../types.js';
 
 export default async function setPassword(
-  root: Root,
-  params: { newPlainPassword: string; userId: string },
+  root: never,
+  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,9 +1,9 @@
 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';
+import { Context } from '../../../types.js';
 
 export default async function setUsername(
-  root: Root,
+  root: never,
   params: { username: string; userId: string },
   { modules, userId }: Context,
 ) {
@@ -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);
 }