@scality/data-browser-library 1.0.0-preview.9 → 1.0.3

package/dist/config/__tests__/factory.test.js

@@ -0,0 +1,311 @@
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+import { loadRuntimeConfig, s3RuntimeConfigSchema } from "../factory.js";
+const server = setupServer();
+const CONFIG_URL = 'http://localhost/config.json';
+describe('loadRuntimeConfig', ()=>{
+    beforeAll(()=>server.listen({
+            onUnhandledRequest: 'error'
+        }));
+    afterEach(()=>server.resetHandlers());
+    afterAll(()=>server.close());
+    describe('Successful configuration loading', ()=>{
+        it('should load and return valid runtime configuration', async ()=>{
+            const mockConfig = {
+                s3: {
+                    endpoint: 'https://s3.us-west-2.amazonaws.com',
+                    region: 'us-west-2',
+                    forcePathStyle: true
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config).toEqual(mockConfig);
+            expect(config.s3.endpoint).toBe('https://s3.us-west-2.amazonaws.com');
+            expect(config.s3.region).toBe('us-west-2');
+            expect(config.s3.forcePathStyle).toBe(true);
+        });
+        it('should support generic type for extended configuration', async ()=>{
+            const mockConfig = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com',
+                    region: 'us-east-1'
+                },
+                basePath: '/app',
+                theme: 'dark',
+                customSettings: {
+                    feature1: true,
+                    feature2: 42
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.basePath).toBe('/app');
+            expect(config.theme).toBe('dark');
+            expect(config.customSettings).toEqual({
+                feature1: true,
+                feature2: 42
+            });
+        });
+        it('should replace "origin" endpoint with window.location.origin', async ()=>{
+            const mockConfig = {
+                s3: {
+                    endpoint: 'origin',
+                    region: 'us-east-1'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.s3.endpoint).not.toBe('origin');
+            expect(config.s3.endpoint).toBe(window.location.origin);
+            expect(config.s3.endpoint).toMatch(/^http/);
+        });
+        it('should handle configuration without optional forcePathStyle', async ()=>{
+            const mockConfig = {
+                s3: {
+                    endpoint: 'https://s3.ap-northeast-1.amazonaws.com',
+                    region: 'ap-northeast-1'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.s3.forcePathStyle).toBeUndefined();
+            expect(config.s3.endpoint).toBe('https://s3.ap-northeast-1.amazonaws.com');
+        });
+        it('should handle configuration without endpoint', async ()=>{
+            const mockConfig = {
+                s3: {
+                    region: 'us-east-1'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.s3.endpoint).toBeUndefined();
+            expect(config.s3.region).toBe('us-east-1');
+        });
+    });
+    describe('HTTP errors', ()=>{
+        it("should throw descriptive error when fetch returns 404", async ()=>{
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(null, {
+                    status: 404
+                })));
+            await expect(loadRuntimeConfig(CONFIG_URL)).rejects.toThrow('Failed to load config: Not Found');
+        });
+        it("should throw descriptive error when fetch returns 500", async ()=>{
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(null, {
+                    status: 500
+                })));
+            await expect(loadRuntimeConfig(CONFIG_URL)).rejects.toThrow('Failed to load config: Internal Server Error');
+        });
+        it('should throw error when fetch returns 403', async ()=>{
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(null, {
+                    status: 403
+                })));
+            await expect(loadRuntimeConfig(CONFIG_URL)).rejects.toThrow('Failed to load config: Forbidden');
+        });
+        it('should throw error when response is network error', async ()=>{
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.error()));
+            await expect(loadRuntimeConfig(CONFIG_URL)).rejects.toThrow();
+        });
+    });
+    describe('Validation errors', ()=>{
+        it('should reject config missing required s3.region field', async ()=>{
+            const invalidConfig = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(invalidConfig)));
+            const error = await loadRuntimeConfig(CONFIG_URL).catch((e)=>e);
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toContain('Invalid config');
+            expect(error.message).toContain('region');
+        });
+        it('should reject config completely missing s3 section', async ()=>{
+            const invalidConfig = {
+                someOtherField: 'value',
+                anotherField: 123
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(invalidConfig)));
+            const error = await loadRuntimeConfig(CONFIG_URL).catch((e)=>e);
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toContain('Invalid config');
+            expect(error.message).toContain('s3');
+        });
+        it('should reject config with invalid region type', async ()=>{
+            const invalidConfig = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com',
+                    region: 123
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(invalidConfig)));
+            const error = await loadRuntimeConfig(CONFIG_URL).catch((e)=>e);
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toContain('Invalid config');
+        });
+        it('should reject config with invalid forcePathStyle type', async ()=>{
+            const invalidConfig = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com',
+                    region: 'us-east-1',
+                    forcePathStyle: 'yes'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(invalidConfig)));
+            const error = await loadRuntimeConfig(CONFIG_URL).catch((e)=>e);
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toContain('Invalid config');
+        });
+    });
+    describe('Edge cases', ()=>{
+        it('should handle empty s3 object with only region', async ()=>{
+            const mockConfig = {
+                s3: {
+                    region: 'eu-west-1'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.s3.region).toBe('eu-west-1');
+            expect(config.s3.endpoint).toBeUndefined();
+            expect(config.s3.forcePathStyle).toBeUndefined();
+        });
+        it('should preserve all unknown fields for extended configs', async ()=>{
+            const mockConfig = {
+                s3: {
+                    region: 'us-east-1'
+                },
+                customField1: 'value1',
+                customField2: 42,
+                nested: {
+                    field: true
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.customField1).toBe('value1');
+            expect(config.customField2).toBe(42);
+            expect(config.nested).toEqual({
+                field: true
+            });
+        });
+        it('should not modify original endpoint when not "origin"', async ()=>{
+            const originalEndpoint = 'https://custom-s3.example.com:9000';
+            const mockConfig = {
+                s3: {
+                    endpoint: originalEndpoint,
+                    region: 'us-east-1'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.s3.endpoint).toBe(originalEndpoint);
+        });
+    });
+});
+describe('s3RuntimeConfigSchema', ()=>{
+    describe('Valid configurations', ()=>{
+        it('should validate complete configuration with all fields', ()=>{
+            const config = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com',
+                    region: 'us-east-1',
+                    forcePathStyle: true
+                }
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config);
+            expect(error).toBeUndefined();
+        });
+        it('should validate minimal configuration with only required fields', ()=>{
+            const config = {
+                s3: {
+                    region: 'eu-west-1'
+                }
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config);
+            expect(error).toBeUndefined();
+        });
+        it('should allow unknown fields when allowUnknown is true', ()=>{
+            const config = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com',
+                    region: 'us-east-1'
+                },
+                customField: 'value',
+                anotherField: 123
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config, {
+                allowUnknown: true
+            });
+            expect(error).toBeUndefined();
+        });
+    });
+    describe('Invalid configurations', ()=>{
+        it('should reject config without s3.region', ()=>{
+            const config = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com'
+                }
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config);
+            expect(error).toBeDefined();
+            expect(error?.details[0].path).toContain('region');
+            expect(error?.message).toContain('region');
+        });
+        it('should reject config without s3 object', ()=>{
+            const config = {};
+            const { error } = s3RuntimeConfigSchema.validate(config);
+            expect(error).toBeDefined();
+            expect(error?.details[0].path).toContain('s3');
+        });
+        it('should reject config with wrong type for region', ()=>{
+            const config = {
+                s3: {
+                    region: 123
+                }
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config);
+            expect(error).toBeDefined();
+            expect(error?.message).toContain('string');
+        });
+        it('should reject config with wrong type for forcePathStyle', ()=>{
+            const config = {
+                s3: {
+                    region: 'us-east-1',
+                    forcePathStyle: 'not-a-boolean'
+                }
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config, {
+                convert: false
+            });
+            expect(error).toBeDefined();
+            expect(error?.message).toContain('boolean');
+        });
+    });
+    describe('Schema behavior', ()=>{
+        it('should return all validation errors when abortEarly is false', ()=>{
+            const config = {
+                s3: {}
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config, {
+                abortEarly: false
+            });
+            expect(error).toBeDefined();
+            expect(error?.details.length).toBeGreaterThanOrEqual(1);
+        });
+        it('should preserve unknown fields when stripUnknown is false', ()=>{
+            const config = {
+                s3: {
+                    region: 'us-east-1'
+                },
+                customField: 'should-be-kept'
+            };
+            const { value } = s3RuntimeConfigSchema.validate(config, {
+                allowUnknown: true,
+                stripUnknown: false
+            });
+            expect(value.customField).toBe('should-be-kept');
+        });
+    });
+});

package/dist/config/factory.d.ts

@@ -1,63 +1,17 @@
-import type { S3ClientConfiguration } from "./types";
-import type { S3BrowserConfig, S3Credentials } from "../types";
-import { CoreUIThemeName } from "@scality/core-ui/dist/style/theme";
-interface RuntimeConfig {
+import Joi from 'joi';
+export type S3RuntimeConfig = {
     s3: {
         endpoint?: string;
         region: string;
         forcePathStyle?: boolean;
     };
-    theme?: CoreUIThemeName;
-    basePath?: string;
-}
-/**
- * Configuration factory that uses build-time constants
- * No runtime environment detection or hardcoded values
- */
-export declare class S3ConfigurationFactory {
-    /**
-     * Load runtime configuration from config.json
-     * Should be called at app startup
-     */
-    static loadRuntimeConfig(configUrl: string): Promise<RuntimeConfig | null>;
-    private static getBuildTimeConfig;
-    /**
-     * Create S3 client configuration based on build-time settings
-     */
-    static createClientConfiguration(credentials: S3Credentials): S3BrowserConfig & {
-        credentials: S3Credentials;
-    };
-    /**
-     * Create proxy middleware configuration
-     */
-    static createProxyConfiguration(): S3ClientConfiguration;
-    /**
-     * Check if proxy middleware should be enabled
-     */
-    static shouldUseProxyMiddleware(): boolean;
-    /**
-     * Get build-time environment info for debugging
-     */
-    static getBuildInfo(): {
-        environment: string;
-        useProxy: boolean;
-        s3Endpoint: string;
-        proxyEndpoint: string | undefined;
-    };
-}
+};
+export declare const s3RuntimeConfigSchema: Joi.ObjectSchema<any>;
 /**
- * Convenience functions for common use cases
+ * Load runtime configuration from config.json
+ *
+ * @template T - Extended runtime config type that must include S3RuntimeConfig
+ * @param configUrl - URL to fetch the config.json from
+ * @returns Promise resolving to the loaded config
  */
-export declare const createS3Config: (credentials: S3Credentials) => S3BrowserConfig & {
-    credentials: S3Credentials;
-};
-export declare const shouldUseProxy: () => boolean;
-export declare const getProxyConfig: () => S3ClientConfiguration;
-export declare const getBuildInfo: () => {
-    environment: string;
-    useProxy: boolean;
-    s3Endpoint: string;
-    proxyEndpoint: string | undefined;
-};
-export declare const loadRuntimeConfig: (configUrl: string) => Promise<RuntimeConfig | null>;
-export {};
+export declare function loadRuntimeConfig<T extends S3RuntimeConfig = S3RuntimeConfig>(configUrl: string): Promise<T>;

package/dist/config/factory.js

@@ -1,73 +1,25 @@
-let runtimeConfig = null;
-class S3ConfigurationFactory {
-    static async loadRuntimeConfig(configUrl) {
-        try {
-            const response = await fetch(configUrl);
-            if (response.ok) {
-                const data = await response.json();
-                runtimeConfig = data;
-                console.log("Loaded runtime configuration:", runtimeConfig);
-                return data;
-            }
-            return null;
-        } catch (error) {
-            console.warn("Could not load runtime config, using build-time config:", error);
-            return null;
-        }
-    }
-    static getBuildTimeConfig() {
-        return {
-            s3: __S3_CONFIG__,
-            dev: __DEV_CONFIG__,
-            isDevelopment: __IS_DEVELOPMENT__,
-            isProduction: __IS_PRODUCTION__
-        };
-    }
-    static createClientConfiguration(credentials) {
-        const buildConfig = this.getBuildTimeConfig();
-        const s3Config = buildConfig.isProduction && runtimeConfig?.s3 ? runtimeConfig.s3 : buildConfig.s3;
-        const baseConfig = {
-            credentials,
-            region: s3Config.region,
-            forcePathStyle: s3Config.forcePathStyle ?? true,
-            endpoint: s3Config.endpoint
-        };
-        if (buildConfig.isDevelopment && buildConfig.dev.useProxy && buildConfig.dev.proxyEndpoint) baseConfig.endpoint = buildConfig.dev.proxyEndpoint;
-        return baseConfig;
-    }
-    static createProxyConfiguration() {
-        const buildConfig = this.getBuildTimeConfig();
-        const config = {
-            endpoint: buildConfig.s3.endpoint,
-            region: buildConfig.s3.region,
-            forcePathStyle: buildConfig.s3.forcePathStyle,
-            useProxy: buildConfig.isDevelopment && buildConfig.dev.useProxy
-        };
-        if (config.useProxy) config.proxyConfig = {
-            realHost: buildConfig.s3.realHost,
-            proxyBasePath: buildConfig.dev.proxyBasePath,
-            proxyHost: buildConfig.dev.proxyHost,
-            proxyPort: buildConfig.dev.proxyPort
-        };
-        return config;
-    }
-    static shouldUseProxyMiddleware() {
-        const buildConfig = this.getBuildTimeConfig();
-        return buildConfig.isDevelopment && buildConfig.dev.useProxy;
-    }
-    static getBuildInfo() {
-        const buildConfig = this.getBuildTimeConfig();
-        return {
-            environment: buildConfig.isDevelopment ? "development" : "production",
-            useProxy: buildConfig.dev.useProxy,
-            s3Endpoint: buildConfig.s3.endpoint,
-            proxyEndpoint: buildConfig.dev.proxyEndpoint
-        };
+import joi from "joi";
+const s3RuntimeConfigSchema = joi.object({
+    s3: joi.object({
+        endpoint: joi.string().optional().allow('origin'),
+        region: joi.string().min(1).required(),
+        forcePathStyle: joi.boolean().optional()
+    }).required()
+});
+async function loadRuntimeConfig(configUrl) {
+    const response = await fetch(configUrl);
+    if (!response.ok) throw new Error(`Failed to load config: ${response.statusText} (${response.status})`);
+    const data = await response.json();
+    const { error } = s3RuntimeConfigSchema.validate(data, {
+        allowUnknown: true,
+        abortEarly: false
+    });
+    if (error) {
+        const messages = error.details.map((d)=>d.message).join('; ');
+        throw new Error(`Invalid config: ${messages}`);
     }
+    if (data.s3?.endpoint === 'origin') if ('undefined' != typeof window && window.location?.origin) data.s3.endpoint = window.location.origin;
+    else throw new Error('Cannot use "origin" keyword outside browser');
+    return data;
 }
-const createS3Config = (credentials)=>S3ConfigurationFactory.createClientConfiguration(credentials);
-const shouldUseProxy = ()=>S3ConfigurationFactory.shouldUseProxyMiddleware();
-const getProxyConfig = ()=>S3ConfigurationFactory.createProxyConfiguration();
-const getBuildInfo = ()=>S3ConfigurationFactory.getBuildInfo();
-const loadRuntimeConfig = (configUrl)=>S3ConfigurationFactory.loadRuntimeConfig(configUrl);
-export { S3ConfigurationFactory, createS3Config, getBuildInfo, getProxyConfig, loadRuntimeConfig, shouldUseProxy };
+export { loadRuntimeConfig, s3RuntimeConfigSchema };