chore: convert the last few stores to typescript

1 files changed, 421 insertions, 0 deletions

diff --git a/src/stores/UserStore.ts b/src/stores/UserStore.ts
new file mode 100644
index 000000000..616ff29a6
--- /dev/null
+++ b/src/stores/UserStore.ts
@@ -0,0 +1,421 @@
+import { observable, computed, action } from 'mobx';
+import moment from 'moment';
+import jwt from 'jsonwebtoken';
+import localStorage from 'mobx-localstorage';
+import { ipcRenderer } from 'electron';
+
+import { ApiInterface } from 'src/api';
+import { Actions } from 'src/actions/lib/actions';
+import { Stores } from 'src/stores.types';
+import { TODOS_PARTITION_ID } from '../config';
+import { isDevMode } from '../environment-remote';
+import Request from './lib/Request';
+import CachedRequest from './lib/CachedRequest';
+import TypedStore from './lib/TypedStore';
+
+const debug = require('../preload-safe-debug')('Ferdium:UserStore');
+
+// TODO: split stores into UserStore and AuthStore
+export default class UserStore extends TypedStore {
+  BASE_ROUTE: string = '/auth';
+
+  WELCOME_ROUTE: string = `${this.BASE_ROUTE}/welcome`;
+
+  LOGIN_ROUTE: string = `${this.BASE_ROUTE}/login`;
+
+  LOGOUT_ROUTE: string = `${this.BASE_ROUTE}/logout`;
+
+  SIGNUP_ROUTE: string = `${this.BASE_ROUTE}/signup`;
+
+  SETUP_ROUTE: string = `${this.BASE_ROUTE}/signup/setup`;
+
+  IMPORT_ROUTE: string = `${this.BASE_ROUTE}/signup/import`;
+
+  INVITE_ROUTE: string = `${this.BASE_ROUTE}/signup/invite`;
+
+  PASSWORD_ROUTE: string = `${this.BASE_ROUTE}/password`;
+
+  CHANGE_SERVER_ROUTE: string = `${this.BASE_ROUTE}/server`;
+
+  @observable loginRequest: Request = new Request(this.api.user, 'login');
+
+  @observable signupRequest: Request = new Request(this.api.user, 'signup');
+
+  @observable passwordRequest: Request = new Request(this.api.user, 'password');
+
+  @observable inviteRequest: Request = new Request(this.api.user, 'invite');
+
+  @observable getUserInfoRequest: CachedRequest = new CachedRequest(
+    this.api.user,
+    'getInfo',
+  );
+
+  @observable updateUserInfoRequest: Request = new Request(
+    this.api.user,
+    'updateInfo',
+  );
+
+  @observable getLegacyServicesRequest: CachedRequest = new CachedRequest(
+    this.api.user,
+    'getLegacyServices',
+  );
+
+  @observable deleteAccountRequest: CachedRequest = new CachedRequest(
+    this.api.user,
+    'delete',
+  );
+
+  @observable isImportLegacyServicesExecuting: boolean = false;
+
+  @observable isImportLegacyServicesCompleted: boolean = false;
+
+  @observable isLoggingOut: boolean = false;
+
+  @observable id: string | null | undefined;
+
+  @observable authToken: string | null =
+    localStorage.getItem('authToken') || null;
+
+  @observable accountType: string | undefined;
+
+  @observable hasCompletedSignup: boolean = false;
+
+  @observable userData: object = {};
+
+  logoutReasonTypes = {
+    SERVER: 'SERVER',
+  };
+
+  @observable logoutReason: string | null = null;
+
+  fetchUserInfoInterval = null;
+
+  constructor(stores: Stores, api: ApiInterface, actions: Actions) {
+    super(stores, api, actions);
+
+    // Register action handlers
+    this.actions.user.login.listen(this._login.bind(this));
+    this.actions.user.retrievePassword.listen(
+      this._retrievePassword.bind(this),
+    );
+    this.actions.user.logout.listen(this._logout.bind(this));
+    this.actions.user.signup.listen(this._signup.bind(this));
+    this.actions.user.invite.listen(this._invite.bind(this));
+    this.actions.user.update.listen(this._update.bind(this));
+    this.actions.user.resetStatus.listen(this._resetStatus.bind(this));
+    this.actions.user.importLegacyServices.listen(
+      this._importLegacyServices.bind(this),
+    );
+    this.actions.user.delete.listen(this._delete.bind(this));
+
+    // Reactions
+    this.registerReactions([
+      this._requireAuthenticatedUser.bind(this),
+      this._getUserData.bind(this),
+    ]);
+  }
+
+  setup(): void {
+    // Data migration
+    this._migrateUserLocale();
+  }
+
+  // Routes
+  get loginRoute(): string {
+    return this.LOGIN_ROUTE;
+  }
+
+  get logoutRoute(): string {
+    return this.LOGOUT_ROUTE;
+  }
+
+  get signupRoute(): string {
+    return this.SIGNUP_ROUTE;
+  }
+
+  get setupRoute(): string {
+    return this.SETUP_ROUTE;
+  }
+
+  get inviteRoute(): string {
+    return this.INVITE_ROUTE;
+  }
+
+  get importRoute(): string {
+    return this.IMPORT_ROUTE;
+  }
+
+  get passwordRoute(): string {
+    return this.PASSWORD_ROUTE;
+  }
+
+  get changeServerRoute(): string {
+    return this.CHANGE_SERVER_ROUTE;
+  }
+
+  // Data
+  @computed get isLoggedIn(): boolean {
+    return Boolean(localStorage.getItem('authToken'));
+  }
+
+  @computed get isTokenExpired(): boolean {
+    if (!this.authToken) return false;
+    const parsedToken = this._parseToken(this.authToken);
+
+    return (
+      parsedToken !== false &&
+      this.authToken !== null &&
+      moment(parsedToken.tokenExpiry).isBefore(moment())
+    );
+  }
+
+  @computed get data() {
+    if (!this.isLoggedIn) return {};
+
+    return this.getUserInfoRequest.execute().result || {};
+  }
+
+  @computed get team(): any {
+    return this.data.team || null;
+  }
+
+  @computed get legacyServices(): any {
+    return this.getLegacyServicesRequest.execute() || {};
+  }
+
+  // Actions
+  @action async _login({ email, password }): Promise<void> {
+    const authToken = await this.loginRequest.execute(email, password)._promise;
+    this._setUserData(authToken);
+
+    this.stores.router.push('/');
+  }
+
+  @action _tokenLogin(authToken: string): void {
+    this._setUserData(authToken);
+
+    this.stores.router.push('/');
+  }
+
+  @action async _signup({
+    firstname,
+    lastname,
+    email,
+    password,
+    accountType,
+    company,
+    plan,
+    currency,
+  }): Promise<void> {
+    const authToken = await this.signupRequest.execute({
+      firstname,
+      lastname,
+      email,
+      password,
+      accountType,
+      company,
+      locale: this.stores.app.locale,
+      plan,
+      currency,
+    });
+
+    this.hasCompletedSignup = true;
+
+    this._setUserData(authToken);
+
+    this.stores.router.push(this.SETUP_ROUTE);
+  }
+
+  @action async _retrievePassword({ email }): Promise<void> {
+    const request = this.passwordRequest.execute(email);
+
+    await request._promise;
+    this.actionStatus = request.result.status || [];
+  }
+
+  @action async _invite({ invites }): Promise<void> {
+    const data = invites.filter(invite => invite.email !== '');
+
+    const response = await this.inviteRequest.execute(data)._promise;
+
+    this.actionStatus = response.status || [];
+
+    // we do not wait for a server response before redirecting the user ONLY DURING SIGNUP
+    if (this.stores.router.location.pathname.includes(this.INVITE_ROUTE)) {
+      this.stores.router.push('/');
+    }
+  }
+
+  @action async _update({ userData }): Promise<void> {
+    if (!this.isLoggedIn) return;
+
+    const response = await this.updateUserInfoRequest.execute(userData)
+      ._promise;
+
+    this.getUserInfoRequest.patch(() => response.data);
+    this.actionStatus = response.status || [];
+  }
+
+  @action _resetStatus(): void {
+    this.actionStatus = [];
+  }
+
+  @action _logout(): void {
+    // workaround mobx issue
+    localStorage.removeItem('authToken');
+    window.localStorage.removeItem('authToken');
+
+    this.getUserInfoRequest.invalidate().reset();
+    this.authToken = null;
+
+    this.stores.services.allServicesRequest.invalidate().reset();
+
+    if (this.stores.todos.isTodosEnabled) {
+      ipcRenderer.send('clear-storage-data', { sessionId: TODOS_PARTITION_ID });
+    }
+  }
+
+  @action async _importLegacyServices({ services }): Promise<void> {
+    this.isImportLegacyServicesExecuting = true;
+
+    // Reduces recipe duplicates
+    const recipes = services
+      .filter(
+        (obj, pos, arr) =>
+          arr.map(mapObj => mapObj.recipe.id).indexOf(obj.recipe.id) === pos,
+      )
+      .map(s => s.recipe.id);
+
+    // Install recipes
+    for (const recipe of recipes) {
+      // eslint-disable-next-line no-await-in-loop
+      await this.stores.recipes._install({ recipeId: recipe });
+    }
+
+    for (const service of services) {
+      this.actions.service.createFromLegacyService({
+        data: service,
+      });
+      // eslint-disable-next-line no-await-in-loop
+      await this.stores.services.createServiceRequest._promise;
+    }
+
+    this.isImportLegacyServicesExecuting = false;
+    this.isImportLegacyServicesCompleted = true;
+  }
+
+  @action async _delete(): Promise<void> {
+    this.deleteAccountRequest.execute();
+  }
+
+  // This is a mobx autorun which forces the user to login if not authenticated
+  _requireAuthenticatedUser = (): void => {
+    if (this.isTokenExpired) {
+      this._logout();
+    }
+
+    const { router } = this.stores;
+    const currentRoute = window.location.hash;
+    if (!this.isLoggedIn && currentRoute.includes('token=')) {
+      router.push(this.WELCOME_ROUTE);
+      const token = currentRoute.split('=')[1];
+
+      const data = this._parseToken(token);
+      if (data) {
+        // Give this some time to sink
+        setTimeout(() => {
+          this._tokenLogin(token);
+        }, 1000);
+      }
+    } else if (!this.isLoggedIn && !currentRoute.includes(this.BASE_ROUTE)) {
+      router.push(this.WELCOME_ROUTE);
+    } else if (this.isLoggedIn && currentRoute === this.LOGOUT_ROUTE) {
+      this.actions.user.logout();
+      router.push(this.LOGIN_ROUTE);
+    } else if (
+      this.isLoggedIn &&
+      currentRoute.includes(this.BASE_ROUTE) &&
+      (this.hasCompletedSignup || this.hasCompletedSignup === null) &&
+      !isDevMode
+    ) {
+      this.stores.router.push('/');
+    }
+  };
+
+  // Reactions
+  async _getUserData(): Promise<void> {
+    if (this.isLoggedIn) {
+      let data;
+      try {
+        data = await this.getUserInfoRequest.execute()._promise;
+      } catch {
+        return;
+      }
+
+      // We need to set the beta flag for the SettingsStore
+      this.actions.settings.update({
+        type: 'app',
+        data: {
+          beta: data.beta,
+          locale: data.locale,
+        },
+      });
+    }
+  }
+
+  // Helpers
+  _parseToken(authToken) {
+    try {
+      const decoded = jwt.decode(authToken);
+
+      return {
+        id: decoded.userId,
+        tokenExpiry: moment.unix(decoded.exp).toISOString(),
+        authToken,
+      };
+    } catch {
+      this._logout();
+      return false;
+    }
+  }
+
+  _setUserData(authToken: any): void {
+    const data = this._parseToken(authToken);
+    if (data !== false && data.authToken) {
+      localStorage.setItem('authToken', data.authToken);
+
+      this.authToken = data.authToken;
+      this.id = data.id;
+    } else {
+      this.authToken = null;
+      this.id = null;
+    }
+  }
+
+  getAuthURL(url: string): string {
+    const parsedUrl = new URL(url);
+    const params = new URLSearchParams(parsedUrl.search.slice(1));
+
+    // TODO: Remove the neccesity for `as string`
+    params.append('authToken', this.authToken as string);
+
+    return `${parsedUrl.origin}${parsedUrl.pathname}?${params.toString()}`;
+  }
+
+  async _migrateUserLocale(): Promise<void> {
+    try {
+      await this.getUserInfoRequest._promise;
+    } catch {
+      return;
+    }
+
+    if (!this.data.locale) {
+      debug('Migrate "locale" to user data');
+      this.actions.user.update({
+        userData: {
+          locale: this.stores.app.locale,
+        },
+      });
+    }
+  }
+}