@unchainedshop/api 2.12.2 → 3.0.0-alpha2

package/src/express/passport/access-token-strategy.ts

@@ -0,0 +1,39 @@
+import Strategy from 'passport-strategy';
+
+export default class AccessTokenStrategy extends Strategy {
+  name: string;
+
+  pass: any;
+
+  _verify: any;
+
+  success: any;
+
+  constructor(verify) {
+    super();
+
+    if (!verify) {
+      throw new TypeError('AccessTokenStrategy requires a verify callback');
+    }
+    // eslint-disable-next-line
+    this._verify = verify;
+
+    // Set the default name of our strategy
+    this.name = 'access-token';
+  }
+
+  authenticate(req) {
+    if (req.headers.authorization) {
+      const [type, token] = req.headers.authorization.split(' ');
+      if (type === 'Bearer') {
+        // eslint-disable-next-line
+        this._verify(token, (err, user) => {
+          if (!user || err) return this.pass();
+          this.success(user);
+        });
+        return;
+      }
+    }
+    this.pass();
+  }
+}

package/src/express/passport/setup.ts

@@ -0,0 +1,44 @@
+import { UnchainedCore } from '@unchainedshop/types/core.js';
+import { Passport } from 'passport';
+import AccessTokenStrategy from './access-token-strategy.js';
+
+const setupPassport = (unchainedAPI: UnchainedCore) => {
+  const passport = new Passport();
+
+  passport.serializeUser(function serialize(user, done) {
+    done(null, user._id);
+  });
+
+  passport.deserializeUser(function deserialize(_id, done) {
+    unchainedAPI.modules.users.findUserById(_id).then(
+      (user) => {
+        done(null, user);
+      },
+      (error) => {
+        done(error, null);
+      },
+    );
+  });
+
+  passport.use(
+    new AccessTokenStrategy(function verify(userToken, done) {
+      const [username] = userToken.split(':');
+      unchainedAPI.modules.users.findUserByToken(userToken).then(
+        (user) => {
+          if (user?.username === username) {
+            done(null, user);
+            return;
+          }
+          done(null, null);
+        },
+        (error) => {
+          done(error, null);
+        },
+      );
+    }),
+  );
+
+  return passport;
+};
+
+export default setupPassport;

package/src/loaders/index.ts

@@ -1,4 +1,3 @@
-import { IncomingMessage, OutgoingMessage } from 'http';
 import DataLoader from 'dataloader';
 import { systemLocale } from '@unchainedshop/utils';
 import localePkg from 'locale';
@@ -15,7 +14,7 @@ function getLocaleStrings(localeObj) {
 function findMatchingText(texts, localeStrings) {
   return localeStrings.reduce((acc, localeString) => {
     if (acc) return acc;
-    return texts.find((p) => p.locale === localeString);
+    return texts.find((p) => p.locale.toLowerCase() === localeString.toLowerCase());
   }, null);
 }
 
@@ -32,11 +31,7 @@ function getFilteredQueries({ queries, texts, filterFn }) {
   });
 }
 
-const loaders = async (
-  req: IncomingMessage,
-  res: OutgoingMessage,
-  unchainedAPI: UnchainedCore,
-): Promise<UnchainedLoaders['loaders']> => {
+const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['loaders']> => {
   return {
     assortmentLoader: new DataLoader(
       async (queries) => {
@@ -216,7 +211,6 @@ const loaders = async (
           ({ filterId, filterOptionValue }) =>
           (text) =>
             text.filterId === filterId && text.filterOptionValue === filterOptionValue;
-
         return getFilteredQueries({ queries, texts, filterFn });
       },
       { batchScheduleFn: (cb) => setImmediate(cb) },

package/src/locale-context.ts

@@ -1,78 +1,86 @@
-import { IncomingMessage, OutgoingMessage } from 'http';
-import { UnchainedLocaleContext } from '@unchainedshop/types/api.js';
+import { UnchainedLocaleContext, UnchainedHTTPServerContext } from '@unchainedshop/types/api.js';
 import localePkg from 'locale';
-import 'abort-controller/polyfill.js';
 import { log, LogLevel } from '@unchainedshop/logger';
 import {
   resolveBestCountry,
   resolveBestSupported,
-  resolveUserRemoteAddress,
+  resolveBestCurrency,
   systemLocale,
 } from '@unchainedshop/utils';
 import { UnchainedCore } from '@unchainedshop/types/core.js';
-import * as lruCache from 'lru-cache';
+import memoizee from 'memoizee';
 
 const { Locales } = localePkg;
 
 const { NODE_ENV } = process.env;
 
-const ttl = NODE_ENV === 'production' ? 1000 * 60 : 0; // minute or second
+export type GetHeaderFn = (key: string) => string | string[];
 
-const localeContextCache = new lruCache.LRUCache({
-  max: 500,
-  ttl,
-});
+export const resolveDefaultContext = memoizee(
+  async ({ acceptLang, acceptCountry }, unchainedAPI) => {
+    const languages = await unchainedAPI.modules.languages.findLanguages(
+      { includeInactive: false },
+      { projection: { isoCode: 1, isActive: 1 } },
+    );
 
-export const getLocaleContext = async (
-  req: IncomingMessage,
-  res: OutgoingMessage,
-  unchainedAPI: UnchainedCore,
-): Promise<UnchainedLocaleContext> => {
-  const cacheKey = `${req.headers['accept-language']}:${req.headers['x-shop-country']}`;
-  const cachedContext = localeContextCache.get(cacheKey) as UnchainedLocaleContext;
+    const countries = await unchainedAPI.modules.countries.findCountries(
+      { includeInactive: false },
+      { projection: { isoCode: 1, isActive: 1 } },
+    );
 
-  const userAgent = req.headers['user-agent'];
-  const { remoteAddress, remotePort } = resolveUserRemoteAddress(req);
+    const currencies = await unchainedAPI.modules.currencies.findCurrencies({ includeInactive: false });
 
-  if (cachedContext) return { remoteAddress, remotePort, userAgent, ...cachedContext };
+    const supportedLocaleStrings = languages.reduce((accumulator, language) => {
+      const added = countries.map((country) => {
+        return `${language.isoCode}-${country.isoCode}`;
+      });
+      return accumulator.concat(added);
+    }, []);
 
-  // return the parsed locale by bcp47 and
-  // return the best resolved normalized locale by locale according to system-wide configuration
-  // else fallback to base language & base country
+    const supportedLocales = new Locales(supportedLocaleStrings, systemLocale.code);
 
-  const languages = await unchainedAPI.modules.languages.findLanguages(
-    { includeInactive: false },
-    { projection: { isoCode: 1, isActive: 1 } },
-  );
+    const localeContext = resolveBestSupported(acceptLang, supportedLocales);
+    const countryContext = resolveBestCountry(localeContext.country, acceptCountry, countries);
 
-  const countries = await unchainedAPI.modules.countries.findCountries(
-    { includeInactive: false },
-    { projection: { isoCode: 1, isActive: 1 } },
-  );
+    const countryObject = countries.find((country) => country.isoCode === countryContext);
+    const currencyContext = resolveBestCurrency(countryObject.defaultCurrencyCode, currencies);
 
-  const supportedLocaleStrings = languages.reduce((accumulator, language) => {
-    const added = countries.map((country) => {
-      return `${language.isoCode}-${country.isoCode}`;
+    log(`Locale Context: Resolved ${localeContext.normalized} ${countryContext} ${currencyContext}`, {
+      level: LogLevel.Debug,
     });
-    return accumulator.concat(added);
-  }, []);
 
-  const supportedLocales = new Locales(supportedLocaleStrings, systemLocale.code);
+    const newContext: UnchainedLocaleContext = {
+      localeContext,
+      countryContext,
+      currencyContext,
+    };
 
-  const localeContext = resolveBestSupported(req.headers['accept-language'], supportedLocales);
-  const countryContext = resolveBestCountry(
-    localeContext.country,
-    req.headers['x-shop-country'],
-    countries,
-  );
-  log(`Locale Context: Resolved ${localeContext.normalized} ${countryContext}`, {
-    level: LogLevel.Debug,
-  });
-  const newContext: UnchainedLocaleContext = {
-    localeContext,
-    countryContext,
-  };
-  localeContextCache.set(cacheKey, newContext);
+    return newContext;
+  },
+  {
+    maxAge: NODE_ENV === 'production' ? 1000 * 60 : 100, // minute or 100ms
+    promise: true,
+    normalizer(args) {
+      return `${args[0].acceptLang}-${args[0].acceptCountry}`;
+    },
+  },
+);
 
-  return { remoteAddress, remotePort, userAgent, ...newContext };
+export const getLocaleContext = async (
+  {
+    remoteAddress,
+    remotePort,
+    getHeader,
+  }: {
+    remoteAddress: string;
+    remotePort: number;
+  } & UnchainedHTTPServerContext,
+  unchainedAPI: UnchainedCore,
+): Promise<UnchainedLocaleContext> => {
+  const userAgent = getHeader('user-agent');
+  const context = await resolveDefaultContext(
+    { acceptLang: getHeader('accept-language'), acceptCountry: getHeader('x-shop-country') },
+    unchainedAPI,
+  );
+  return { remoteAddress, remotePort, userAgent, ...context };
 };

package/src/resolvers/index.ts

@@ -1,4 +1,3 @@
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.mjs';
 import { JSONResolver, TimestampResolver, DateTimeResolver, DateResolver } from 'graphql-scalars';
 import Query from './queries/index.js';
 import Mutation from './mutations/index.js';
@@ -8,7 +7,6 @@ import CustomScalars from './scalars/index.js';
 export default {
   ...Types,
   ...CustomScalars,
-  Upload: GraphQLUpload,
   JSON: JSONResolver,
   Query,
   Mutation,

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

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api.js';
-import { UserNotFoundError } from '../../../errors.js';
+import { EmailAlreadyExistsError, UserNotFoundError } from '../../../errors.js';
 
 export default async function addEmail(
   root: Root,
@@ -14,7 +14,12 @@ export default async function addEmail(
   if (!(await modules.users.userExists({ userId: normalizedUserId })))
     throw new UserNotFoundError({ userId: normalizedUserId });
 
-  await modules.accounts.addEmail(normalizedUserId, params.email);
+  try {
+    await modules.users.addEmail(normalizedUserId, params.email);
+  } catch (e) {
+    if (e.cause === 'EMAIL_INVALID') throw new EmailAlreadyExistsError({ email: params?.email });
+    else throw e;
+  }
 
   return modules.users.findUserById(normalizedUserId);
 }

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

@@ -10,7 +10,7 @@ export default async function addWebAuthnCredentials(
     userId,
   });
 
-  const webAuthnService = await modules.accounts.webAuthn.verifyCredentialCreation(
+  const webAuthnService = await modules.users.webAuthn.verifyCredentialCreation(
     user.username,
     credentials,
   );

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

@@ -1,30 +1,40 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api.js';
-import { AuthOperationFailedError, InvalidCredentialsError } from '../../../errors.js';
+import { InvalidCredentialsError, PasswordInvalidError } from '../../../errors.js';
 
 export default async function changePassword(
   root: Root,
   params: {
-    oldPlainPassword?: string;
-    newPlainPassword?: string;
+    oldPassword?: string;
+    newPassword?: string;
   },
   { modules, userId }: Context,
 ) {
   log('mutation changePassword', { userId });
 
-  if (!params.newPlainPassword) {
+  if (!params.newPassword) {
     throw new Error('New password is required');
   }
-  if (!params.oldPlainPassword) {
+  if (!params.oldPassword) {
     throw new Error('Old password is required');
   }
+
+  const user = await modules.users.findUserById(userId);
+
+  const isValidCurrentPassword =
+    user.services?.password &&
+    (await modules.users.verifyPassword(user.services?.password, params.oldPassword));
+  if (!isValidCurrentPassword) throw new InvalidCredentialsError({});
+
   let success = false;
+
   try {
-    success = await modules.accounts.changePassword(userId, params);
+    await modules.users.setPassword(user._id, params.newPassword);
+    success = true;
   } catch (e) {
     success = false;
-    if (e.code === 'InvalidCredentials') throw new InvalidCredentialsError({});
-    else throw new AuthOperationFailedError({});
+    if (e.cause === 'PASSWORD_INVALID') throw new PasswordInvalidError({ userId });
+    else throw e;
   }
 
   return { success };

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

@@ -1,12 +1,13 @@
-import { UserData } from '@unchainedshop/types/accounts.js';
+import { UserData } from '@unchainedshop/types/user.js';
 import { Context, Root } from '@unchainedshop/types/api.js';
 import { log } from '@unchainedshop/logger';
-import { hashPassword } from '../../../hashPassword.js';
 import {
   AuthOperationFailedError,
   EmailAlreadyExistsError,
   UsernameAlreadyExistsError,
   UsernameOrEmailRequiredError,
+  PasswordOrWebAuthnPublicKeyRequiredError,
+  PasswordInvalidError,
 } from '../../../errors.js';
 
 export default async function createUser(root: Root, params: UserData, context: Context) {
@@ -14,48 +15,40 @@ export default async function createUser(root: Root, params: UserData, context:
 
   log('mutation createUser', { email: params.email, username: params.username, userId });
 
-  if (!params.plainPassword && !params.webAuthnPublicKeyCredentials) {
-    throw new Error('Password or Public Key is required');
+  if (!params.username && !params.email) {
+    throw new UsernameOrEmailRequiredError({ username: params?.username });
   }
 
-  const mappedUser = { ...params };
-  if (mappedUser.plainPassword) {
-    mappedUser.password = hashPassword(mappedUser.plainPassword);
-  }
-  delete mappedUser.plainPassword;
-  delete mappedUser.webAuthnPublicKeyCredentials;
-
-  const webAuthnService =
-    params.webAuthnPublicKeyCredentials &&
-    (await modules.accounts.webAuthn.verifyCredentialCreation(
-      params.username,
-      params.webAuthnPublicKeyCredentials,
-    ));
-  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 (!params.password && !params.webAuthnPublicKeyCredentials) {
+    throw new PasswordOrWebAuthnPublicKeyRequiredError({ username: params?.username });
   }
 
-  if (newUserId && webAuthnService) {
-    await modules.users.updateUser(
-      { _id: newUserId },
+  try {
+    const newUserId = await modules.users.createUser(
       {
-        $push: {
-          'services.webAuthn': webAuthnService,
-        },
+        ...params,
+        initialPassword: false,
       },
       {},
     );
-  }
 
-  return modules.accounts.createLoginToken(newUserId, context);
+    let user = await modules.users.findUserById(newUserId);
+
+    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);
+  } catch (e) {
+    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/createWebAuthnCredentialCreationOptions.ts

@@ -4,14 +4,14 @@ import { Context, Root } from '@unchainedshop/types/api.js';
 export default async function createWebAuthnCredentialCreationOptions(
   root: Root,
   { 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

@@ -4,20 +4,20 @@ import { Context, Root } from '@unchainedshop/types/api.js';
 export default async function createWebAuthnCredentialRequestOptions(
   root: Root,
   { 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,10 +1,10 @@
 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 { UserData } from '@unchainedshop/types/user.js';
 import {
   AuthOperationFailedError,
   EmailAlreadyExistsError,
+  PasswordInvalidError,
   UsernameAlreadyExistsError,
   UsernameOrEmailRequiredError,
 } from '../../../errors.js';
@@ -14,27 +14,28 @@ export default async function enrollUser(root: Root, params: UserData, 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,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api.js';
-import { AuthOperationFailedError, UserNotFoundError } from '../../../errors.js';
+import { UserNotFoundError } from '../../../errors.js';
 
 export default async function forgotPassword(
   root: Root,
@@ -9,13 +9,17 @@ export default async function forgotPassword(
 ) {
   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);
+    await modules.users.sendResetPasswordEmail(user._id, email);
+    return {
+      success: true,
+    };
   } catch (e) {
-    if (e.code === 'UserNotFound') throw new UserNotFoundError({ email });
-    else throw new AuthOperationFailedError({ email });
+    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';
 
 export default async function loginAsGuest(root: Root, _: any, context: Context) {
-  const { modules } = 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.normalized,
+    countryCode: context.countryContext,
+  });
 
-  return loginToken;
+  return context.login(user);
 }