@scality/data-browser-library 1.0.0-preview.8 → 1.0.1

package/dist/utils/__tests__/proxyMiddleware.test.js

@@ -0,0 +1,579 @@
+import { HttpRequest } from "@aws-sdk/protocol-http";
+import { createProxyMiddleware, resolveProxyEndpoint } from "../proxyMiddleware.js";
+describe('resolveProxyEndpoint', ()=>{
+    it('should return full URL unchanged', ()=>{
+        expect(resolveProxyEndpoint('http://localhost:3000/api/s3')).toBe('http://localhost:3000/api/s3');
+        expect(resolveProxyEndpoint('https://proxy.example.com:8443/s3')).toBe('https://proxy.example.com:8443/s3');
+    });
+    it('should resolve origin-relative path using window.location.origin', ()=>{
+        const resolved = resolveProxyEndpoint('/zenko/s3');
+        expect(resolved).toContain('/zenko/s3');
+        expect(resolved.startsWith('http')).toBe(true);
+    });
+    it('should resolve "origin" keyword using window.location.origin', ()=>{
+        const resolved = resolveProxyEndpoint('origin');
+        expect(resolved.startsWith('http')).toBe(true);
+        expect(resolved.split('://')[1]).not.toContain('/');
+    });
+});
+describe('createProxyMiddleware', ()=>{
+    describe('Configuration validation', ()=>{
+        it('should create middleware with https target endpoint', ()=>{
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            expect(middleware).toBeDefined();
+            expect(middleware.applyToStack).toBeInstanceOf(Function);
+        });
+        it('should create middleware with custom port in target endpoint', ()=>{
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:8080/proxy',
+                target: 'https://s3.amazonaws.com:9000'
+            });
+            expect(middleware).toBeDefined();
+            expect(middleware.applyToStack).toBeInstanceOf(Function);
+        });
+        it('should create middleware with path in proxy endpoint', ()=>{
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            expect(middleware).toBeDefined();
+            expect(middleware.applyToStack).toBeInstanceOf(Function);
+        });
+        it('should create middleware with hostname-only target', ()=>{
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 's3.pod-choco.local'
+            });
+            expect(middleware).toBeDefined();
+            expect(middleware.applyToStack).toBeInstanceOf(Function);
+        });
+    });
+    describe('Middleware stack integration', ()=>{
+        it('should add two middlewares to the stack', ()=>{
+            const mockStack = {
+                add: jest.fn()
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            expect(mockStack.add).toHaveBeenCalledTimes(2);
+            expect(mockStack.add).toHaveBeenNthCalledWith(1, expect.any(Function), expect.objectContaining({
+                step: 'build',
+                name: 'proxyPreSigningMiddleware',
+                priority: 'high'
+            }));
+            expect(mockStack.add).toHaveBeenNthCalledWith(2, expect.any(Function), expect.objectContaining({
+                step: 'finalizeRequest',
+                name: 'proxyPostSigningMiddleware',
+                priority: 'high'
+            }));
+        });
+    });
+    describe('Pre-signing middleware', ()=>{
+        it('should modify request to use real S3 host for signing', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('build' === config.step) mockStack.preSigningMiddleware = middleware;
+                }),
+                preSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const preSigningMiddleware = mockStack.preSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 'localhost',
+                port: 3000,
+                path: '/api/s3/bucket/key',
+                protocol: 'http:',
+                headers: {
+                    host: 'localhost:3000'
+                },
+                query: {
+                    param: 'value'
+                }
+            });
+            await preSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.hostname).toBe('s3.amazonaws.com');
+            expect(mockRequest.port).toBe(443);
+            expect(mockRequest.protocol).toBe('https:');
+            expect(mockRequest.headers.host).toBe('s3.amazonaws.com');
+            expect(mockRequest.query).toEqual({
+                param: 'value'
+            });
+            expect(mockNext).toHaveBeenCalledTimes(1);
+            expect(mockNext).toHaveBeenCalledWith({
+                request: mockRequest,
+                input: {}
+            });
+        });
+        it('should remove proxy path prefix from request path before signing', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('build' === config.step) mockStack.preSigningMiddleware = middleware;
+                }),
+                preSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const preSigningMiddleware = mockStack.preSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 'localhost',
+                path: '/api/s3/mybucket/mykey',
+                protocol: 'http:',
+                headers: {
+                    host: 'localhost'
+                }
+            });
+            await preSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.path).toBe('/mybucket/mykey');
+        });
+        it('should ensure path starts with slash after removing prefix', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('build' === config.step) mockStack.preSigningMiddleware = middleware;
+                }),
+                preSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const preSigningMiddleware = mockStack.preSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 'localhost',
+                path: '/api/s3mybucket',
+                protocol: 'http:',
+                headers: {
+                    host: 'localhost'
+                }
+            });
+            await preSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.path).toMatch(/^\//);
+        });
+        it('should preserve query parameters during pre-signing', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('build' === config.step) mockStack.preSigningMiddleware = middleware;
+                }),
+                preSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const preSigningMiddleware = mockStack.preSigningMiddleware(mockNext);
+            const originalQuery = {
+                'list-type': '2',
+                prefix: 'folder/',
+                delimiter: '/'
+            };
+            const mockRequest = new HttpRequest({
+                hostname: 'localhost',
+                path: '/api/s3/bucket',
+                protocol: 'http:',
+                headers: {
+                    host: 'localhost'
+                },
+                query: originalQuery
+            });
+            await preSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.query).toEqual(originalQuery);
+        });
+        it('should handle custom port in real S3 endpoint', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('build' === config.step) mockStack.preSigningMiddleware = middleware;
+                }),
+                preSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'http://s3.local:9000'
+            });
+            middleware.applyToStack(mockStack);
+            const preSigningMiddleware = mockStack.preSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 'localhost',
+                path: '/api/s3/bucket/key',
+                protocol: 'http:',
+                headers: {
+                    host: 'localhost'
+                }
+            });
+            await preSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.hostname).toBe('s3.local');
+            expect(mockRequest.port).toBe(9000);
+            expect(mockRequest.protocol).toBe('http:');
+        });
+        it('should not modify requests not targeting proxy', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('build' === config.step) mockStack.preSigningMiddleware = middleware;
+                }),
+                preSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const preSigningMiddleware = mockStack.preSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 'different-host.com',
+                path: '/bucket/key',
+                protocol: 'https:',
+                headers: {
+                    host: 'different-host.com'
+                }
+            });
+            const originalHostname = mockRequest.hostname;
+            const originalPath = mockRequest.path;
+            await preSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.hostname).toBe(originalHostname);
+            expect(mockRequest.path).toBe(originalPath);
+        });
+    });
+    describe('Post-signing middleware', ()=>{
+        it('should route signed request through proxy with correct parameters', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('finalizeRequest' === config.step) mockStack.postSigningMiddleware = middleware;
+                }),
+                postSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const postSigningMiddleware = mockStack.postSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 's3.amazonaws.com',
+                port: 443,
+                path: '/bucket/key',
+                protocol: 'https:',
+                headers: {
+                    host: 's3.amazonaws.com',
+                    authorization: 'AWS4-HMAC-SHA256 Credential=...'
+                },
+                query: {
+                    param: 'value'
+                }
+            });
+            await postSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.hostname).toBe('localhost');
+            expect(mockRequest.port).toBe(3000);
+            expect(mockRequest.protocol).toBe('http:');
+            expect(mockRequest.path).toBe('/api/s3/bucket/key');
+            expect(mockRequest.headers.host).toBe('localhost:3000');
+            expect(mockRequest.query).toEqual({
+                param: 'value'
+            });
+            expect(mockRequest.headers.authorization).toBe('AWS4-HMAC-SHA256 Credential=...');
+            expect(mockNext).toHaveBeenCalledTimes(1);
+        });
+        it('should preserve authorization header when routing through proxy', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('finalizeRequest' === config.step) mockStack.postSigningMiddleware = middleware;
+                }),
+                postSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const postSigningMiddleware = mockStack.postSigningMiddleware(mockNext);
+            const authHeader = 'AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20230101/us-east-1/s3/aws4_request';
+            const mockRequest = new HttpRequest({
+                hostname: 's3.amazonaws.com',
+                path: '/bucket/key',
+                protocol: 'https:',
+                headers: {
+                    host: 's3.amazonaws.com',
+                    authorization: authHeader
+                }
+            });
+            await postSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.headers.authorization).toBe(authHeader);
+        });
+        it('should correctly format host header for non-standard proxy port', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('finalizeRequest' === config.step) mockStack.postSigningMiddleware = middleware;
+                }),
+                postSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:8080/proxy',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const postSigningMiddleware = mockStack.postSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 's3.amazonaws.com',
+                path: '/bucket/key',
+                protocol: 'https:',
+                headers: {
+                    host: 's3.amazonaws.com'
+                }
+            });
+            await postSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.hostname).toBe('localhost');
+            expect(mockRequest.port).toBe(8080);
+            expect(mockRequest.headers.host).toBe('localhost:8080');
+        });
+        it('should omit port from host header for http port 80', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('finalizeRequest' === config.step) mockStack.postSigningMiddleware = middleware;
+                }),
+                postSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://proxy.example.com/api',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const postSigningMiddleware = mockStack.postSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 's3.amazonaws.com',
+                path: '/bucket/key',
+                protocol: 'https:',
+                headers: {
+                    host: 's3.amazonaws.com'
+                }
+            });
+            await postSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.headers.host).toBe('proxy.example.com');
+            expect(mockRequest.headers.host).not.toContain(':80');
+        });
+        it('should omit port from host header for https port 443', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('finalizeRequest' === config.step) mockStack.postSigningMiddleware = middleware;
+                }),
+                postSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'https://proxy.example.com/api',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const postSigningMiddleware = mockStack.postSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 's3.amazonaws.com',
+                path: '/bucket/key',
+                protocol: 'https:',
+                headers: {
+                    host: 's3.amazonaws.com'
+                }
+            });
+            await postSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.headers.host).toBe('proxy.example.com');
+            expect(mockRequest.headers.host).not.toContain(':443');
+        });
+        it('should prepend proxy pathname to request path', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('finalizeRequest' === config.step) mockStack.postSigningMiddleware = middleware;
+                }),
+                postSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/my/proxy/path',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const postSigningMiddleware = mockStack.postSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 's3.amazonaws.com',
+                path: '/bucket/key',
+                protocol: 'https:',
+                headers: {
+                    host: 's3.amazonaws.com'
+                }
+            });
+            await postSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.path).toBe('/my/proxy/path/bucket/key');
+        });
+        it('should preserve complex query parameters', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('finalizeRequest' === config.step) mockStack.postSigningMiddleware = middleware;
+                }),
+                postSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const postSigningMiddleware = mockStack.postSigningMiddleware(mockNext);
+            const complexQuery = {
+                'list-type': '2',
+                prefix: 'folder/subfolder/',
+                delimiter: '/',
+                'max-keys': '1000',
+                'continuation-token': 'ABC123=='
+            };
+            const mockRequest = new HttpRequest({
+                hostname: 's3.amazonaws.com',
+                path: '/bucket',
+                protocol: 'https:',
+                headers: {
+                    host: 's3.amazonaws.com'
+                },
+                query: complexQuery
+            });
+            await postSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.query).toEqual(complexQuery);
+        });
+        it('should not modify requests not targeting real S3 endpoint', async ()=>{
+            const mockNext = jest.fn().mockResolvedValue({
+                output: {}
+            });
+            const mockStack = {
+                add: jest.fn((middleware, config)=>{
+                    if ('finalizeRequest' === config.step) mockStack.postSigningMiddleware = middleware;
+                }),
+                postSigningMiddleware: null
+            };
+            const middleware = createProxyMiddleware({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'https://s3.amazonaws.com'
+            });
+            middleware.applyToStack(mockStack);
+            const postSigningMiddleware = mockStack.postSigningMiddleware(mockNext);
+            const mockRequest = new HttpRequest({
+                hostname: 'other-service.com',
+                path: '/api/endpoint',
+                protocol: 'https:',
+                headers: {
+                    host: 'other-service.com'
+                }
+            });
+            const originalHostname = mockRequest.hostname;
+            const originalPath = mockRequest.path;
+            const originalPort = mockRequest.port;
+            await postSigningMiddleware({
+                request: mockRequest,
+                input: {}
+            });
+            expect(mockRequest.hostname).toBe(originalHostname);
+            expect(mockRequest.path).toBe(originalPath);
+            expect(mockRequest.port).toBe(originalPort);
+        });
+    });
+});

package/dist/utils/__tests__/s3Client.test.d.ts

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