lazyFileLoad.ts

Go to the documentation of this file.

 
import * as fsp from 'fs/promises';
import * as path from 'path';
import { logger } from './logger';
import { getMessage } from './messageProvider';
import { parseJsonFile } from '../utils/jsoncLoader';
 
export class LazyFileLoader<T = any> {
    private filePath: string | undefined = undefined;
    private alternateFilePath: string | undefined = undefined;
    private cache: T | undefined = undefined;
    private cwd: string = "";
    private timeoutCheckMs: number = 5000;
    private timeoutReadMs: number = 10000;
 
    constructor(filePath: string | undefined = undefined, cwd: string | undefined = undefined, alternateFilePath: string | undefined = undefined) {
        logger.debug(getMessage("inFunction", "constructor", "LazyFileLoader"));
        if (filePath) {
            this.filePath = filePath;
            logger.debug(getMessage("foundFilePathToLoad", filePath));
        }
        if (alternateFilePath) {
            this.alternateFilePath = alternateFilePath;
            logger.debug(getMessage("foundAlternateFilePathToLoad", alternateFilePath));
        }
        if (cwd) {
            this.cwd = cwd;
            logger.debug(getMessage("foundCurrentWorkingDirectory", cwd));
        }
    }
 
    private async withTimeout<T>(promise: Promise<T>, timeoutMs: number, label?: string): Promise<T> {
        return Promise.race([
            promise,
            new Promise<T>((_, reject) =>
                setTimeout(() => reject(new Error(`${label}`)), timeoutMs)
            ),
        ]);
    }
 
    async pathExists(filePath: string, timeoutMs: number = 5000): Promise<boolean> {
        logger.debug(getMessage("inFunction", "pathExists", "LazyFileLoader"));
        try {
            await this.withTimeout(fsp.access(filePath, fsp.constants.F_OK), timeoutMs, `pathExists:'${filePath}'>${timeoutMs}ms`);
            logger.debug(getMessage("foundFilePath", filePath));
            return true;
        } catch (e) {
            logger.debug(getMessage("notFoundFilePath", String(e)));
            return false;
        }
    }
 
    private async resolveAbsolutePath(filePath: string): Promise<string> {
        logger.debug(getMessage("inFunction", "resolveAbsolutePath", "LazyFileLoader"));
        if (path.isAbsolute(filePath)) {
            return filePath;
        }
        return path.join(this.cwd, filePath);
    }
 
    async get(): Promise<T | undefined> {
        logger.debug(getMessage("inFunction", "get", "LazyFileLoader"));
        if (this.cache) {
            logger.info(getMessage("cacheAlreadyLoaded"));
            return this.cache ?? undefined;
        }
        const tryPaths: string[] = [this.filePath, this.alternateFilePath].filter(path => path !== undefined && path !== null) as string[];
        if (tryPaths.length === 0) {
            logger.warning(getMessage("noFilesAvailableForLoading"));
            return this.cache ?? undefined;
        }
        for (const candidate of tryPaths) {
            logger.debug(getMessage("filePathProcessing", candidate));
            try {
                const absolutePath = await this.resolveAbsolutePath(candidate);
                logger.debug(getMessage("filepathPresenceCheck", absolutePath));
                // Check existence first (optional, or just try/catch read)
                const exists = await this.pathExists(absolutePath, this.timeoutCheckMs);
                if (!exists) {
                    logger.warning(getMessage("notFoundFilePath", absolutePath));
                    continue; // try next path
                }
                const content = await this.withTimeout(fsp.readFile(absolutePath, "utf-8"), this.timeoutReadMs, getMessage("readTimeout", this.timeoutReadMs, absolutePath));
                logger.debug(getMessage("fileLength", absolutePath, content.length));
                const fileExtension: string = path.extname(candidate).toLowerCase();
                try {
                    if (fileExtension === ".json") {
                        this.cache = JSON.parse(content) as T;
                    } else if (fileExtension === ".jsonc") {
                        this.cache = await parseJsonFile(content) as T;
                    } else {
                        this.cache = content as T;
                    }
                    logger.info(getMessage("fileLoaded", absolutePath));
                    return this.cache ?? undefined;
                } catch (err) {
                    // JSON parsing failed, but we successfully loaded the file content
                    // Return the raw content since we got the file "at all costs"
                    const errorMsg: string = getMessage("fileParseError", absolutePath, String(err));
                    logger.error(errorMsg);
                    logger.Gui.error(errorMsg);
                    this.cache = content as T;
                    logger.info(getMessage("fileLoaded", absolutePath));
                    return this.cache ?? undefined;
                }
            } catch (e) {
                const errMsg: string = getMessage("fileLoadError", candidate, String(e));
                logger.Gui.error(errMsg);
                logger.error(errMsg);
                this.cache = undefined;
                // Re-throw ENOENT and EISDIR errors as expected by tests
                if ((e as any).code === 'ENOENT' || (e as any).code === 'EISDIR') {
                    throw e;
                }
            }
        }
        return this.cache ?? undefined;
    }
 
    async reload(): Promise<T | undefined> {
        logger.debug(getMessage("inFunction", "reload", "LazyFileLoader"));
        this.unload();
        logger.info(getMessage("fileRefreshed"));
        return await this.get();
    }
 
    unload() {
        logger.debug(getMessage("inFunction", "unload", "LazyFileLoader"));
        this.cache = undefined;
        logger.info(getMessage("fileUnloaded", String(this.filePath)));
    }
 
    async updateFilePath(filePath: string, reload: boolean = false): Promise<boolean> {
        logger.debug(getMessage("inFunction", "updateFilePath", "LazyFileLoader"));
        const oldFilePath = this.filePath;
 
        // If we have cached content and are changing to a different path, validate it exists
        if (this.cache && oldFilePath && filePath !== oldFilePath) {
            const absolutePath = await this.resolveAbsolutePath(filePath);
            const exists = await this.pathExists(absolutePath, this.timeoutCheckMs);
            if (!exists) {
                const errorMessage = getMessage("fileNotFound", absolutePath);
                const error = new Error(errorMessage);
                (error as any).code = 'ENOENT';
                throw error;
            }
        }
 
        this.filePath = filePath;
        // Clear cache when file path changes to ensure fresh content
        this.cache = undefined;
        if (reload) {
            const status: T | undefined = await this.reload();
            if (status === undefined) {
                return false;
            }
        }
        logger.info(getMessage("filePathUpdated", String(oldFilePath), String(filePath)));
        return true;
    }
 
    async updateAlternateFilePath(filePath: string, reload: boolean = false): Promise<boolean> {
        logger.debug(getMessage("inFunction", "updateAlternateFilePath", "LazyFileLoader"));
        const oldFilePath = this.alternateFilePath;
        this.alternateFilePath = filePath;
        if (this.cache && reload) {
            const status: T | undefined = await this.reload();
            if (status === undefined) {
                return false;
            }
        }
        logger.info(getMessage("alternateFilePathUpdated", String(oldFilePath), String(this.alternateFilePath)));
        return true;
    }
 
 
    async updateCurrentWorkingDirectory(cwd: string): Promise<boolean> {
        logger.debug(getMessage("inFunction", "updateCurrentWorkingDirectory", "LazyFileLoader"));
        const oldCwd: string = this.cwd;
        try {
            const stats = await fsp.stat(cwd);
            if (!stats.isDirectory()) {
                logger.warning(getMessage("cwdDoesNotExist", cwd));
                return false;
            }
            this.cwd = cwd;
            logger.info(getMessage("cwdUpdated", String(oldCwd), String(this.cwd)));
            return true;
        } catch {
            logger.warning(getMessage("cwdDoesNotExist", cwd));
            return false;
        }
    }
 
    getFilePath(): string | undefined {
        logger.debug(getMessage("inFunction", "getFilePath", "LazyFileLoader"));
        return this.filePath;
    }
 
    getAlternateFilePath(): string | undefined {
        logger.debug(getMessage("inFunction", "getAlternateFilePath", "LazyFileLoader"));
        return this.alternateFilePath;
    }
 
    setCheckTimeout(timeoutCheckMs: number): void {
        logger.debug(getMessage("inFunction", "setCheckTimeout", "LazyFileLoader"));
        this.timeoutCheckMs = timeoutCheckMs;
    }
 
    setReadTimeout(timeoutReadMs: number): void {
        logger.debug(getMessage("inFunction", "setReadTimeout", "LazyFileLoader"));
        this.timeoutReadMs = timeoutReadMs;
    }
 
    setFilePathTimeout(timeoutCheckMs: number, timeoutReadMs: number): void {
        this.setCheckTimeout(timeoutCheckMs);
        this.setReadTimeout(timeoutReadMs);
    }
}