Improved error logging when file icon extraction fails

src/common/Core/ContextBridge.ts

@@ -11,6 +11,7 @@ export type ContextBridge = {
         on: IpcRenderer["on"];
     };
 
+    resetChache: () => Promise<void>;
     copyTextToClipboard: (textToCopy: string) => void;
     extensionDisabled: (extensionId: string) => void;
     extensionEnabled: (extensionId: string) => void;

src/main/Core/ExtensionManager/ExtensionManagerModule.ts

@@ -25,6 +25,11 @@ export class ExtensionManagerModule {
 
         await extensionManager.populateSearchIndex();
 
+        ipcMain.handle("resetCache", async () => {
+            await dependencyRegistry.get("FileImageGenerator").clearCache();
+            await extensionManager.populateSearchIndex();
+        });
+
         ipcMain.on("getExtensionTranslations", (event) => {
             event.returnValue = extensionManager.getSupportedExtensions().map((extension) => ({
                 extensionId: extension.id,

src/main/Core/FileSystemUtility/Contract/FileSystemUtility.ts

@@ -1,5 +1,6 @@
 export interface FileSystemUtility {
     createFolderIfDoesntExist(folderPath: string): Promise<void>;
+    clearFolder(folderPath: string): Promise<void>;
     pathExists(fileOrFolderPath: string): Promise<boolean>;
     readJsonFile<T>(filePath: string): Promise<T>;
     readJsonFileSync<T>(filePath: string): T;

src/main/Core/FileSystemUtility/NodeJsFileSystemUtility.ts

@@ -5,14 +5,21 @@ import {
     mkdir,
     readFile,
     readFileSync,
+    readdir,
     statSync,
     unlink,
     writeFile,
     writeFileSync,
 } from "fs";
+import { join } from "path";
 import type { FileSystemUtility } from "./Contract";
 
 export class NodeJsFileSystemUtility implements FileSystemUtility {
+    public async clearFolder(folderPath: string): Promise<void> {
+        const filePaths = await this.readDirectory(folderPath);
+        await Promise.all(filePaths.map((filePath) => this.removeFile(filePath)));
+    }
+
     public async createFolderIfDoesntExist(folderPath: string): Promise<void> {
         const exists = await this.pathExists(folderPath);
 
@@ -110,4 +117,16 @@ export class NodeJsFileSystemUtility implements FileSystemUtility {
     private readFileSync(filePath: string): Buffer {
         return readFileSync(filePath);
     }
+
+    private readDirectory(folderPath: string): Promise<string[]> {
+        return new Promise((resolve, reject) => {
+            readdir(folderPath, (error, fileNames) => {
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve(fileNames.map((fileName) => join(folderPath, fileName)));
+                }
+            });
+        });
+    }
 }

src/main/Core/ImageGenerator/Contract/FileImageGenerator.ts

@@ -2,4 +2,5 @@ import type { Image } from "@common/Core/Image";
 
 export interface FileImageGenerator {
     getImage(filePath: string): Promise<Image>;
+    clearCache: () => Promise<void>;
 }

src/main/Core/ImageGenerator/FileImageGenerator.test.ts

@@ -8,6 +8,32 @@ import { FileImageGenerator } from "./FileImageGenerator";
 describe(FileImageGenerator, () => {
     const cacheFolderPath = "cacheFolderPath";
 
+    it("should clear cache folder if it exists", async () => {
+        const pathExistsMock = vi.fn().mockReturnValue(true);
+        const clearFolderMock = vi.fn().mockReturnValue(Promise.resolve());
+
+        const fileSystemUtility = <FileSystemUtility>{
+            pathExists: (f) => pathExistsMock(f),
+            clearFolder: (f) => clearFolderMock(f),
+        };
+
+        const fileImageGenerator = new FileImageGenerator(cacheFolderPath, fileSystemUtility);
+
+        await fileImageGenerator.clearCache();
+        expect(pathExistsMock).toHaveBeenCalledWith(cacheFolderPath);
+        expect(clearFolderMock).toHaveBeenCalledWith(cacheFolderPath);
+    });
+
+    it("should do nothing if cache folder does not exist", async () => {
+        const pathExistsMock = vi.fn().mockReturnValue(false);
+        const fileSystemUtility = <FileSystemUtility>{ pathExists: (f) => pathExistsMock(f) };
+
+        const fileImageGenerator = new FileImageGenerator(cacheFolderPath, fileSystemUtility);
+
+        await fileImageGenerator.clearCache();
+        expect(pathExistsMock).toHaveBeenCalledWith(cacheFolderPath);
+    });
+
     it("should create the cached file if it doesn't exist and return the image", async () => {
         const pathExistsMock = vi.fn().mockReturnValue(false);
         const writePngMock = vi.fn().mockReturnValue(Promise.resolve());

src/main/Core/ImageGenerator/FileImageGenerator.ts

@@ -11,6 +11,14 @@ export class FileImageGenerator implements FileImageGeneratorInterface {
         private readonly fileSystemUtility: FileSystemUtility,
     ) {}
 
+    public async clearCache(): Promise<void> {
+        const exists = await this.fileSystemUtility.pathExists(this.cacheFolderPath);
+
+        if (exists) {
+            await this.fileSystemUtility.clearFolder(this.cacheFolderPath);
+        }
+    }
+
     public async getImage(filePath: string): Promise<Image> {
         const cachedPngFilePath = await this.ensureCachedPngFileExists(filePath);
 
@@ -23,7 +31,13 @@ export class FileImageGenerator implements FileImageGeneratorInterface {
         const exists = await this.fileSystemUtility.pathExists(cachedPngFilePath);
 
         if (!exists) {
-            await this.fileSystemUtility.writePng(getFileIcon(filePath), cachedPngFilePath);
+            const buffer = getFileIcon(filePath);
+
+            if (!buffer.byteLength) {
+                throw new Error(`getFileIcon returned Buffer with length 0`);
+            }
+
+            await this.fileSystemUtility.writePng(buffer, cachedPngFilePath);
         }
 
         return cachedPngFilePath;

src/main/Core/Logger/Logger.test.ts

@@ -1,3 +1,4 @@
+import type { BrowserWindowNotifier } from "@Core/BrowserWindowNotifier";
 import type { Clock } from "@Core/Clock/Clock";
 import { describe, expect, it, vi } from "vitest";
 import { Logger } from "./Logger";
@@ -7,45 +8,65 @@ describe(Logger, () => {
 
     it("should log an error", () => {
         const getCurrentTimeAsStringMock = vi.fn().mockReturnValue(nowAsString);
+        const notifyMock = vi.fn();
 
-        const logger = new Logger(<Clock>{ getCurrentTimeAsString: () => getCurrentTimeAsStringMock() });
+        const logger = new Logger(
+            <Clock>{ getCurrentTimeAsString: () => getCurrentTimeAsStringMock() },
+            <BrowserWindowNotifier>{ notify: (c) => notifyMock(c) },
+        );
 
         logger.error("This is an error");
 
         expect(logger.getLogs()).toEqual([`[${nowAsString}][ERROR] This is an error`]);
         expect(getCurrentTimeAsStringMock).toHaveBeenCalledOnce();
+        expect(notifyMock).toHaveBeenCalledWith("logsUpdated");
     });
 
     it("should log a debug message", () => {
         const getCurrentTimeAsStringMock = vi.fn().mockReturnValue(nowAsString);
+        const notifyMock = vi.fn();
 
-        const logger = new Logger(<Clock>{ getCurrentTimeAsString: () => getCurrentTimeAsStringMock() });
+        const logger = new Logger(
+            <Clock>{ getCurrentTimeAsString: () => getCurrentTimeAsStringMock() },
+            <BrowserWindowNotifier>{ notify: (c) => notifyMock(c) },
+        );
 
         logger.debug("This is a debug message");
 
         expect(logger.getLogs()).toEqual([`[${nowAsString}][DEBUG] This is a debug message`]);
         expect(getCurrentTimeAsStringMock).toHaveBeenCalledOnce();
+        expect(notifyMock).toHaveBeenCalledWith("logsUpdated");
     });
 
     it("should log a info message", () => {
         const getCurrentTimeAsStringMock = vi.fn().mockReturnValue(nowAsString);
+        const notifyMock = vi.fn();
 
-        const logger = new Logger(<Clock>{ getCurrentTimeAsString: () => getCurrentTimeAsStringMock() });
+        const logger = new Logger(
+            <Clock>{ getCurrentTimeAsString: () => getCurrentTimeAsStringMock() },
+            <BrowserWindowNotifier>{ notify: (c) => notifyMock(c) },
+        );
 
         logger.info("This is a info message");
 
         expect(logger.getLogs()).toEqual([`[${nowAsString}][INFO] This is a info message`]);
         expect(getCurrentTimeAsStringMock).toHaveBeenCalledOnce();
+        expect(notifyMock).toHaveBeenCalledWith("logsUpdated");
     });
 
     it("should log a warning", () => {
         const getCurrentTimeAsStringMock = vi.fn().mockReturnValue(nowAsString);
+        const notifyMock = vi.fn();
 
-        const logger = new Logger(<Clock>{ getCurrentTimeAsString: () => getCurrentTimeAsStringMock() });
+        const logger = new Logger(
+            <Clock>{ getCurrentTimeAsString: () => getCurrentTimeAsStringMock() },
+            <BrowserWindowNotifier>{ notify: (c) => notifyMock(c) },
+        );
 
         logger.warn("This is a warning");
 
         expect(logger.getLogs()).toEqual([`[${nowAsString}][WARNING] This is a warning`]);
         expect(getCurrentTimeAsStringMock).toHaveBeenCalledOnce();
+        expect(notifyMock).toHaveBeenCalledWith("logsUpdated");
     });
 });

src/main/Core/Logger/Logger.ts

@@ -1,10 +1,14 @@
+import type { BrowserWindowNotifier } from "@Core/BrowserWindowNotifier";
 import type { Clock } from "../Clock";
 import type { Logger as LoggerInterface } from "./Contract";
 
 export class Logger implements LoggerInterface {
     private logs: string[] = [];
 
-    public constructor(private readonly clock: Clock) {}
+    public constructor(
+        private readonly clock: Clock,
+        private readonly browserWindowNotifier: BrowserWindowNotifier,
+    ) {}
 
     public error(message: string): void {
         this.writeLog("ERROR", message);
@@ -28,5 +32,6 @@ export class Logger implements LoggerInterface {
 
     private writeLog(logLevel: string, message: string) {
         this.logs.push(`[${this.clock.getCurrentTimeAsString()}][${logLevel}] ${message}`);
+        this.browserWindowNotifier.notify("logsUpdated");
     }
 }

src/main/Core/Logger/LoggerModule.ts

@@ -5,9 +5,8 @@ import { Logger } from "./Logger";
 export class LoggerModule {
     public static bootstrap(dependencyRegistry: DependencyRegistry<Dependencies>) {
         const ipcMain = dependencyRegistry.get("IpcMain");
-        const clock = dependencyRegistry.get("Clock");
 
-        const logger = new Logger(clock);
+        const logger = new Logger(dependencyRegistry.get("Clock"), dependencyRegistry.get("BrowserWindowNotifier"));
 
         dependencyRegistry.register("Logger", logger);
         ipcMain.on("getLogs", (event) => (event.returnValue = logger.getLogs()));

src/main/Extensions/ApplicationSearch/ApplicationSearch.ts

@@ -21,7 +21,7 @@ export class ApplicationSearch implements Extension {
     };
 
     public constructor(
-        private readonly currentOperatingSystem: OperatingSystem,
+        private readonly operatingSystem: OperatingSystem,
         private readonly applicationRepository: ApplicationRepository,
         private readonly settings: Settings,
         private readonly assetPathResolver: AssetPathResolver,
@@ -34,7 +34,7 @@ export class ApplicationSearch implements Extension {
 
     public isSupported(): boolean {
         const supportedOperatingSystems: OperatingSystem[] = ["Windows", "macOS"];
-        return supportedOperatingSystems.includes(this.currentOperatingSystem);
+        return supportedOperatingSystems.includes(this.operatingSystem);
     }
 
     public getSettingDefaultValue<T>(key: string): T {
@@ -51,8 +51,14 @@ export class ApplicationSearch implements Extension {
     }
 
     public getImage(): Image {
+        const fileNames: Record<OperatingSystem, string> = {
+            Linux: null, // not supported,
+            macOS: "macos-applications.png",
+            Windows: "windows-applications.png",
+        };
+
         return {
-            url: `file://${this.assetPathResolver.getExtensionAssetPath(this.id, "macos-applications.png")}`,
+            url: `file://${this.assetPathResolver.getExtensionAssetPath(this.id, fileNames[this.operatingSystem])}`,
         };
     }
 

src/main/Extensions/ApplicationSearch/ApplicationSearchModule.ts

@@ -23,12 +23,14 @@ export class ApplicationSearchModule implements ExtensionModule {
                 dependencyRegistry.get("FileImageGenerator"),
                 dependencyRegistry.get("Logger"),
                 settings,
+                dependencyRegistry.get("AssetPathResolver"),
             ),
             Windows: new WindowsApplicationRepository(
                 dependencyRegistry.get("PowershellUtility"),
                 settings,
                 dependencyRegistry.get("FileImageGenerator"),
                 dependencyRegistry.get("Logger"),
+                dependencyRegistry.get("AssetPathResolver"),
             ),
             Linux: undefined, // not supported
         };

src/main/Extensions/ApplicationSearch/Windows/WindowsApplicationRepository.ts

@@ -1,3 +1,4 @@
+import type { AssetPathResolver } from "@Core/AssetPathResolver";
 import type { FileImageGenerator } from "@Core/ImageGenerator";
 import type { Logger } from "@Core/Logger";
 import type { PowershellUtility } from "@Core/PowershellUtility";
@@ -15,6 +16,7 @@ export class WindowsApplicationRepository implements ApplicationRepository {
         private readonly settings: Settings,
         private readonly fileImageGenerator: FileImageGenerator,
         private readonly logger: Logger,
+        private readonly assetPathResolver: AssetPathResolver,
     ) {}
 
     public async getApplications(): Promise<Application[]> {
@@ -40,7 +42,14 @@ export class WindowsApplicationRepository implements ApplicationRepository {
         const appIcons = await this.getAppIcons(windowsApplicationRetrieverResults.map(({ FullName }) => FullName));
 
         return windowsApplicationRetrieverResults.map(
-            ({ BaseName, FullName }) => new Application(BaseName, FullName, appIcons[FullName]),
+            ({ BaseName, FullName }) =>
+                new Application(
+                    BaseName,
+                    FullName,
+                    appIcons[FullName] ?? {
+                        url: `file://${this.assetPathResolver.getExtensionAssetPath("ApplicationSearch", "windows-generic-app-icon.png")}`,
+                    },
+                ),
         );
     }
 

src/main/Extensions/ApplicationSearch/macOS/MacOsApplicationRepository.ts

@@ -1,3 +1,4 @@
+import type { AssetPathResolver } from "@Core/AssetPathResolver";
 import type { CommandlineUtility } from "@Core/CommandlineUtility";
 import type { FileImageGenerator } from "@Core/ImageGenerator";
 import type { Logger } from "@Core/Logger";
@@ -13,6 +14,7 @@ export class MacOsApplicationRepository implements ApplicationRepository {
         private readonly fileImageGenerator: FileImageGenerator,
         private readonly logger: Logger,
         private readonly settings: Settings,
+        private readonly assetPathResolver: AssetPathResolver,
     ) {}
 
     public async getApplications(): Promise<Application[]> {
@@ -21,7 +23,16 @@ export class MacOsApplicationRepository implements ApplicationRepository {
 
         return filePaths
             .filter((filePath) => !!icons[filePath])
-            .map((filePath) => new Application(parse(filePath).name, filePath, icons[filePath]));
+            .map(
+                (filePath) =>
+                    new Application(
+                        parse(filePath).name,
+                        filePath,
+                        icons[filePath] ?? {
+                            url: `file://${this.assetPathResolver.getExtensionAssetPath("ApplicationSearch", "macos-generic-app-icon.png")}`,
+                        },
+                    ),
+            );
     }
 
     private async getAllFilePaths(): Promise<string[]> {

src/main/index.ts

@@ -26,17 +26,17 @@ import * as Extensions from "./Extensions";
     dependencyRegistry.register("SafeStorage", Electron.safeStorage);
 
     // Core Modules
+    Core.EventEmitterModule.bootstrap(dependencyRegistry);
+    Core.EventSubscriberModule.bootstrap(dependencyRegistry);
     Core.RandomStringProviderModule.bootstrap(dependencyRegistry);
     Core.SafeStorageEncryptionModule.bootstrap(dependencyRegistry);
     Core.AssetPathResolverModule.bootstrap(dependencyRegistry);
     Core.ShellModule.bootstrap(dependencyRegistry);
     Core.ClipboardModule.bootstrap(dependencyRegistry);
     Core.ClockModule.bootstrap(dependencyRegistry);
     Core.AboutUeliModule.bootstrap(dependencyRegistry);
-    Core.LoggerModule.bootstrap(dependencyRegistry);
-    Core.EventEmitterModule.bootstrap(dependencyRegistry);
-    Core.EventSubscriberModule.bootstrap(dependencyRegistry);
     Core.BrowserWindowNotifierModule.bootstrap(dependencyRegistry);
+    Core.LoggerModule.bootstrap(dependencyRegistry);
     Core.CommandlineUtilityModule.bootstrap(dependencyRegistry);
     Core.FileSystemUtilityModule.bootstrap(dependencyRegistry);
     await Core.PowershellUtilityModule.bootstrap(dependencyRegistry);

src/preload/index.ts

@@ -6,6 +6,7 @@ const contextBridgeImplementation: ContextBridge = {
         on: (channel, listener) => ipcRenderer.on(channel, listener),
     },
 
+    resetChache: () => ipcRenderer.invoke("resetCache"),
     copyTextToClipboard: (textToCopy) => ipcRenderer.send("copyTextToClipboard", { textToCopy }),
     extensionDisabled: (extensionId) => ipcRenderer.send("extensionDisabled", { extensionId }),
     extensionEnabled: (extensionId) => ipcRenderer.send("extensionEnabled", { extensionId }),