@scality/data-browser-library 1.0.0-preview.16 → 1.0.0-preview.17

package/dist/components/__tests__/BucketDetails.test.js

@@ -6,7 +6,7 @@ import { applyBucketMocks, createTestWrapper } from "../../test/testUtils.js";
 import { useGetBucketAcl, useGetBucketCors, useGetBucketLifecycle, useGetBucketLocation, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning } from "../../hooks/index.js";
 import { useISVBucketStatus } from "../../hooks/useISVBucketDetection.js";
 import { useFeatures } from "../../hooks/useFeatures.js";
-import * as __WEBPACK_EXTERNAL_MODULE__contexts_DataBrowserUICustomizationContext_js_f267b01c__ from "../../contexts/DataBrowserUICustomizationContext.js";
+import * as __rspack_external__contexts_DataBrowserUICustomizationContext_js_f267b01c from "../../contexts/DataBrowserUICustomizationContext.js";
 jest.mock('../../hooks');
 jest.mock('../../hooks/useISVBucketDetection');
 jest.mock('../../hooks/useFeatures');
@@ -29,7 +29,7 @@ const mockUseGetBucketTagging = jest.mocked(useGetBucketTagging);
 const mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
 const mockUseFeatures = jest.mocked(useFeatures);
 const mockUseDataBrowserUICustomization = (config = {})=>{
-    jest.spyOn(__WEBPACK_EXTERNAL_MODULE__contexts_DataBrowserUICustomizationContext_js_f267b01c__, 'useDataBrowserUICustomization').mockReturnValue(config);
+    jest.spyOn(__rspack_external__contexts_DataBrowserUICustomizationContext_js_f267b01c, 'useDataBrowserUICustomization').mockReturnValue(config);
 };
 const renderBucketDetails = ()=>{
     const Wrapper = createTestWrapper();

package/dist/components/__tests__/BucketList.test.js

@@ -3,9 +3,9 @@ import { fireEvent, render, screen } from "@testing-library/react";
 import { MemoryRouter } from "react-router";
 import { createTestWrapper, mockOffsetSize } from "../../test/testUtils.js";
 import { BucketList } from "../buckets/BucketList.js";
-import * as __WEBPACK_EXTERNAL_MODULE__contexts_DataBrowserUICustomizationContext_js_f267b01c__ from "../../contexts/DataBrowserUICustomizationContext.js";
+import * as __rspack_external__contexts_DataBrowserUICustomizationContext_js_f267b01c from "../../contexts/DataBrowserUICustomizationContext.js";
 const mockUseDataBrowserUICustomization = (config = {})=>{
-    jest.spyOn(__WEBPACK_EXTERNAL_MODULE__contexts_DataBrowserUICustomizationContext_js_f267b01c__, 'useDataBrowserUICustomization').mockReturnValue(config);
+    jest.spyOn(__rspack_external__contexts_DataBrowserUICustomizationContext_js_f267b01c, 'useDataBrowserUICustomization').mockReturnValue(config);
 };
 const renderBucketList = (props = {})=>{
     const Wrapper = createTestWrapper();

package/dist/components/__tests__/BucketOverview.test.js

@@ -6,7 +6,7 @@ import { useGetBucketAcl, useGetBucketCors, useGetBucketLocation, useGetBucketOb
 import { applyBucketMocks, createTestWrapper } from "../../test/testUtils.js";
 import { BucketOverview, useBucketOverviewContext } from "../buckets/BucketOverview.js";
 import { useFeatures } from "../../hooks/useFeatures.js";
-import * as __WEBPACK_EXTERNAL_MODULE__contexts_DataBrowserUICustomizationContext_js_f267b01c__ from "../../contexts/DataBrowserUICustomizationContext.js";
+import * as __rspack_external__contexts_DataBrowserUICustomizationContext_js_f267b01c from "../../contexts/DataBrowserUICustomizationContext.js";
 jest.mock('../../hooks');
 jest.mock('../../hooks/useFeatures');
 const mockUseGetBucketVersioning = jest.mocked(useGetBucketVersioning);
@@ -19,7 +19,7 @@ const mockUseGetBucketTagging = jest.mocked(useGetBucketTagging);
 const mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
 const mockUseFeatures = jest.mocked(useFeatures);
 const mockUseDataBrowserUICustomization = (config = {})=>{
-    jest.spyOn(__WEBPACK_EXTERNAL_MODULE__contexts_DataBrowserUICustomizationContext_js_f267b01c__, 'useDataBrowserUICustomization').mockReturnValue(config);
+    jest.spyOn(__rspack_external__contexts_DataBrowserUICustomizationContext_js_f267b01c, 'useDataBrowserUICustomization').mockReturnValue(config);
 };
 const renderBucketOverview = (props = {})=>{
     const { bucketName = 'test-bucket', onEmptyBucket, onDeleteBucket, onEditPolicy, renderEmptyButton, renderDeleteButton, isEmptyBucketDisabled, isDeleteBucketDisabled } = props;

package/dist/components/__tests__/ObjectList.test.js

@@ -5,7 +5,7 @@ import { createTestWrapper, mockOffsetSize, setupMswServer } from "../../test/te
 import { useListObjectVersions, useListObjects } from "../../hooks/index.js";
 import { ObjectList } from "../objects/ObjectList.js";
 import { DataBrowserUICustomizationProvider } from "../../contexts/DataBrowserUICustomizationContext.js";
-import * as __WEBPACK_EXTERNAL_MODULE__hooks_useFeatures_js_a6a84786__ from "../../hooks/useFeatures.js";
+import * as __rspack_external__hooks_useFeatures_js_a6a84786 from "../../hooks/useFeatures.js";
 setupMswServer();
 const renderObjectList = (props = {}, customization)=>{
     const Wrapper = createTestWrapper();
@@ -32,7 +32,7 @@ describe('ObjectList', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
         mockOffsetSize(800, 600);
-        jest.spyOn(__WEBPACK_EXTERNAL_MODULE__hooks_useFeatures_js_a6a84786__, 'useFeatures').mockReturnValue(false);
+        jest.spyOn(__rspack_external__hooks_useFeatures_js_a6a84786, 'useFeatures').mockReturnValue(false);
     });
     afterEach(()=>{
         jest.restoreAllMocks();
@@ -284,7 +284,7 @@ describe('ObjectList', ()=>{
     });
     describe('Search Features', ()=>{
         it('renders table search when metadata-search feature is disabled', async ()=>{
-            jest.spyOn(__WEBPACK_EXTERNAL_MODULE__hooks_useFeatures_js_a6a84786__, 'useFeatures').mockReturnValue(false);
+            jest.spyOn(__rspack_external__hooks_useFeatures_js_a6a84786, 'useFeatures').mockReturnValue(false);
             renderObjectList();
             await waitFor(()=>{
                 expect(screen.getByRole('grid')).toBeInTheDocument();
@@ -292,7 +292,7 @@ describe('ObjectList', ()=>{
             expect(screen.queryByPlaceholderText(/Metadata Search/i)).not.toBeInTheDocument();
         });
         it('renders MetadataSearch component when metadata-search feature is enabled', async ()=>{
-            jest.spyOn(__WEBPACK_EXTERNAL_MODULE__hooks_useFeatures_js_a6a84786__, 'useFeatures').mockReturnValue(true);
+            jest.spyOn(__rspack_external__hooks_useFeatures_js_a6a84786, 'useFeatures').mockReturnValue(true);
             renderObjectList();
             await waitFor(()=>{
                 expect(screen.getByRole('grid')).toBeInTheDocument();

package/dist/components/buckets/BucketPage.js

@@ -7,7 +7,7 @@ import { BucketDetails } from "./BucketDetails.js";
 import { BucketList } from "./BucketList.js";
 import { useDataBrowserNavigate } from "../../hooks/useDataBrowserNavigate.js";
 import { useEffect } from "react";
-const BucketPage_BucketPage = ()=>{
+const BucketPage = ()=>{
     const { data, status } = useBuckets();
     const { bucketName } = useParams();
     const navigate = useDataBrowserNavigate();
@@ -47,5 +47,5 @@ const BucketPage_BucketPage = ()=>{
         rightPanel: /*#__PURE__*/ jsx(BucketDetails, {})
     });
 };
-const BucketPage = BucketPage_BucketPage;
-export { BucketPage_BucketPage as BucketPage, BucketPage as default };
+const buckets_BucketPage = BucketPage;
+export { BucketPage, buckets_BucketPage as default };

package/dist/components/objects/ObjectDetails/__tests__/ObjectDetails.test.js

@@ -1,12 +1,12 @@
-import * as __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__ from "../index.js";
+import * as __rspack_external__index_js_95fdb65a from "../index.js";
 import { jsx } from "react/jsx-runtime";
 import { cleanup, render, screen } from "@testing-library/react";
 import { MemoryRouter, Route, Routes } from "react-router";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { DataBrowserUICustomizationProvider } from "../../../../contexts/DataBrowserUICustomizationContext.js";
 var __webpack_modules__ = {
-    "..": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__;
+    ".." (module) {
+        module.exports = __rspack_external__index_js_95fdb65a;
     }
 };
 var __webpack_module_cache__ = {};

package/dist/components/objects/UploadButton.js

@@ -111,7 +111,7 @@ const NoFile = ({ open })=>/*#__PURE__*/ jsxs(EmptyFile, {
             })
         ]
     });
-const UploadButton_UploadButton = ({ bucket, prefix = '', uploadOptions = {}, onUploadSuccess, onUploadError })=>{
+const UploadButton = ({ bucket, prefix = '', uploadOptions = {}, onUploadSuccess, onUploadError })=>{
     const [isModalOpen, setIsModalOpen] = useState(false);
     const [acceptedFiles, setAcceptedFiles] = useState([]);
     const uploadMutation = useUploadObjects();
@@ -225,5 +225,5 @@ const UploadButton_UploadButton = ({ bucket, prefix = '', uploadOptions = {}, on
         ]
     });
 };
-const UploadButton = UploadButton_UploadButton;
-export { UploadButton_UploadButton as UploadButton, UploadButton as default };
+const objects_UploadButton = UploadButton;
+export { UploadButton, objects_UploadButton as default };

package/dist/config/__tests__/factory.test.d.ts

@@ -0,0 +1 @@
+export {};

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,6 +1,4 @@
 import Joi from 'joi';
-import type { S3BrowserConfig, S3Credentials } from '../types';
-import type { S3ClientConfiguration } from './types';
 export type S3RuntimeConfig = {
     s3: {
         endpoint?: string;
@@ -10,67 +8,10 @@ export type S3RuntimeConfig = {
 };
 export declare const s3RuntimeConfigSchema: Joi.ObjectSchema<any>;
 /**
- * Configuration factory that uses build-time constants
- * No runtime environment detection or hardcoded values
+ * 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 class S3ConfigurationFactory {
-    /**
-     * Load runtime configuration from config.json
-     * Should be called at app startup
-     *
-     * @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 or null if loading failed
-     *
-     * @example
-     * ```typescript
-     * type MyConfig = S3RuntimeConfig & {
-     *   theme?: string;
-     *   basePath?: string;
-     *   more: "type";
-     * };
-     *
-     * const config = await loadRuntimeConfig<MyConfig>("/config.json");
-     * ```
-     */
-    static loadRuntimeConfig<T extends S3RuntimeConfig = S3RuntimeConfig>(configUrl: string): Promise<T>;
-    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;
-    };
-}
-/**
- * Convenience functions for common use cases
- */
-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: <T extends S3RuntimeConfig = S3RuntimeConfig>(configUrl: string) => Promise<T>;
+export declare function loadRuntimeConfig<T extends S3RuntimeConfig = S3RuntimeConfig>(configUrl: string): Promise<T>;

package/dist/config/factory.js

@@ -1,89 +1,25 @@
 import joi from "joi";
 const s3RuntimeConfigSchema = joi.object({
     s3: joi.object({
-        endpoint: joi.string().optional(),
-        region: joi.string().required(),
+        endpoint: joi.string().optional().allow('origin'),
+        region: joi.string().min(1).required(),
         forcePathStyle: joi.boolean().optional()
-    })
+    }).required()
 });
-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;
-                const { error } = s3RuntimeConfigSchema.validate(data, {
-                    allowUnknown: true,
-                    stripUnknown: false,
-                    abortEarly: false
-                });
-                if (error) {
-                    const errorMessages = error.details.map((detail)=>detail.message).join(`\n`);
-                    throw new Error(`Invalid runtime configuration, please check your config.json: \n${errorMessages}`);
-                }
-                if (runtimeConfig?.s3?.endpoint === 'origin') runtimeConfig.s3.endpoint = window.location.origin;
-                return data;
-            }
-            throw new Error('Failed to load runtime configuration');
-        } catch (error) {
-            throw error;
-        }
-    }
-    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
-        };
+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, s3RuntimeConfigSchema, shouldUseProxy };
+export { loadRuntimeConfig, s3RuntimeConfigSchema };