1 files changed, 95 insertions, 35 deletions

diff --git a/packages/main/src/stores/SharedStore.ts b/packages/main/src/stores/SharedStore.ts
index 861c8ce..9ec7963 100644
--- a/packages/main/src/stores/SharedStore.ts
+++ b/packages/main/src/stores/SharedStore.ts
@@ -22,12 +22,16 @@ import { sharedStore as originalSharedStore } from '@sophie/shared';
 import {
   applySnapshot,
   getSnapshot,
+  IMSTArray,
+  IMSTMap,
   Instance,
+  IReferenceType,
+  IStateTreeNode,
+  IType,
   resolveIdentifier,
   types,
 } from 'mobx-state-tree';
 
-import SettingsWithId from '../utils/SettingsWithId';
 import { getLogger } from '../utils/log';
 import overrideProps from '../utils/overrideProps';
 
@@ -51,27 +55,51 @@ function getConfigs<T>(models: { config: T }[]): T[] | undefined {
   return models.length === 0 ? undefined : models.map((model) => model.config);
 }
 
-function reconcileSettings<T>(
-  originalSnapshots: SettingsWithId<T>[],
-  settingsSnapshotsWithId: SettingsWithId<T>[],
-): SettingsWithId<T>[] {
-  const idToOriginalSnapshots = new Map(
-    originalSnapshots.map((originalSnapshot) => [
-      originalSnapshot.id,
-      originalSnapshot,
-    ]),
-  );
-  return settingsSnapshotsWithId.map(({ id, settings }) => ({
-    ...idToOriginalSnapshots.get(id),
-    id,
-    settings,
-  }));
+type TypeWithSettings<C> = IType<
+  { id: string; settings: C },
+  unknown,
+  { settings: IStateTreeNode<IType<C, unknown, unknown>> }
+>;
+
+function deleteStaleModels<C, D extends TypeWithSettings<C>>(
+  currentById: IMSTMap<D>,
+  toApplyById: Map<string, C>,
+): void {
+  const toDelete = new Set(currentById.keys());
+  toApplyById.forEach((_settings, id) => toDelete.delete(id));
+  toDelete.forEach((id) => currentById.delete(id));
+}
+
+function applySettings<C, D extends TypeWithSettings<C>>(
+  currentById: IMSTMap<D>,
+  toApplyById: Map<string, C>,
+): void {
+  toApplyById.forEach((settingsSnapshot, id) => {
+    const model = currentById.get(id);
+    if (model === undefined) {
+      currentById.set(id, {
+        id,
+        settings: settingsSnapshot,
+      });
+    } else {
+      applySnapshot(model.settings, settingsSnapshot);
+    }
+  });
+}
+
+function pushReferences<C, D extends TypeWithSettings<C>>(
+  list: IMSTArray<IReferenceType<D>>,
+  toApply: [string, C][],
+): void {
+  list.push(...toApply.map(([id]) => id));
 }
 
 export const sharedStore = overrideProps(originalSharedStore, {
   settings: types.optional(globalSettings, {}),
-  profiles: types.array(profile),
-  services: types.array(service),
+  profilesById: types.map(profile),
+  profiles: types.array(types.reference(profile)),
+  servicesById: types.map(service),
+  services: types.array(types.reference(service)),
   selectedService: types.safeReference(service),
 })
   .views((self) => ({
@@ -87,25 +115,57 @@ export const sharedStore = overrideProps(originalSharedStore, {
   }))
   .actions((self) => ({
     loadConfig(config: Config): void {
-      const snapshot = getSnapshot(self);
-      const { profiles, services, ...settings } = config;
-      const profileSettingsSnapshots = addMissingProfileIds(profiles);
-      const serviceSettingsSnapshots = addMissingServiceIdsAndProfiles(
+      // `onPatch` will send store changes piecemeal without any attention to
+      // transaction boundaries. We must make sure that any state communicated to the
+      // renderer process is actually valid.
+      const {
+        profiles,
+        profilesById,
+        selectedService,
         services,
-        profileSettingsSnapshots,
-      );
-      applySnapshot(self, {
-        ...snapshot,
+        servicesById,
         settings,
-        profiles: reconcileSettings(
-          snapshot.profiles,
-          profileSettingsSnapshots,
-        ),
-        services: reconcileSettings(
-          snapshot.services,
-          serviceSettingsSnapshots,
-        ),
-      });
+      } = self;
+      const { id: selectedServiceId } = selectedService ?? { id: undefined };
+      const {
+        profiles: profilesConfig,
+        services: servicesConfig,
+        ...settingsToApply
+      } = config;
+      const profilesToApply = addMissingProfileIds(profilesConfig);
+      const servicesToApply = addMissingServiceIdsAndProfiles(
+        servicesConfig,
+        profilesToApply,
+      );
+      const profilesToApplyById = new Map(profilesToApply);
+      const servicesToApplyById = new Map(servicesToApply);
+      // First remove any references to profiles and services that might be deleted.
+      self.selectedService = undefined;
+      services.clear();
+      profiles.clear();
+      // Delete all services that may depend on profiles that will be delete.
+      deleteStaleModels(servicesById, servicesToApplyById);
+      // Update existing profiles and add new profiles.
+      applySettings(profilesById, profilesToApplyById);
+      // Update existing services and add new services. This will make sure that no service
+      // depends on a profile that will be deleted.
+      applySettings(servicesById, servicesToApplyById);
+      // Now it's safe to delete stale profiles.
+      deleteStaleModels(profilesById, profilesToApplyById);
+      // We are ready to build new profile and service lists from the new models.
+      pushReferences(profiles, profilesToApply);
+      pushReferences(services, servicesToApply);
+      // Global settings may refer to particular profiles or services.
+      applySnapshot(settings, settingsToApply);
+      // Restore service selection (if applicable).
+      let newSelectedService;
+      if (selectedServiceId !== undefined) {
+        newSelectedService = servicesById.get(selectedServiceId);
+      }
+      if (newSelectedService === undefined && services.length > 0) {
+        [newSelectedService] = services;
+      }
+      self.selectedService = newSelectedService;
     },
     setShouldUseDarkColors(shouldUseDarkColors: boolean): void {
       self.shouldUseDarkColors = shouldUseDarkColors;