Function loadJsonFile

packages/shared/src/utils.ts:18–75

(
    filePath: string,
    schema: any
)

// TODO: Merge this with config loading logic which uses AJV
export const loadJsonFile = async <T>(
    filePath: string,
    schema: any
): Promise<T> => {
    const fileContent = await (async () => {
        if (isRemotePath(filePath)) {
            const response = await fetch(filePath);
            if (!response.ok) {
                throw new Error(`Failed to fetch file ${filePath}: ${response.statusText}`);
            }
            return response.text();
        } else {
            // Retry logic for handling race conditions with mounted volumes
            const maxAttempts = 5;
            const retryDelayMs = 2000;
            let lastError: Error | null = null;

            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
                try {
                    return await readFile(filePath, {
                        encoding: 'utf-8',
                    });
                } catch (error) {
                    lastError = error as Error;
                    
                    // Only retry on ENOENT errors (file not found)
                    if ((error as NodeJS.ErrnoException)?.code !== 'ENOENT') {
                        throw error; // Throw immediately for non-ENOENT errors
                    }
                    
                    // Log warning before retry (except on the last attempt)
                    if (attempt < maxAttempts) {
                        console.warn(`File not found, retrying in 2s... (Attempt ${attempt}/${maxAttempts})`);
                        await new Promise(resolve => setTimeout(resolve, retryDelayMs));
                    }
                }
            }
            
            // If we've exhausted all retries, throw the last ENOENT error
            if (lastError) {
                throw lastError;
            }
            
            throw new Error('Failed to load file after all retry attempts');
        }
    })();

    const parsedData = JSON.parse(stripJsonComments(fileContent));
    
    try {
        return schema.parse(parsedData);
    } catch (error) {
        if (error instanceof z.ZodError) {
            throw new Error(`File '${filePath}' is invalid: ${error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`);
        }
        throw error;
    }
}