feat: init

apps/admin/core/store/instance.store.ts

@@ -0,0 +1,218 @@
+import { set } from "lodash-es";
+import { observable, action, computed, makeObservable, runInAction } from "mobx";
+// plane internal packages
+import type { TInstanceStatus } from "@plane/constants";
+import { EInstanceStatus } from "@plane/constants";
+import { InstanceService } from "@plane/services";
+import type {
+  IInstance,
+  IInstanceAdmin,
+  IInstanceConfiguration,
+  IFormattedInstanceConfiguration,
+  IInstanceInfo,
+  IInstanceConfig,
+} from "@plane/types";
+// root store
+import type { CoreRootStore } from "@/store/root.store";
+
+export interface IInstanceStore {
+  // issues
+  isLoading: boolean;
+  error: any;
+  instanceStatus: TInstanceStatus | undefined;
+  instance: IInstance | undefined;
+  config: IInstanceConfig | undefined;
+  instanceAdmins: IInstanceAdmin[] | undefined;
+  instanceConfigurations: IInstanceConfiguration[] | undefined;
+  // computed
+  formattedConfig: IFormattedInstanceConfiguration | undefined;
+  // action
+  hydrate: (data: IInstanceInfo) => void;
+  fetchInstanceInfo: () => Promise<IInstanceInfo | undefined>;
+  updateInstanceInfo: (data: Partial<IInstance>) => Promise<IInstance | undefined>;
+  fetchInstanceAdmins: () => Promise<IInstanceAdmin[] | undefined>;
+  fetchInstanceConfigurations: () => Promise<IInstanceConfiguration[] | undefined>;
+  updateInstanceConfigurations: (data: Partial<IFormattedInstanceConfiguration>) => Promise<IInstanceConfiguration[]>;
+  disableEmail: () => Promise<void>;
+}
+
+export class InstanceStore implements IInstanceStore {
+  isLoading: boolean = true;
+  error: any = undefined;
+  instanceStatus: TInstanceStatus | undefined = undefined;
+  instance: IInstance | undefined = undefined;
+  config: IInstanceConfig | undefined = undefined;
+  instanceAdmins: IInstanceAdmin[] | undefined = undefined;
+  instanceConfigurations: IInstanceConfiguration[] | undefined = undefined;
+  // service
+  instanceService;
+
+  constructor(private store: CoreRootStore) {
+    makeObservable(this, {
+      // observable
+      isLoading: observable.ref,
+      error: observable.ref,
+      instanceStatus: observable,
+      instance: observable,
+      instanceAdmins: observable,
+      instanceConfigurations: observable,
+      // computed
+      formattedConfig: computed,
+      // actions
+      hydrate: action,
+      fetchInstanceInfo: action,
+      fetchInstanceAdmins: action,
+      updateInstanceInfo: action,
+      fetchInstanceConfigurations: action,
+      updateInstanceConfigurations: action,
+    });
+
+    this.instanceService = new InstanceService();
+  }
+
+  hydrate = (data: IInstanceInfo) => {
+    if (data) {
+      this.instance = data.instance;
+      this.config = data.config;
+    }
+  };
+
+  /**
+   * computed value for instance configurations data for forms.
+   * @returns configurations in the form of {key, value} pair.
+   */
+  get formattedConfig() {
+    if (!this.instanceConfigurations) return undefined;
+    return this.instanceConfigurations?.reduce((formData: IFormattedInstanceConfiguration, config) => {
+      formData[config.key] = config.value;
+      return formData;
+    }, {} as IFormattedInstanceConfiguration);
+  }
+
+  /**
+   * @description fetching instance configuration
+   * @returns {IInstance} instance
+   */
+  fetchInstanceInfo = async () => {
+    try {
+      if (this.instance === undefined) this.isLoading = true;
+      this.error = undefined;
+      const instanceInfo = await this.instanceService.info();
+      // handling the new user popup toggle
+      if (this.instance === undefined && !instanceInfo?.instance?.workspaces_exist)
+        this.store.theme.toggleNewUserPopup();
+      runInAction(() => {
+        // console.log("instanceInfo: ", instanceInfo);
+        this.isLoading = false;
+        this.instance = instanceInfo.instance;
+        this.config = instanceInfo.config;
+      });
+      return instanceInfo;
+    } catch (error) {
+      console.error("Error fetching the instance info");
+      this.isLoading = false;
+      this.error = { message: "Failed to fetch the instance info" };
+      this.instanceStatus = {
+        status: EInstanceStatus.ERROR,
+      };
+      throw error;
+    }
+  };
+
+  /**
+   * @description updating instance information
+   * @param {Partial<IInstance>} data
+   * @returns void
+   */
+  updateInstanceInfo = async (data: Partial<IInstance>) => {
+    try {
+      const instanceResponse = await this.instanceService.update(data);
+      if (instanceResponse) {
+        runInAction(() => {
+          if (this.instance) set(this.instance, "instance", instanceResponse);
+        });
+      }
+      return instanceResponse;
+    } catch (error) {
+      console.error("Error updating the instance info");
+      throw error;
+    }
+  };
+
+  /**
+   * @description fetching instance admins
+   * @return {IInstanceAdmin[]} instanceAdmins
+   */
+  fetchInstanceAdmins = async () => {
+    try {
+      const instanceAdmins = await this.instanceService.admins();
+      if (instanceAdmins) runInAction(() => (this.instanceAdmins = instanceAdmins));
+      return instanceAdmins;
+    } catch (error) {
+      console.error("Error fetching the instance admins");
+      throw error;
+    }
+  };
+
+  /**
+   * @description fetching instance configurations
+   * @return {IInstanceAdmin[]} instanceConfigurations
+   */
+  fetchInstanceConfigurations = async () => {
+    try {
+      const instanceConfigurations = await this.instanceService.configurations();
+      if (instanceConfigurations) runInAction(() => (this.instanceConfigurations = instanceConfigurations));
+      return instanceConfigurations;
+    } catch (error) {
+      console.error("Error fetching the instance configurations");
+      throw error;
+    }
+  };
+
+  /**
+   * @description updating instance configurations
+   * @param data
+   */
+  updateInstanceConfigurations = async (data: Partial<IFormattedInstanceConfiguration>) => {
+    try {
+      const response = await this.instanceService.updateConfigurations(data);
+      runInAction(() => {
+        this.instanceConfigurations = this.instanceConfigurations?.map((config) => {
+          const item = response.find((item) => item.key === config.key);
+          if (item) return item;
+          return config;
+        });
+      });
+      return response;
+    } catch (error) {
+      console.error("Error updating the instance configurations");
+      throw error;
+    }
+  };
+
+  disableEmail = async () => {
+    const instanceConfigurations = this.instanceConfigurations;
+    try {
+      runInAction(() => {
+        this.instanceConfigurations = this.instanceConfigurations?.map((config) => {
+          if (
+            [
+              "EMAIL_HOST",
+              "EMAIL_PORT",
+              "EMAIL_HOST_USER",
+              "EMAIL_HOST_PASSWORD",
+              "EMAIL_FROM",
+              "ENABLE_SMTP",
+            ].includes(config.key)
+          )
+            return { ...config, value: "" };
+          return config;
+        });
+      });
+      await this.instanceService.disableEmail();
+    } catch (_error) {
+      console.error("Error disabling the email");
+      this.instanceConfigurations = instanceConfigurations;
+    }
+  };
+}

apps/admin/core/store/root.store.ts

@@ -0,0 +1,41 @@
+import { enableStaticRendering } from "mobx-react";
+// stores
+import type { IInstanceStore } from "./instance.store";
+import { InstanceStore } from "./instance.store";
+import type { IThemeStore } from "./theme.store";
+import { ThemeStore } from "./theme.store";
+import type { IUserStore } from "./user.store";
+import { UserStore } from "./user.store";
+import type { IWorkspaceStore } from "./workspace.store";
+import { WorkspaceStore } from "./workspace.store";
+
+enableStaticRendering(typeof window === "undefined");
+
+export abstract class CoreRootStore {
+  theme: IThemeStore;
+  instance: IInstanceStore;
+  user: IUserStore;
+  workspace: IWorkspaceStore;
+
+  constructor() {
+    this.theme = new ThemeStore(this);
+    this.instance = new InstanceStore(this);
+    this.user = new UserStore(this);
+    this.workspace = new WorkspaceStore(this);
+  }
+
+  hydrate(initialData: any) {
+    this.theme.hydrate(initialData.theme);
+    this.instance.hydrate(initialData.instance);
+    this.user.hydrate(initialData.user);
+    this.workspace.hydrate(initialData.workspace);
+  }
+
+  resetOnSignOut() {
+    localStorage.setItem("theme", "system");
+    this.instance = new InstanceStore(this);
+    this.user = new UserStore(this);
+    this.theme = new ThemeStore(this);
+    this.workspace = new WorkspaceStore(this);
+  }
+}

apps/admin/core/store/theme.store.ts

@@ -0,0 +1,68 @@
+import { action, observable, makeObservable } from "mobx";
+// root store
+import type { CoreRootStore } from "@/store/root.store";
+
+type TTheme = "dark" | "light";
+export interface IThemeStore {
+  // observables
+  isNewUserPopup: boolean;
+  theme: string | undefined;
+  isSidebarCollapsed: boolean | undefined;
+  // actions
+  hydrate: (data: any) => void;
+  toggleNewUserPopup: () => void;
+  toggleSidebar: (collapsed: boolean) => void;
+  setTheme: (currentTheme: TTheme) => void;
+}
+
+export class ThemeStore implements IThemeStore {
+  // observables
+  isNewUserPopup: boolean = false;
+  isSidebarCollapsed: boolean | undefined = undefined;
+  theme: string | undefined = undefined;
+
+  constructor(private store: CoreRootStore) {
+    makeObservable(this, {
+      // observables
+      isNewUserPopup: observable.ref,
+      isSidebarCollapsed: observable.ref,
+      theme: observable.ref,
+      // action
+      toggleNewUserPopup: action,
+      toggleSidebar: action,
+      setTheme: action,
+    });
+  }
+
+  hydrate = (data: any) => {
+    if (data) this.theme = data;
+  };
+
+  /**
+   * @description Toggle the new user popup modal
+   */
+  toggleNewUserPopup = () => (this.isNewUserPopup = !this.isNewUserPopup);
+
+  /**
+   * @description Toggle the sidebar collapsed state
+   * @param isCollapsed
+   */
+  toggleSidebar = (isCollapsed: boolean) => {
+    if (isCollapsed === undefined) this.isSidebarCollapsed = !this.isSidebarCollapsed;
+    else this.isSidebarCollapsed = isCollapsed;
+    localStorage.setItem("god_mode_sidebar_collapsed", isCollapsed.toString());
+  };
+
+  /**
+   * @description Sets the user theme and applies it to the platform
+   * @param currentTheme
+   */
+  setTheme = async (currentTheme: TTheme) => {
+    try {
+      localStorage.setItem("theme", currentTheme);
+      this.theme = currentTheme;
+    } catch (error) {
+      console.error("setting user theme error", error);
+    }
+  };
+}

apps/admin/core/store/user.store.ts

@@ -0,0 +1,103 @@
+import { action, observable, runInAction, makeObservable } from "mobx";
+// plane internal packages
+import type { TUserStatus } from "@plane/constants";
+import { EUserStatus } from "@plane/constants";
+import { AuthService, UserService } from "@plane/services";
+import type { IUser } from "@plane/types";
+// root store
+import type { CoreRootStore } from "@/store/root.store";
+
+export interface IUserStore {
+  // observables
+  isLoading: boolean;
+  userStatus: TUserStatus | undefined;
+  isUserLoggedIn: boolean | undefined;
+  currentUser: IUser | undefined;
+  // fetch actions
+  hydrate: (data: any) => void;
+  fetchCurrentUser: () => Promise<IUser>;
+  reset: () => void;
+  signOut: () => void;
+}
+
+export class UserStore implements IUserStore {
+  // observables
+  isLoading: boolean = true;
+  userStatus: TUserStatus | undefined = undefined;
+  isUserLoggedIn: boolean | undefined = undefined;
+  currentUser: IUser | undefined = undefined;
+  // services
+  userService;
+  authService;
+
+  constructor(private store: CoreRootStore) {
+    makeObservable(this, {
+      // observables
+      isLoading: observable.ref,
+      userStatus: observable,
+      isUserLoggedIn: observable.ref,
+      currentUser: observable,
+      // action
+      fetchCurrentUser: action,
+      reset: action,
+      signOut: action,
+    });
+    this.userService = new UserService();
+    this.authService = new AuthService();
+  }
+
+  hydrate = (data: any) => {
+    if (data) this.currentUser = data;
+  };
+
+  /**
+   * @description Fetches the current user
+   * @returns Promise<IUser>
+   */
+  fetchCurrentUser = async () => {
+    try {
+      if (this.currentUser === undefined) this.isLoading = true;
+      const currentUser = await this.userService.adminDetails();
+      if (currentUser) {
+        await this.store.instance.fetchInstanceAdmins();
+        runInAction(() => {
+          this.isUserLoggedIn = true;
+          this.currentUser = currentUser;
+          this.isLoading = false;
+        });
+      } else {
+        runInAction(() => {
+          this.isUserLoggedIn = false;
+          this.currentUser = undefined;
+          this.isLoading = false;
+        });
+      }
+      return currentUser;
+    } catch (error: any) {
+      this.isLoading = false;
+      this.isUserLoggedIn = false;
+      if (error.status === 403)
+        this.userStatus = {
+          status: EUserStatus.AUTHENTICATION_NOT_DONE,
+          message: error?.message || "",
+        };
+      else
+        this.userStatus = {
+          status: EUserStatus.ERROR,
+          message: error?.message || "",
+        };
+      throw error;
+    }
+  };
+
+  reset = async () => {
+    this.isUserLoggedIn = false;
+    this.currentUser = undefined;
+    this.isLoading = false;
+    this.userStatus = undefined;
+  };
+
+  signOut = async () => {
+    this.store.resetOnSignOut();
+  };
+}

apps/admin/core/store/workspace.store.ts

@@ -0,0 +1,150 @@
+import { set } from "lodash-es";
+import { action, observable, runInAction, makeObservable, computed } from "mobx";
+// plane imports
+import { InstanceWorkspaceService } from "@plane/services";
+import type { IWorkspace, TLoader, TPaginationInfo } from "@plane/types";
+// root store
+import type { CoreRootStore } from "@/store/root.store";
+
+export interface IWorkspaceStore {
+  // observables
+  loader: TLoader;
+  workspaces: Record<string, IWorkspace>;
+  paginationInfo: TPaginationInfo | undefined;
+  // computed
+  workspaceIds: string[];
+  // helper actions
+  hydrate: (data: Record<string, IWorkspace>) => void;
+  getWorkspaceById: (workspaceId: string) => IWorkspace | undefined;
+  // fetch actions
+  fetchWorkspaces: () => Promise<IWorkspace[]>;
+  fetchNextWorkspaces: () => Promise<IWorkspace[]>;
+  // curd actions
+  createWorkspace: (data: IWorkspace) => Promise<IWorkspace>;
+}
+
+export class WorkspaceStore implements IWorkspaceStore {
+  // observables
+  loader: TLoader = "init-loader";
+  workspaces: Record<string, IWorkspace> = {};
+  paginationInfo: TPaginationInfo | undefined = undefined;
+  // services
+  instanceWorkspaceService;
+
+  constructor(private store: CoreRootStore) {
+    makeObservable(this, {
+      // observables
+      loader: observable,
+      workspaces: observable,
+      paginationInfo: observable,
+      // computed
+      workspaceIds: computed,
+      // helper actions
+      hydrate: action,
+      getWorkspaceById: action,
+      // fetch actions
+      fetchWorkspaces: action,
+      fetchNextWorkspaces: action,
+      // curd actions
+      createWorkspace: action,
+    });
+    this.instanceWorkspaceService = new InstanceWorkspaceService();
+  }
+
+  // computed
+  get workspaceIds() {
+    return Object.keys(this.workspaces);
+  }
+
+  // helper actions
+  /**
+   * @description Hydrates the workspaces
+   * @param data - Record<string, IWorkspace>
+   */
+  hydrate = (data: Record<string, IWorkspace>) => {
+    if (data) this.workspaces = data;
+  };
+
+  /**
+   * @description Gets a workspace by id
+   * @param workspaceId - string
+   * @returns IWorkspace | undefined
+   */
+  getWorkspaceById = (workspaceId: string) => this.workspaces[workspaceId];
+
+  // fetch actions
+  /**
+   * @description Fetches all workspaces
+   * @returns Promise<>
+   */
+  fetchWorkspaces = async (): Promise<IWorkspace[]> => {
+    try {
+      if (this.workspaceIds.length > 0) {
+        this.loader = "mutation";
+      } else {
+        this.loader = "init-loader";
+      }
+      const paginatedWorkspaceData = await this.instanceWorkspaceService.list();
+      runInAction(() => {
+        const { results, ...paginationInfo } = paginatedWorkspaceData;
+        results.forEach((workspace: IWorkspace) => {
+          set(this.workspaces, [workspace.id], workspace);
+        });
+        set(this, "paginationInfo", paginationInfo);
+      });
+      return paginatedWorkspaceData.results;
+    } catch (error) {
+      console.error("Error fetching workspaces", error);
+      throw error;
+    } finally {
+      this.loader = "loaded";
+    }
+  };
+
+  /**
+   * @description Fetches the next page of workspaces
+   * @returns Promise<IWorkspace[]>
+   */
+  fetchNextWorkspaces = async (): Promise<IWorkspace[]> => {
+    if (!this.paginationInfo || this.paginationInfo.next_page_results === false) return [];
+    try {
+      this.loader = "pagination";
+      const paginatedWorkspaceData = await this.instanceWorkspaceService.list(this.paginationInfo.next_cursor);
+      runInAction(() => {
+        const { results, ...paginationInfo } = paginatedWorkspaceData;
+        results.forEach((workspace: IWorkspace) => {
+          set(this.workspaces, [workspace.id], workspace);
+        });
+        set(this, "paginationInfo", paginationInfo);
+      });
+      return paginatedWorkspaceData.results;
+    } catch (error) {
+      console.error("Error fetching next workspaces", error);
+      throw error;
+    } finally {
+      this.loader = "loaded";
+    }
+  };
+
+  // curd actions
+  /**
+   * @description Creates a new workspace
+   * @param data - IWorkspace
+   * @returns Promise<IWorkspace>
+   */
+  createWorkspace = async (data: IWorkspace): Promise<IWorkspace> => {
+    try {
+      this.loader = "mutation";
+      const workspace = await this.instanceWorkspaceService.create(data);
+      runInAction(() => {
+        set(this.workspaces, [workspace.id], workspace);
+      });
+      return workspace;
+    } catch (error) {
+      console.error("Error creating workspace", error);
+      throw error;
+    } finally {
+      this.loader = "loaded";
+    }
+  };
+}