@servicetitan/standalone-root 1.1.0 → 1.2.0

package/src/stores/standalone-root.store.ts

@@ -1,87 +1,83 @@
-import { inject, injectable, Store } from '@servicetitan/react-ioc';
 import { makeObservable, observable, runInAction } from 'mobx';
-import { TenantManagementApi, TenantModel } from '@servicetitan/standalone-tm-api';
-import { CurrentUserClientApi, UserDetails } from '@servicetitan/marketing-services-api/identity';
+
+import {
+    CurrentUserClientApi,
+    PartitionInfo,
+    PartitionsClientApi,
+    UserDetails,
+} from '@servicetitan/marketing-services-api/identity';
+import { LoadStatus } from '@servicetitan/standalone-ui';
+import { inject, injectable } from '@servicetitan/react-ioc';
 import {
     AppConfigApi,
     AppSettings,
 } from '@servicetitan/marketing-services-api/dist/common/app-config.mrk.api';
-import { LoadStatus } from '@servicetitan/standalone-ui';
-
-const symbolKey = 'standalone-root-symbol-key';
-const isInitializedSymbol: symbol = Symbol.for(symbolKey);
-
-const storageKey = 'standalone-root-cache';
-const storageKeyForTenant = `${storageKey}-tenant`;
-const storageKeyForConfig = `${storageKey}-config`;
-const storageKeyForUser = `${storageKey}-user`;
-const storageKeyForAppSettings = `${storageKey}-app-settings`;
-const storageKeyForLocale = `${storageKey}-locale`;
+import { TenantManagementApi, TenantModel } from '@servicetitan/standalone-tm-api';
+import { OnboardingApi, OnboardingResponse } from '@servicetitan/marketing-services-api/settings';
 
-const cultureKeyInCoreConfigs = 'Customers___Locations:Culture';
+import { Events } from '../utils/events';
+import { EventEmitter } from '../utils/event-emitter';
+import {
+    storageKeyForUser,
+    storageKeyForLocale,
+    storageKeyForTenant,
+    storageKeyForOnboarding,
+    storageKeyForPartitions,
+    storageKeyForAppSettings,
+    storageKeyForTenantConfigs,
+} from '../utils/storage-keys';
+import { cultureKeyInCoreConfigs, defaultLocale, defaultTimezone } from '../utils/constants';
+import { currentInstanceSymbol, eventEmitterSymbol, isInitializedSymbol } from '../utils/symbols';
 
 @injectable()
-export class StandaloneRootStore extends Store {
+export class StandaloneRootStore {
     @observable loadStatus = LoadStatus.None;
     @observable tenant!: TenantModel;
     @observable tenantConfigs!: { [key: string]: string };
     @observable user!: UserDetails;
     @observable appSettings!: AppSettings;
-    @observable timezone = 'UTC';
-    @observable locale = 'en-US';
+    @observable onboarding!: OnboardingResponse;
+    @observable partitions!: PartitionInfo[];
+    @observable timezone = defaultTimezone;
+    @observable locale = defaultLocale;
+
+    private eventEmitter!: EventEmitter;
 
     constructor(
         @inject(TenantManagementApi) private readonly tenantManagementApi: TenantManagementApi,
         @inject(AppConfigApi) private readonly appConfigApi: AppConfigApi,
         @inject(CurrentUserClientApi) private readonly currentUserClientApi: CurrentUserClientApi,
+        @inject(OnboardingApi) private readonly onboardingApi: OnboardingApi,
+        @inject(PartitionsClientApi) private partitionsApi: PartitionsClientApi,
     ) {
-        super();
+        this.initializeEventEmitter();
         makeObservable(this);
     }
 
-    initialize = async () => {
+    initialize = async (forceRefresh: boolean, refreshOnboarding: boolean) => {
         try {
             runInAction(() => {
                 this.loadStatus = LoadStatus.Loading;
             });
 
-            const fetchData = async () => {
-                const [
-                    tenantFetched,
-                    tenantConfigFetched,
-                    { data: userFetched },
-                    { data: appSettingsFetched },
-                ] = await Promise.all([
-                    this.tenantManagementApi.client.tenant(undefined),
-                    this.tenantManagementApi.client.config(
-                        undefined,
-                        undefined,
-                        undefined,
-                        undefined,
-                    ),
-                    this.currentUserClientApi.getUserName(),
-                    this.appConfigApi.getAppSettings(),
+            const fetchAll = async () => {
+                await Promise.all([
+                    this.fetchTenant(),
+                    this.fetchTenantConfigs(),
+                    this.fetchUser(),
+                    this.fetchAppSettings(),
+                    this.fetchOnboarding(),
+                    this.fetchPartitions(),
                 ]);
 
                 const coreConfigs = await this.tenantManagementApi.client.configs2(
-                    tenantFetched.id,
-                    tenantFetched.id,
+                    this.tenant.id,
+                    this.tenant.id,
                     undefined,
                     [cultureKeyInCoreConfigs],
                 );
-                const localeFetched = coreConfigs[cultureKeyInCoreConfigs];
-
-                localStorage.setItem(storageKeyForTenant, JSON.stringify(tenantFetched));
-                localStorage.setItem(storageKeyForConfig, JSON.stringify(tenantConfigFetched));
-                localStorage.setItem(storageKeyForUser, JSON.stringify(userFetched));
-                localStorage.setItem(storageKeyForAppSettings, JSON.stringify(appSettingsFetched));
 
-                runInAction(() => {
-                    this.tenant = tenantFetched;
-                    this.tenantConfigs = tenantConfigFetched;
-                    this.user = userFetched;
-                    this.appSettings = appSettingsFetched;
-                });
+                const localeFetched = coreConfigs[cultureKeyInCoreConfigs];
 
                 if (localeFetched) {
                     localStorage.setItem(storageKeyForLocale, JSON.stringify(localeFetched));
@@ -95,44 +91,20 @@ export class StandaloneRootStore extends Store {
             };
 
             // checks if the root is initialized first time across the app
-            if ((window as any)[isInitializedSymbol]) {
-                const tenantCached = localStorage.getItem(storageKeyForTenant);
-                const tenantConfigsCached = localStorage.getItem(storageKeyForConfig);
-                const userCached = localStorage.getItem(storageKeyForUser);
-                const appSettingsCached = localStorage.getItem(storageKeyForAppSettings);
-                const localeCached = localStorage.getItem(storageKeyForLocale);
-
-                if (
-                    tenantCached &&
-                    tenantConfigsCached &&
-                    userCached &&
-                    appSettingsCached &&
-                    localeCached
-                ) {
-                    const tenantCachedParsed = JSON.parse(tenantCached) as typeof this.tenant;
-                    const tenantConfigsCachedParsed = JSON.parse(
-                        tenantConfigsCached,
-                    ) as typeof this.tenantConfigs;
-                    const userCachedParsed = JSON.parse(userCached) as typeof this.user;
-                    const appSettingsCachedParsed = JSON.parse(
-                        appSettingsCached,
-                    ) as typeof this.appSettings;
-                    const localeCachedParsed = JSON.parse(localeCached) as typeof this.locale;
+            if (this.isInitialized && !forceRefresh) {
+                const isSuccess = this.syncFromStorage();
 
-                    runInAction(() => {
-                        this.tenant = tenantCachedParsed;
-                        this.tenantConfigs = tenantConfigsCachedParsed;
-                        this.user = userCachedParsed;
-                        this.appSettings = appSettingsCachedParsed;
-                        this.locale = localeCachedParsed;
-                    });
+                if (isSuccess) {
+                    if (refreshOnboarding) {
+                        await this.fetchOnboarding();
+                    }
                 } else {
-                    await fetchData();
+                    await fetchAll();
                 }
             } else {
-                await fetchData();
+                await fetchAll();
 
-                (window as any)[isInitializedSymbol] = true;
+                this.setIsInitialized(true);
             }
 
             const timezoneFetched = this.tenantConfigs.TimeZone;
@@ -146,10 +118,181 @@ export class StandaloneRootStore extends Store {
             runInAction(() => {
                 this.loadStatus = LoadStatus.Ok;
             });
+
+            this.registerGlobalSyncListener();
         } catch {
             runInAction(() => {
                 this.loadStatus = LoadStatus.Error;
             });
         }
     };
+
+    refreshTenant = () => this.fetchTenant().then(this.emitGlobalSync);
+    refreshTenantConfigs = () => this.fetchTenantConfigs().then(this.emitGlobalSync);
+    refreshUser = () => this.fetchUser().then(this.emitGlobalSync);
+    refreshAppSettings = () => this.fetchAppSettings().then(this.emitGlobalSync);
+    refreshOnboarding = () => this.fetchOnboarding().then(this.emitGlobalSync);
+    refreshPartitions = () => this.fetchPartitions().then(this.emitGlobalSync);
+
+    get defaultMFEData() {
+        const { tenant, appSettings, timezone } = this;
+
+        return {
+            timezone,
+            partnerId: tenant.parentId,
+            partnerTenantId: tenant.externalId,
+            currentPartitionId: tenant.currentPartitionId,
+            featureFlagClientId: appSettings.featureFlagClientId,
+        };
+    }
+
+    unregisterGlobalSyncListener = () => {
+        this.eventEmitter.off(Events.SyncFromStorage, this.listenGlobalSync);
+    };
+
+    private initializeEventEmitter = () => {
+        const globalEventEmitter = (window as any)[eventEmitterSymbol];
+
+        if (globalEventEmitter) {
+            this.eventEmitter = globalEventEmitter;
+        } else {
+            (window as any)[eventEmitterSymbol] = new EventEmitter();
+            this.eventEmitter = (window as any)[eventEmitterSymbol];
+        }
+    };
+
+    private registerGlobalSyncListener = () => {
+        this.eventEmitter.on(Events.SyncFromStorage, this.listenGlobalSync);
+    };
+
+    private listenGlobalSync = (instanceSymbol: symbol) => {
+        if (instanceSymbol !== currentInstanceSymbol) {
+            this.syncFromStorage();
+        }
+    };
+
+    private emitGlobalSync = () => {
+        this.eventEmitter.emit(Events.SyncFromStorage, currentInstanceSymbol);
+    };
+
+    private syncFromStorage = () => {
+        const tenantCached = localStorage.getItem(storageKeyForTenant);
+        const tenantConfigsCached = localStorage.getItem(storageKeyForTenantConfigs);
+        const userCached = localStorage.getItem(storageKeyForUser);
+        const appSettingsCached = localStorage.getItem(storageKeyForAppSettings);
+        const onboardingCached = localStorage.getItem(storageKeyForOnboarding);
+        const partitionsCached = localStorage.getItem(storageKeyForPartitions);
+        const localeCached = localStorage.getItem(storageKeyForLocale);
+
+        if (
+            tenantCached &&
+            tenantConfigsCached &&
+            userCached &&
+            appSettingsCached &&
+            onboardingCached &&
+            partitionsCached &&
+            localeCached
+        ) {
+            const tenantCachedParsed = JSON.parse(tenantCached) as typeof this.tenant;
+            const tenantConfigsCachedParsed = JSON.parse(
+                tenantConfigsCached,
+            ) as typeof this.tenantConfigs;
+            const userCachedParsed = JSON.parse(userCached) as typeof this.user;
+            const appSettingsCachedParsed = JSON.parse(
+                appSettingsCached,
+            ) as typeof this.appSettings;
+            const onboardingCachedParsed = JSON.parse(onboardingCached) as typeof this.onboarding;
+            const partitionsCachedParsed = JSON.parse(partitionsCached) as typeof this.partitions;
+            const localeCachedParsed = JSON.parse(localeCached) as typeof this.locale;
+
+            runInAction(() => {
+                this.tenant = tenantCachedParsed;
+                this.tenantConfigs = tenantConfigsCachedParsed;
+                this.user = userCachedParsed;
+                this.appSettings = appSettingsCachedParsed;
+                this.onboarding = onboardingCachedParsed;
+                this.partitions = partitionsCachedParsed;
+                this.locale = localeCachedParsed;
+            });
+
+            return true;
+        }
+
+        return false;
+    };
+
+    private setIsInitialized = (value: boolean) => {
+        (window as any)[isInitializedSymbol] = value;
+    };
+
+    private get isInitialized() {
+        return !!(window as any)[isInitializedSymbol];
+    }
+
+    private fetchTenant = async () => {
+        const tenantFetched = await this.tenantManagementApi.client.tenant(undefined);
+
+        localStorage.setItem(storageKeyForTenant, JSON.stringify(tenantFetched));
+
+        runInAction(() => {
+            this.tenant = tenantFetched;
+        });
+    };
+
+    private fetchTenantConfigs = async () => {
+        const tenantConfigsFetched = await this.tenantManagementApi.client.config(
+            undefined,
+            undefined,
+            undefined,
+            undefined,
+        );
+
+        localStorage.setItem(storageKeyForTenantConfigs, JSON.stringify(tenantConfigsFetched));
+
+        runInAction(() => {
+            this.tenantConfigs = tenantConfigsFetched;
+        });
+    };
+
+    private fetchUser = async () => {
+        const { data: userFetched } = await this.currentUserClientApi.getUserName();
+
+        localStorage.setItem(storageKeyForUser, JSON.stringify(userFetched));
+
+        runInAction(() => {
+            this.user = userFetched;
+        });
+    };
+
+    private fetchAppSettings = async () => {
+        const { data: appSettingsFetched } = await this.appConfigApi.getAppSettings();
+
+        localStorage.setItem(storageKeyForAppSettings, JSON.stringify(appSettingsFetched));
+
+        runInAction(() => {
+            this.appSettings = appSettingsFetched;
+        });
+    };
+
+    private fetchOnboarding = async () => {
+        const { data: onboardingFetched } = await this.onboardingApi.getStatus();
+
+        localStorage.setItem(storageKeyForOnboarding, JSON.stringify(onboardingFetched));
+
+        runInAction(() => {
+            this.onboarding = onboardingFetched;
+        });
+    };
+
+    private fetchPartitions = async () => {
+        const { data: partitionsFetchedUnfiltered } =
+            await this.partitionsApi.userAssignedPartitions();
+        const partitionsFetched = partitionsFetchedUnfiltered.filter(Boolean) as PartitionInfo[];
+
+        localStorage.setItem(storageKeyForPartitions, JSON.stringify(partitionsFetched));
+
+        runInAction(() => {
+            this.partitions = partitionsFetched;
+        });
+    };
 }

package/src/utils/constants.ts

@@ -0,0 +1,4 @@
+export const defaultTimezone = 'UTC';
+export const defaultLocale = 'en-US';
+
+export const cultureKeyInCoreConfigs = 'Customers___Locations:Culture';

package/src/utils/event-emitter.ts

@@ -0,0 +1,27 @@
+type Listener = (instanceSymbol: symbol) => void;
+
+export class EventEmitter {
+    private events: Record<string, Listener[]> = {};
+
+    on(event: string, listener: Listener) {
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        this.events[event].push(listener);
+        return () => this.off(event, listener);
+    }
+
+    off(event: string, listener: Listener) {
+        if (!this.events[event]) {
+            return;
+        }
+        this.events[event] = this.events[event].filter(l => l !== listener);
+    }
+
+    emit(event: string, instanceSymbol: symbol) {
+        if (!this.events[event]) {
+            return;
+        }
+        this.events[event].forEach(listener => listener(instanceSymbol));
+    }
+}

package/src/utils/events.ts

@@ -0,0 +1,3 @@
+export enum Events {
+    SyncFromStorage = 'SyncFromStorage',
+}

package/src/utils/storage-keys.ts

@@ -0,0 +1,9 @@
+const storageKey = 'standalone-root-cache';
+
+export const storageKeyForTenant = `${storageKey}-tenant`;
+export const storageKeyForTenantConfigs = `${storageKey}-config`;
+export const storageKeyForUser = `${storageKey}-user`;
+export const storageKeyForAppSettings = `${storageKey}-app-settings`;
+export const storageKeyForOnboarding = `${storageKey}-onboarding`;
+export const storageKeyForPartitions = `${storageKey}-partitions`;
+export const storageKeyForLocale = `${storageKey}-locale`;

package/src/utils/symbols.ts

@@ -0,0 +1,6 @@
+const rootSymbolKey = 'standalone-root-symbol-key';
+const eventEmitterSymbolKey = 'standalone-root-event-emitter-symbol-key';
+
+export const isInitializedSymbol = Symbol.for(rootSymbolKey);
+export const eventEmitterSymbol = Symbol.for(eventEmitterSymbolKey);
+export const currentInstanceSymbol = Symbol();