fix: Retrieve projectVersion from main for 'extensions-persistent-storage'

- Prevent the version being changed by the renderer

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

packages/core/src/common/initializable-state/create.ts

@@ -26,12 +26,11 @@ export type ImplInitializableInjectionTokensArgs<T> = {
   token: Initializable<T>;
   init: (di: DiContainerForInjection) => T | Promise<T>;
 } & (
-  {
+  | {
     phase: InjectionToken<Runnable<void>, void>;
     runAfter?: Injectable<Runnable<void>, Runnable<void>, void>[];
   }
-  |
-  {
+  | {
     runAfter: Injectable<Runnable<void>, Runnable<void>, void>;
     phase?: undefined;
   }

packages/core/src/features/extensions/enabled/common/storage-version.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { getRequestChannel } from "@k8slens/messaging";
+import { getInitializable } from "../../../../common/initializable-state/create";
+
+export const enabledExtensionsPersistentStorageVersionInitializable = getInitializable<string>(
+  "enabled-extensions-persistent-storage-version",
+);
+
+export const enabledExtensionsPersistentStorageVersionChannel = getRequestChannel<void, string>(
+  "enabled-extensions-persistent-storage-version",
+);

packages/core/src/features/extensions/enabled/common/storage.injectable.ts

@@ -3,6 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { LensExtensionId } from "@k8slens/legacy-extensions";
+import { isDefined } from "@k8slens/utilities";
 import { getInjectable } from "@ogre-tools/injectable";
 import { action, toJS } from "mobx";
 import createPersistentStorageInjectable from "../../../../common/persistent-storage/create.injectable";
@@ -10,6 +11,13 @@ import persistentStorageMigrationsInjectable from "../../../../common/persistent
 import { enabledExtensionsMigrationDeclarationInjectionToken } from "./migrations";
 import type { LensExtensionState } from "./state.injectable";
 import enabledExtensionsStateInjectable from "./state.injectable";
+import { enabledExtensionsPersistentStorageVersionInitializable } from "./storage-version";
+import z from "zod";
+
+const stateModel = z.object({
+  enabled: z.boolean(),
+  name: z.string(),
+});
 
 interface EnabledExtensionsStorageModal {
   extensions: [LensExtensionId, LensExtensionState][];
@@ -23,13 +31,25 @@ const enabledExtensionsPersistentStorageInjectable = getInjectable({
 
     return createPersistentStorage<EnabledExtensionsStorageModal>({
       configName: "lens-extensions",
-      fromStore: action(({ extensions = [] }) => {
+      fromStore: action(({ extensions: rawExtensions = [] }) => {
+        const extensions = rawExtensions
+          .map(([key, value]) => {
+            const verification = stateModel.safeParse(value);
+
+            if (!verification.success) {
+              return undefined;
+            }
+
+            return [key, verification.data] as const;
+          })
+          .filter(isDefined);
+
         state.replace(extensions);
       }),
       toJSON: () => ({
         extensions: [...toJS(state)],
       }),
-      projectVersion: "6.5.0",  // temporary fix for #7784, otherwise calculated wrong on the renderer process
+      projectVersion: di.inject(enabledExtensionsPersistentStorageVersionInitializable.stateToken),
       migrations: di.inject(persistentStorageMigrationsInjectable, enabledExtensionsMigrationDeclarationInjectionToken),
     });
   },

packages/core/src/features/extensions/enabled/main/storage-version-handler.injectable.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { getRequestChannelListenerInjectable } from "@k8slens/messaging";
+import { enabledExtensionsPersistentStorageVersionChannel, enabledExtensionsPersistentStorageVersionInitializable } from "../common/storage-version";
+
+const enabledExtensionsPersistentStorageVersionChannelHandler = getRequestChannelListenerInjectable({
+  id: "enabled-extensions-persistent-storage-version-handler",
+  channel: enabledExtensionsPersistentStorageVersionChannel,
+  getHandler: (di) => {
+    const version = di.inject(enabledExtensionsPersistentStorageVersionInitializable.stateToken);
+
+    return () => version;
+  },
+});
+
+export default enabledExtensionsPersistentStorageVersionChannelHandler;

packages/core/src/features/extensions/enabled/main/storage-version.injectable.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import storageMigrationVersionInjectable from "../../../../common/persistent-storage/storage-migration-version.injectable";
+import { enabledExtensionsMigrationDeclarationInjectionToken } from "../common/migrations";
+import { enabledExtensionsPersistentStorageVersionInitializable } from "../common/storage-version";
+import { getInjectable } from "@ogre-tools/injectable";
+
+const enabledExtensionsPersistentStorageVersionStateInjectable = getInjectable({
+  id: "enabled-extensions-persistent-storage-version-state",
+  instantiate: (di) => di.inject(storageMigrationVersionInjectable, enabledExtensionsMigrationDeclarationInjectionToken),
+  injectionToken: enabledExtensionsPersistentStorageVersionInitializable.stateToken,
+});
+
+export default enabledExtensionsPersistentStorageVersionStateInjectable;
+

packages/core/src/features/extensions/enabled/renderer/load-storage.injectable.ts

@@ -5,6 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { beforeFrameStartsSecondInjectionToken } from "../../../../renderer/before-frame-starts/tokens";
 import enabledExtensionsPersistentStorageInjectable from "../common/storage.injectable";
+import { enabledExtensionsPersistentStorageVersionInitializationInjectable } from "./storage-version.injectable";
 
 const loadEnabledExtensionsStorageInjectable = getInjectable({
   id: "load-enabled-extensions-storage",
@@ -14,6 +15,7 @@ const loadEnabledExtensionsStorageInjectable = getInjectable({
 
       storage.loadAndStartSyncing();
     },
+    runAfter: enabledExtensionsPersistentStorageVersionInitializationInjectable,
   }),
   injectionToken: beforeFrameStartsSecondInjectionToken,
 });

packages/core/src/features/extensions/enabled/renderer/storage-version.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { requestFromChannelInjectionToken } from "@k8slens/messaging";
+import { getInjectablesForInitializable } from "../../../../common/initializable-state/create";
+import { beforeFrameStartsSecondInjectionToken } from "../../../../renderer/before-frame-starts/tokens";
+import { enabledExtensionsPersistentStorageVersionChannel, enabledExtensionsPersistentStorageVersionInitializable } from "../common/storage-version";
+
+const {
+  initializationInjectable: enabledExtensionsPersistentStorageVersionInitializationInjectable,
+  stateInjectable: enabledExtensionsPersistentStorageVersionStateInjectable,
+} = getInjectablesForInitializable({
+  token: enabledExtensionsPersistentStorageVersionInitializable,
+  init: (di) => {
+    const requestFromChannel = di.inject(requestFromChannelInjectionToken);
+
+    return requestFromChannel(enabledExtensionsPersistentStorageVersionChannel);
+  },
+  phase: beforeFrameStartsSecondInjectionToken,
+});
+
+export {
+  enabledExtensionsPersistentStorageVersionInitializationInjectable,
+  enabledExtensionsPersistentStorageVersionStateInjectable,
+};