[Feat/Tech] Migration system

src/backend/components/migration/index.ts

@@ -0,0 +1,70 @@
+import { TypeCheckedStoreBackend } from '../../electron_store'
+import { logError, logInfo } from '../../logger/logger'
+
+import { LegendaryGlobalConfigFolderMigration } from './migrations/legendary'
+
+import type { TypeCheckedStore } from 'common/types/electron_store'
+
+export interface Migration {
+  identifier: string
+  run(): Promise<boolean>
+}
+
+export default class MigrationComponent {
+  constructor() {
+    this.migrationsStore = new TypeCheckedStoreBackend('migrationsStore', {
+      cwd: 'store',
+      name: 'migrations'
+    })
+  }
+
+  async applyMigrations() {
+    const appliedMigrations = this.migrationsStore.get('appliedMigrations', [])
+
+    // NOTE: This intentionally runs migrations sequentially to avoid race conditions
+    for (const migration of this.getAllMigrations()) {
+      if (appliedMigrations.includes(migration.identifier)) continue
+
+      const wasApplied = await this.applyMigration(migration)
+      if (wasApplied) appliedMigrations.push(migration.identifier)
+    }
+
+    this.migrationsStore.set('appliedMigrations', appliedMigrations)
+  }
+
+  private async applyMigration(migration: Migration): Promise<boolean> {
+    logInfo(['Applying migration', `"${migration.identifier}"`])
+    const result = await migration.run().catch((e: Error) => e)
+
+    if (!result) {
+      // The idea here is that the migration failed, but did so gracefully.
+      // It thus (hopefully) printed out some of its own logging on why it
+      // failed
+      logError([
+        'Migration',
+        `"${migration.identifier}"`,
+        'failed. More details will be available above this message'
+      ])
+      return false
+    }
+
+    if (result instanceof Error) {
+      logError([
+        'Migration',
+        `"${migration.identifier}"`,
+        'encountered error while applying:',
+        result
+      ])
+      return false
+    }
+
+    logInfo(['Migration', `"${migration.identifier}"`, 'successfully applied'])
+    return true
+  }
+
+  private getAllMigrations(): Migration[] {
+    return [new LegendaryGlobalConfigFolderMigration()]
+  }
+
+  private readonly migrationsStore: TypeCheckedStore<'migrationsStore'>
+}

src/backend/components/migration/migrations/legendary.ts

@@ -0,0 +1,35 @@
+import { app } from 'electron'
+import { type PathLike } from 'fs'
+import { access, cp, mkdir } from 'fs/promises'
+import { join } from 'path'
+
+import { isLinux, legendaryConfigPath, userHome } from 'backend/constants'
+
+import type { Migration } from '..'
+
+const exists = async (path: PathLike) =>
+  access(path).then(
+    () => true,
+    () => false
+  )
+
+export class LegendaryGlobalConfigFolderMigration implements Migration {
+  identifier = 'legendary-move-global-config-folder'
+  async run(): Promise<boolean> {
+    const hasHeroicSpecificConfig = await exists(legendaryConfigPath)
+    // Don't overwrite existing configuration
+    if (hasHeroicSpecificConfig) return true
+
+    const globalLegendaryConfig = isLinux
+      ? join(app.getPath('appData'), 'legendary')
+      : join(userHome, '.config', 'legendary')
+
+    const hasGlobalConfig = await exists(globalLegendaryConfig)
+    // Nothing to migrate
+    if (!hasGlobalConfig) return true
+
+    await mkdir(legendaryConfigPath, { recursive: true })
+    await cp(globalLegendaryConfig, legendaryConfigPath, { recursive: true })
+    return true
+  }
+}

src/backend/electron_store.ts

@@ -8,14 +8,12 @@ import {
 } from 'common/types/electron_store'
 import { Get } from 'type-fest'
 
-export class TypeCheckedStoreBackend<
-  Name extends ValidStoreName,
-  Structure extends StoreStructure[Name]
-> implements TypeCheckedStore<Name, Structure>
+export class TypeCheckedStoreBackend<Name extends ValidStoreName>
+  implements TypeCheckedStore<Name>
 {
   private store: Store
 
-  constructor(name: Name, options: Store.Options<Structure>) {
+  constructor(name: Name, options: Store.Options<StoreStructure[Name]>) {
     // @ts-expect-error This looks like a bug in electron-store's type definitions
     this.store = new Store(options)
   }
@@ -26,22 +24,22 @@ export class TypeCheckedStoreBackend<
 
   public get<KeyType extends string>(
     key: KeyType,
-    defaultValue: NonNullable<UnknownGuard<Get<Structure, KeyType>>>
+    defaultValue: NonNullable<UnknownGuard<Get<StoreStructure[Name], KeyType>>>
   ) {
     return this.store.get(key, defaultValue) as NonNullable<
-      UnknownGuard<Get<Structure, KeyType>>
+      UnknownGuard<Get<StoreStructure[Name], KeyType>>
     >
   }
 
   public get_nodefault<KeyType extends string>(key: KeyType) {
     return this.store.get(key) as UnknownGuard<
-      Get<Structure, KeyType> | undefined
+      Get<StoreStructure[Name], KeyType> | undefined
     >
   }
 
   public set<KeyType extends string>(
     key: KeyType,
-    value: UnknownGuard<Get<Structure, KeyType>>
+    value: UnknownGuard<Get<StoreStructure[Name], KeyType>>
   ) {
     this.store.set(key, value)
   }

src/backend/main.ts

@@ -145,6 +145,7 @@ import {
   getGameSdl
 } from 'backend/storeManagers/legendary/library'
 import { storeMap } from 'common/utils'
+import MigrationComponent from './components/migration'
 
 app.commandLine?.appendSwitch('ozone-platform-hint', 'auto')
 
@@ -301,6 +302,9 @@ if (!gotTheLock) {
     handleProtocol(argv)
   })
   app.whenReady().then(async () => {
+    const migrationComponent = new MigrationComponent()
+    await migrationComponent.applyMigrations()
+
     initLogger()
     initOnlineMonitor()
     initStoreManagers()

src/backend/storeManagers/legendary/library.ts

@@ -30,8 +30,6 @@ import {
   legendaryConfigPath,
   legendaryLogFile,
   legendaryMetadata,
-  isLinux,
-  userHome,
   isWindows
 } from '../../constants'
 import {
@@ -50,8 +48,6 @@ import { callRunner } from '../../launcher'
 import { dirname, join } from 'path'
 import { isOnline } from 'backend/online_monitor'
 import { update } from './games'
-import { app } from 'electron'
-import { copySync } from 'fs-extra'
 import { LegendaryCommand } from './commands'
 import { LegendaryAppName, LegendaryPlatform } from './commands/base'
 import { Path } from 'backend/schemas'
@@ -65,15 +61,6 @@ let installedGames: Map<string, InstalledJsonMetadata> = new Map()
 const library: Map<string, GameInfo> = new Map()
 
 export async function initLegendaryLibraryManager() {
-  // Migrate user data from global Legendary config if necessary
-  const globalLegendaryConfig = isLinux
-    ? join(app.getPath('appData'), 'legendary')
-    : join(userHome, '.config', 'legendary')
-  if (!existsSync(legendaryConfigPath) && existsSync(globalLegendaryConfig)) {
-    mkdirSync(legendaryConfigPath, { recursive: true })
-    copySync(globalLegendaryConfig, legendaryConfigPath)
-  }
-
   loadGamesInAccount()
   refreshInstalled()
 }

src/common/types/electron_store.ts

@@ -99,6 +99,9 @@ export interface StoreStructure {
     [title: string]: WikiInfo
   }
   uploadedLogs: Record<string, UploadedLogData>
+  migrationsStore: {
+    appliedMigrations: string[]
+  }
 }
 
 export type StoreOptions<T extends Record<string, unknown>> = Store.Options<T>
@@ -112,24 +115,21 @@ export type UnknownGuard<T> = unknown extends T
     : never
   : T
 
-export abstract class TypeCheckedStore<
-  Name extends ValidStoreName,
-  Structure extends StoreStructure[Name]
-> {
+export abstract class TypeCheckedStore<Name extends ValidStoreName> {
   abstract has(key: string): boolean
 
   abstract get<KeyType extends string>(
     key: KeyType,
-    defaultValue: NonNullable<UnknownGuard<Get<Structure, KeyType>>>
-  ): NonNullable<UnknownGuard<Get<Structure, KeyType>>>
+    defaultValue: NonNullable<UnknownGuard<Get<StoreStructure[Name], KeyType>>>
+  ): NonNullable<UnknownGuard<Get<StoreStructure[Name], KeyType>>>
 
   abstract get_nodefault<KeyType extends string>(
     key: KeyType
-  ): UnknownGuard<Get<Structure, KeyType> | undefined>
+  ): UnknownGuard<Get<StoreStructure[Name], KeyType> | undefined>
 
   abstract set<KeyType extends string>(
     key: KeyType,
-    value: UnknownGuard<Get<Structure, KeyType>>
+    value: UnknownGuard<Get<StoreStructure[Name], KeyType>>
   ): void
 
   // FIXME: This is currently not type-checked properly

src/frontend/helpers/electronStores.ts

@@ -9,14 +9,12 @@ import {
 } from 'common/types/electron_store'
 import { GameInfo } from 'common/types'
 
-export class TypeCheckedStoreFrontend<
-  Name extends ValidStoreName,
-  Structure extends StoreStructure[Name]
-> implements TypeCheckedStore<Name, Structure>
+export class TypeCheckedStoreFrontend<Name extends ValidStoreName>
+  implements TypeCheckedStore<Name>
 {
   private storeName: ValidStoreName
 
-  constructor(name: Name, options: StoreOptions<Structure>) {
+  constructor(name: Name, options: StoreOptions<StoreStructure[Name]>) {
     this.storeName = name
     // @ts-expect-error This looks like a bug in electron-store's type definitions
     window.api.storeNew(name, options)
@@ -28,24 +26,24 @@ export class TypeCheckedStoreFrontend<
 
   public get<KeyType extends string>(
     key: KeyType,
-    defaultValue: NonNullable<UnknownGuard<Get<Structure, KeyType>>>
+    defaultValue: NonNullable<UnknownGuard<Get<StoreStructure[Name], KeyType>>>
   ) {
     return window.api.storeGet(
       this.storeName,
       key,
       defaultValue
-    ) as NonNullable<UnknownGuard<Get<Structure, KeyType>>>
+    ) as NonNullable<UnknownGuard<Get<StoreStructure[Name], KeyType>>>
   }
 
   public get_nodefault<KeyType extends string>(key: KeyType) {
     return window.api.storeGet(this.storeName, key) as UnknownGuard<
-      Get<Structure, KeyType> | undefined
+      Get<StoreStructure[Name], KeyType> | undefined
     >
   }
 
   public set<KeyType extends string>(
     key: KeyType,
-    value: UnknownGuard<Get<Structure, KeyType>>
+    value: UnknownGuard<Get<StoreStructure[Name], KeyType>>
   ) {
     window.api.storeSet(this.storeName, key, value)
   }