Move UserStore to new format

Signed-off-by: Sebastian Malton <sebastian@malton.name>

packages/core/src/common/user-store/user-store.injectable.ts

@@ -6,18 +6,12 @@ import { getInjectable } from "@ogre-tools/injectable";
 import { UserStore } from "./user-store";
 import selectedUpdateChannelInjectable from "../../features/application-update/common/selected-update-channel/selected-update-channel.injectable";
 import emitAppEventInjectable from "../app-event-bus/emit-event.injectable";
-import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
-import getConfigurationFileModelInjectable from "../get-configuration-file-model/get-configuration-file-model.injectable";
 import loggerInjectable from "../logger.injectable";
 import storeMigrationVersionInjectable from "../vars/store-migration-version.injectable";
 import storeMigrationsInjectable from "../base-store/migrations.injectable";
 import { userStoreMigrationInjectionToken } from "./migrations-token";
-import { baseStoreIpcChannelPrefixesInjectionToken } from "../base-store/channel-prefix";
-import { shouldBaseStoreDisableSyncInIpcListenerInjectionToken } from "../base-store/disable-sync";
-import { persistStateToConfigInjectionToken } from "../base-store/save-to-file";
-import getBasenameOfPathInjectable from "../path/get-basename.injectable";
-import { enlistMessageChannelListenerInjectionToken } from "@k8slens/messaging";
 import userStorePreferenceDescriptorsInjectable from "./preference-descriptors.injectable";
+import createBaseStoreInjectable from "../base-store/create-base-store.injectable";
 
 const userStoreInjectable = getInjectable({
   id: "user-store",
@@ -25,17 +19,11 @@ const userStoreInjectable = getInjectable({
   instantiate: (di) => new UserStore({
     selectedUpdateChannel: di.inject(selectedUpdateChannelInjectable),
     emitAppEvent: di.inject(emitAppEventInjectable),
-    directoryForUserData: di.inject(directoryForUserDataInjectable),
-    getConfigurationFileModel: di.inject(getConfigurationFileModelInjectable),
     logger: di.inject(loggerInjectable),
     storeMigrationVersion: di.inject(storeMigrationVersionInjectable),
     migrations: di.inject(storeMigrationsInjectable, userStoreMigrationInjectionToken),
-    getBasenameOfPath: di.inject(getBasenameOfPathInjectable),
-    ipcChannelPrefixes: di.inject(baseStoreIpcChannelPrefixesInjectionToken),
-    persistStateToConfig: di.inject(persistStateToConfigInjectionToken),
-    enlistMessageChannelListener: di.inject(enlistMessageChannelListenerInjectionToken),
-    shouldDisableSyncInListener: di.inject(shouldBaseStoreDisableSyncInIpcListenerInjectionToken),
     preferenceDescriptors: di.inject(userStorePreferenceDescriptorsInjectable),
+    createBaseStore: di.inject(createBaseStoreInjectable),
   }),
 });
 

packages/core/src/common/user-store/user-store.ts

@@ -3,9 +3,8 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import { action, observable, makeObservable, isObservableArray, isObservableSet, isObservableMap } from "mobx";
+import { action, observable, makeObservable, isObservableArray, isObservableSet, isObservableMap, runInAction } from "mobx";
-import type { BaseStoreDependencies } from "../base-store/base-store";
+import type { BaseStore } from "../base-store/base-store";
-import { BaseStore } from "../base-store/base-store";
 import { getOrInsertSet, toggle, object } from "@k8slens/utilities";
 import type { UserPreferencesModel, StoreType } from "./preferences-helpers";
 import type { EmitAppEvent } from "../app-event-bus/emit-event.injectable";
@@ -14,37 +13,72 @@ import type { EmitAppEvent } from "../app-event-bus/emit-event.injectable";
 import type { SelectedUpdateChannel } from "../../features/application-update/common/selected-update-channel/selected-update-channel.injectable";
 import type { ReleaseChannel } from "../../features/application-update/common/update-channels";
 import type { PreferenceDescriptors } from "./preference-descriptors.injectable";
+import type { CreateBaseStore } from "../base-store/create-base-store.injectable";
+import type { Logger } from "../logger";
+import type { Migrations } from "conf/dist/source/types";
 import { toJS } from "../utils";
 
 export interface UserStoreModel {
   preferences: UserPreferencesModel;
 }
 
-interface Dependencies extends BaseStoreDependencies {
+interface Dependencies {
   readonly selectedUpdateChannel: SelectedUpdateChannel;
   readonly preferenceDescriptors: PreferenceDescriptors;
+  readonly logger: Logger;
+  readonly storeMigrationVersion: string;
+  readonly migrations: Migrations<Record<string, unknown>>;
   emitAppEvent: EmitAppEvent;
+  createBaseStore: CreateBaseStore;
 }
 
-export class UserStore extends BaseStore<UserStoreModel> /* implements UserStoreFlatModel (when strict null is enabled) */ {
+export class UserStore {
+  private readonly store: BaseStore<UserStoreModel>;
+
   constructor(protected readonly dependencies: Dependencies) {
-    super(dependencies, {
+    this.store = this.dependencies.createBaseStore({
       configName: "lens-user-store",
+      projectVersion: this.dependencies.storeMigrationVersion,
+      migrations: this.dependencies.migrations as unknown as Migrations<UserStoreModel>,
+      fromStore: action(({ preferences }) => {
+        this.dependencies.logger.debug("UserStore.fromStore()", { preferences });
+
+        for (const [key, { fromStore }] of object.entries(this.dependencies.preferenceDescriptors)) {
+          const curVal = this[key];
+          const newVal = fromStore((preferences)?.[key] as never) as never;
+
+          if (isObservableArray(curVal)) {
+            curVal.replace(newVal);
+          } else if (isObservableSet(curVal) || isObservableMap(curVal)) {
+            curVal.replace(newVal);
+          } else {
+            this[key] = newVal;
+          }
+        }
+
+        // TODO: Switch to action-based saving instead saving stores by reaction
+        if (preferences?.updateChannel) {
+          this.dependencies.selectedUpdateChannel.setValue(preferences?.updateChannel as ReleaseChannel);
+        }
+      }),
+      toJSON: () => {
+        const preferences = object.fromEntries(
+          object.entries(this.dependencies.preferenceDescriptors)
+            .map(([key, { toStore }]) => [key, toStore(this[key] as never)]),
+        ) as UserPreferencesModel;
+
+        return toJS({
+          preferences: {
+            ...preferences,
+            updateChannel: this.dependencies.selectedUpdateChannel.value.get().id,
+          },
+        });
+      },
     });
 
     makeObservable(this);
   }
 
-  /**
-   * @deprecated No longer used
-   */
-  @observable seenContexts = observable.set<string>();
-
-  /**
-   * @deprecated No longer used
-   */
-  @observable newContexts = observable.set<string>();
-
   @observable allowErrorReporting!: StoreType<PreferenceDescriptors["allowErrorReporting"]>;
   @observable allowUntrustedCAs!: StoreType<PreferenceDescriptors["allowUntrustedCAs"]>;
   @observable colorTheme!: StoreType<PreferenceDescriptors["colorTheme"]>;
@@ -112,45 +146,13 @@ export class UserStore extends BaseStore<UserStoreModel> /* implements UserStore
     toggle(getOrInsertSet(this.hiddenTableColumns, tableId), columnId);
   }
 
-  @action
   resetTheme() {
-    this.colorTheme = this.dependencies.preferenceDescriptors.colorTheme.fromStore(undefined);
+    runInAction(() => {
-  }
+      this.colorTheme = this.dependencies.preferenceDescriptors.colorTheme.fromStore(undefined);
-
-  @action
-  protected fromStore({ preferences }: Partial<UserStoreModel> = {}) {
-    this.dependencies.logger.debug("UserStore.fromStore()", { preferences });
-
-    for (const [key, { fromStore }] of object.entries(this.dependencies.preferenceDescriptors)) {
-      const curVal = this[key];
-      const newVal = fromStore((preferences)?.[key] as never) as never;
-
-      if (isObservableArray(curVal)) {
-        curVal.replace(newVal);
-      } else if (isObservableSet(curVal) || isObservableMap(curVal)) {
-        curVal.replace(newVal);
-      } else {
-        this[key] = newVal;
-      }
-    }
-
-    // TODO: Switch to action-based saving instead saving stores by reaction
-    if (preferences?.updateChannel) {
-      this.dependencies.selectedUpdateChannel.setValue(preferences?.updateChannel as ReleaseChannel);
-    }
-  }
-
-  toJSON(): UserStoreModel {
-    const preferences = object.fromEntries(
-      object.entries(this.dependencies.preferenceDescriptors)
-        .map(([key, { toStore }]) => [key, toStore(this[key] as never)]),
-    ) as UserPreferencesModel;
-
-    return toJS({
-      preferences: {
-        ...preferences,
-        updateChannel: this.dependencies.selectedUpdateChannel.value.get().id,
-      },
     });
   }
+
+  load() {
+    this.store.load();
+  }
 }