@paakd/api 0.0.1 → 0.0.2

package/dist/src/interceptors.spec.js

@@ -0,0 +1,1063 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const connect_1 = require("@connectrpc/connect");
+const interceptors_1 = require("./interceptors");
+// Mock the checkout config
+vi.mock('@paakd/config', () => ({
+    Checkout: {},
+}));
+vi.mock('./compressor/brotli', () => ({
+    brotliCompression: {
+        name: 'brotli',
+        compress: vi.fn(),
+        decompress: vi.fn(),
+    },
+}));
+describe('interceptors', () => {
+    describe('createLoggingInterceptor', () => {
+        let mockLogger;
+        let mockNext;
+        let mockRequest;
+        let mockResponse;
+        beforeEach(() => {
+            mockLogger = {
+                onRequestHeader: vi.fn(),
+                onRequestMessage: vi.fn(),
+                onResponseHeader: vi.fn(),
+                onResponseMessage: vi.fn(),
+                onResponseTrailer: vi.fn(),
+                onError: vi.fn(),
+            };
+            mockNext = vi.fn();
+            mockRequest = {
+                stream: false,
+                method: {
+                    methodKind: 'unary',
+                    toString: () => 'TestService/TestMethod',
+                },
+                header: new Headers(),
+                message: { $typeName: 'test.Message' },
+            };
+            mockResponse = {
+                stream: false,
+                header: new Headers(),
+                message: { $typeName: 'test.Message' },
+                trailer: new Headers(),
+            };
+        });
+        it('should create a logging interceptor with default logger', () => {
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)();
+            expect(typeof interceptor).toBe('function');
+        });
+        it('should create a logging interceptor with custom logger', () => {
+            const customLogger = vi.fn().mockReturnValue(mockLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            expect(typeof interceptor).toBe('function');
+        });
+        it('should log unary request and response', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customLogger = vi.fn().mockReturnValue(mockLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            const result = yield interceptorFn(mockRequest);
+            expect(customLogger).toHaveBeenCalledWith(mockRequest);
+            expect(mockLogger.onRequestHeader).toHaveBeenCalledWith(mockRequest.header);
+            expect(mockLogger.onRequestMessage).toHaveBeenCalledWith(mockRequest.message);
+            expect(mockLogger.onResponseHeader).toHaveBeenCalledWith(mockResponse.header);
+            expect(mockLogger.onResponseMessage).toHaveBeenCalledWith(mockResponse.message);
+            expect(mockLogger.onResponseTrailer).toHaveBeenCalledWith(mockResponse.trailer);
+            expect(result).toBe(mockResponse);
+        }));
+        it('should handle stream requests with multiple messages', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            const customLogger = vi.fn().mockReturnValue(mockLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            const interceptorFn = interceptor(mockNext);
+            const messages = [
+                { $typeName: 'test.Message', id: 1 },
+                { $typeName: 'test.Message', id: 2 },
+                { $typeName: 'test.Message', id: 3 },
+            ];
+            const streamRequest = Object.assign(Object.assign({}, mockRequest), { stream: true, message: (function () {
+                    return __asyncGenerator(this, arguments, function* () {
+                        for (const msg of messages) {
+                            yield yield __await(msg);
+                        }
+                    });
+                })() });
+            const streamResponse = Object.assign(Object.assign({}, mockResponse), { stream: true, message: (function () {
+                    return __asyncGenerator(this, arguments, function* () {
+                        for (const msg of messages) {
+                            yield yield __await(msg);
+                        }
+                    });
+                })() });
+            mockNext.mockResolvedValue(streamResponse);
+            const result = yield interceptorFn(streamRequest);
+            expect(customLogger).toHaveBeenCalledWith(streamRequest);
+            expect(mockLogger.onRequestHeader).toHaveBeenCalledWith(streamRequest.header);
+            expect(result).toBeDefined();
+            expect(result.stream).toBe(true);
+            // Consume the stream to trigger message logging
+            const responseMessages = [];
+            try {
+                for (var _d = true, _e = __asyncValues(result.message), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const msg = _c;
+                    responseMessages.push(msg);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            expect(responseMessages).toHaveLength(3);
+            expect(mockLogger.onResponseMessage).toHaveBeenCalledTimes(3);
+            expect(mockLogger.onResponseTrailer).toHaveBeenCalledWith(mockResponse.trailer);
+        }));
+        it('should log errors in stream and rethrow', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customLogger = vi.fn().mockReturnValue(mockLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            const interceptorFn = interceptor(mockNext);
+            const streamError = new Error('Stream processing error');
+            const streamRequest = Object.assign(Object.assign({}, mockRequest), { stream: true, message: (function () {
+                    return __asyncGenerator(this, arguments, function* () {
+                        yield yield __await({ $typeName: 'test.Message' });
+                        throw streamError;
+                    });
+                })() });
+            const streamResponse = Object.assign(Object.assign({}, mockResponse), { stream: true, message: (function () {
+                    return __asyncGenerator(this, arguments, function* () {
+                        throw streamError;
+                    });
+                })() });
+            mockNext.mockResolvedValue(streamResponse);
+            const result = yield interceptorFn(streamRequest);
+            // Consume the response stream to trigger error
+            yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+                var _a, e_2, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(result.message), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const msg = _c;
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            })).rejects.toThrow('Stream processing error');
+            expect(mockLogger.onError).toHaveBeenCalledWith(streamError);
+        }));
+        it('should log errors and rethrow them in unary calls', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customLogger = vi.fn().mockReturnValue(mockLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            const interceptorFn = interceptor(mockNext);
+            const error = new Error('Test error');
+            mockNext.mockRejectedValue(error);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow('Test error');
+            expect(mockLogger.onError).toHaveBeenCalledWith(error);
+        }));
+        it('should log ConnectError during request processing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customLogger = vi.fn().mockReturnValue(mockLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            const interceptorFn = interceptor(mockNext);
+            const connectError = new connect_1.ConnectError('Service unavailable', connect_1.Code.Unavailable);
+            mockNext.mockRejectedValue(connectError);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+            expect(mockLogger.onError).toHaveBeenCalledWith(connectError);
+        }));
+        it('should use default logger when none provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)();
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            yield interceptorFn(mockRequest);
+            expect(consoleSpy).toHaveBeenCalled();
+            const calls = consoleSpy.mock.calls.filter(call => { var _a; return (_a = call[0]) === null || _a === void 0 ? void 0 : _a.includes('TestService'); });
+            expect(calls.length).toBeGreaterThan(0);
+            consoleSpy.mockRestore();
+        }));
+        it('should handle partial logger implementation', () => __awaiter(void 0, void 0, void 0, function* () {
+            const partialLogger = {
+                onRequestHeader: vi.fn(),
+                // Missing other callbacks
+            };
+            const customLogger = vi.fn().mockReturnValue(partialLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            // Should not throw even with missing callbacks
+            yield expect(interceptorFn(mockRequest)).resolves.toBeDefined();
+            expect(partialLogger.onRequestHeader).toHaveBeenCalled();
+        }));
+        it('should pass correct method info to logger function', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customLogger = vi.fn().mockReturnValue(mockLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            const testRequest = Object.assign(Object.assign({}, mockRequest), { method: {
+                    methodKind: 'unary',
+                    toString: () => 'CustomService/CustomMethod',
+                } });
+            yield interceptorFn(testRequest);
+            expect(customLogger).toHaveBeenCalledWith(testRequest);
+            const loggerResult = customLogger.mock.results[0].value;
+            expect(loggerResult).toBeDefined();
+        }));
+        it('should handle stream response completion without error', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, e_3, _b, _c;
+            const customLogger = vi.fn().mockReturnValue(mockLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            const interceptorFn = interceptor(mockNext);
+            const streamResponse = Object.assign(Object.assign({}, mockResponse), { stream: true, message: (function () {
+                    return __asyncGenerator(this, arguments, function* () {
+                        yield yield __await({ $typeName: 'test.Message', id: 1 }
+                        // Stream ends normally
+                        );
+                        // Stream ends normally
+                    });
+                })() });
+            mockNext.mockResolvedValue(streamResponse);
+            const result = yield interceptorFn(mockRequest);
+            // Consume the stream
+            const messages = [];
+            try {
+                for (var _d = true, _e = __asyncValues(result.message), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const msg = _c;
+                    messages.push(msg);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            expect(messages).toHaveLength(1);
+            expect(mockLogger.onResponseTrailer).toHaveBeenCalled();
+        }));
+        it('should handle stream iterator with throw method', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customLogger = vi.fn().mockReturnValue(mockLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            const interceptorFn = interceptor(mockNext);
+            const mockIterator = {
+                next: vi.fn().mockResolvedValue({
+                    done: false,
+                    value: { $typeName: 'test.Message' },
+                }),
+                throw: vi.fn().mockRejectedValue(new Error('Thrown error')),
+                return: vi.fn().mockResolvedValue({ done: true }),
+            };
+            const streamResponse = Object.assign(Object.assign({}, mockResponse), { stream: true, message: {
+                    [Symbol.asyncIterator]: () => mockIterator,
+                } });
+            mockNext.mockResolvedValue(streamResponse);
+            const result = yield interceptorFn(mockRequest);
+            // Get the intercepted iterator
+            const interceptedIterator = result.message[Symbol.asyncIterator]();
+            // The intercepted iterator should have throw and return methods
+            expect(typeof interceptedIterator.throw).toBe('function');
+            expect(typeof interceptedIterator.return).toBe('function');
+        }));
+        it('should handle stream iterator without throw method', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customLogger = vi.fn().mockReturnValue(mockLogger);
+            const interceptor = (0, interceptors_1.createLoggingInterceptor)(customLogger);
+            const interceptorFn = interceptor(mockNext);
+            const mockIterator = {
+                next: vi.fn().mockResolvedValue({
+                    done: false,
+                    value: { $typeName: 'test.Message' },
+                }),
+                // No throw or return methods
+            };
+            const streamResponse = Object.assign(Object.assign({}, mockResponse), { stream: true, message: {
+                    [Symbol.asyncIterator]: () => mockIterator,
+                } });
+            mockNext.mockResolvedValue(streamResponse);
+            const result = yield interceptorFn(mockRequest);
+            const interceptedIterator = result.message[Symbol.asyncIterator]();
+            // Should work without throw/return methods
+            const msg = yield interceptedIterator.next();
+            expect(msg.value).toBeDefined();
+        }));
+    });
+    describe('createAuthenticationInterceptor', () => {
+        let mockNext;
+        let mockRequest;
+        let mockResponse;
+        let mockCheckoutConfig;
+        beforeEach(() => {
+            mockNext = vi.fn();
+            mockRequest = {
+                header: new Headers(),
+            };
+            mockResponse = {
+                header: new Headers(),
+                message: { $typeName: 'test.Message' },
+                trailer: new Headers(),
+            };
+            mockCheckoutConfig = {
+                hostname: 'example.com',
+                cmsRemoteURL: 'https://cms.example.com',
+                enterpriseRemoteURL: 'https://enterprise.example.com',
+                cmsURL: 'https://cms-local.example.com',
+                enterpriseURL: 'https://enterprise.example.com',
+                secureCookiePassword: 'secure-cookie-password',
+                forestAPIKey: 'forest-api-key',
+                saleChannelAccessKey: 'test-sales-channel-access',
+                salesChannelAPISecret: 'test-sales-channel-secret',
+                storeAccessKey: 'test-store-access',
+                storeAPISecret: 'test-store-secret',
+                isProduction: false,
+                posthogKey: 'posthog-key',
+                posthogDomain: 'posthog.example.com',
+                posthogHost: 'posthog.example.com',
+                assetsPath: '/assets',
+                assetsDomain: 'assets.example.com',
+                turnstileKey: 'turnstile-key',
+                turnstileSecret: 'turnstile-secret',
+                redis: {
+                    user: 'redis-user',
+                    host: 'localhost',
+                    password: 'redis-password',
+                    port: 6379,
+                },
+            };
+        });
+        it('should create an authentication interceptor', () => {
+            const interceptor = (0, interceptors_1.createAuthenticationInterceptor)(mockCheckoutConfig);
+            expect(typeof interceptor).toBe('function');
+        });
+        it('should set all authentication headers', () => __awaiter(void 0, void 0, void 0, function* () {
+            const interceptor = (0, interceptors_1.createAuthenticationInterceptor)(mockCheckoutConfig);
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            const result = yield interceptorFn(mockRequest);
+            expect(mockRequest.header.get('X-Store-Key')).toBe('test-store-secret');
+            expect(mockRequest.header.get('X-SA-Key')).toBe('test-store-access');
+            expect(mockRequest.header.get('X-CH-Key')).toBe('test-sales-channel-secret');
+            expect(mockRequest.header.get('X-CHA-Key')).toBe('test-sales-channel-access');
+            expect(mockNext).toHaveBeenCalledWith(mockRequest);
+            expect(result).toBe(mockResponse);
+        }));
+        it('should set headers exactly once per call', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const interceptor = (0, interceptors_1.createAuthenticationInterceptor)(mockCheckoutConfig);
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            yield interceptorFn(mockRequest);
+            // Verify headers are set exactly once
+            const headerSetCalls = ((_a = mockRequest.header.set.mock) === null || _a === void 0 ? void 0 : _a.calls) || [];
+            // Headers.set might not be mockable, so we verify via get
+            expect(mockRequest.header.get('X-Store-Key')).toBe('test-store-secret');
+            expect(mockRequest.header.get('X-SA-Key')).toBe('test-store-access');
+            expect(mockRequest.header.get('X-CH-Key')).toBe('test-sales-channel-secret');
+            expect(mockRequest.header.get('X-CHA-Key')).toBe('test-sales-channel-access');
+        }));
+        it('should work with stream requests', () => __awaiter(void 0, void 0, void 0, function* () {
+            const interceptor = (0, interceptors_1.createAuthenticationInterceptor)(mockCheckoutConfig);
+            const interceptorFn = interceptor(mockNext);
+            const streamRequest = Object.assign(Object.assign({}, mockRequest), { stream: true });
+            mockNext.mockResolvedValue(mockResponse);
+            const result = yield interceptorFn(streamRequest);
+            expect(streamRequest.header.get('X-Store-Key')).toBe('test-store-secret');
+            expect(streamRequest.header.get('X-SA-Key')).toBe('test-store-access');
+            expect(streamRequest.header.get('X-CH-Key')).toBe('test-sales-channel-secret');
+            expect(streamRequest.header.get('X-CHA-Key')).toBe('test-sales-channel-access');
+            expect(result).toBe(mockResponse);
+        }));
+        it('should pass request unchanged to next interceptor', () => __awaiter(void 0, void 0, void 0, function* () {
+            const interceptor = (0, interceptors_1.createAuthenticationInterceptor)(mockCheckoutConfig);
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            const originalRequest = mockRequest;
+            yield interceptorFn(originalRequest);
+            expect(mockNext).toHaveBeenCalledWith(originalRequest);
+        }));
+        it('should handle empty config values', () => __awaiter(void 0, void 0, void 0, function* () {
+            const emptyConfig = {
+                hostname: 'example.com',
+                cmsRemoteURL: 'https://cms.example.com',
+                enterpriseRemoteURL: 'https://enterprise.example.com',
+                cmsURL: 'https://cms-local.example.com',
+                enterpriseURL: 'https://enterprise.example.com',
+                secureCookiePassword: 'secure-cookie-password',
+                forestAPIKey: 'forest-api-key',
+                saleChannelAccessKey: '',
+                salesChannelAPISecret: '',
+                storeAccessKey: '',
+                storeAPISecret: '',
+                isProduction: false,
+                posthogKey: 'posthog-key',
+                posthogDomain: 'posthog.example.com',
+                posthogHost: 'posthog.example.com',
+                assetsPath: '/assets',
+                assetsDomain: 'assets.example.com',
+                turnstileKey: 'turnstile-key',
+                turnstileSecret: 'turnstile-secret',
+                redis: {
+                    user: 'redis-user',
+                    host: 'localhost',
+                    password: 'redis-password',
+                    port: 6379,
+                },
+            };
+            const interceptor = (0, interceptors_1.createAuthenticationInterceptor)(emptyConfig);
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            const result = yield interceptorFn(mockRequest);
+            expect(mockRequest.header.get('X-Store-Key')).toBe('');
+            expect(mockRequest.header.get('X-SA-Key')).toBe('');
+            expect(result).toBe(mockResponse);
+        }));
+        it('should propagate response from next interceptor', () => __awaiter(void 0, void 0, void 0, function* () {
+            const interceptor = (0, interceptors_1.createAuthenticationInterceptor)(mockCheckoutConfig);
+            const interceptorFn = interceptor(mockNext);
+            const customResponse = Object.assign(Object.assign({}, mockResponse), { message: { $typeName: 'custom.Message', data: 'custom' } });
+            mockNext.mockResolvedValue(customResponse);
+            const result = yield interceptor(mockNext)(mockRequest);
+            expect(result).toBe(customResponse);
+            expect(result.message.data).toBe('custom');
+        }));
+    });
+    describe('createCustomerAuthenticationInterceptor', () => {
+        let mockNext;
+        let mockRequest;
+        let mockResponse;
+        beforeEach(() => {
+            mockNext = vi.fn();
+            mockRequest = {
+                header: new Headers(),
+            };
+            mockResponse = {
+                header: new Headers(),
+                message: { $typeName: 'test.Message' },
+                trailer: new Headers(),
+            };
+        });
+        it('should create a customer authentication interceptor', () => {
+            const interceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)('test-jwt-token');
+            expect(typeof interceptor).toBe('function');
+        });
+        it('should set Authorization header with Bearer token', () => __awaiter(void 0, void 0, void 0, function* () {
+            const jwtToken = 'test-jwt-token';
+            const interceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)(jwtToken);
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            const result = yield interceptorFn(mockRequest);
+            expect(mockRequest.header.get('Authorization')).toBe(`Bearer ${jwtToken}`);
+            expect(mockNext).toHaveBeenCalledWith(mockRequest);
+            expect(result).toBe(mockResponse);
+        }));
+        it('should work with various JWT token formats', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tokens = [
+                'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c',
+                'simple-token',
+                'token-with-many-dashes-123-456-789',
+            ];
+            for (const token of tokens) {
+                const interceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)(token);
+                const interceptorFn = interceptor(mockNext);
+                mockNext.mockResolvedValue(mockResponse);
+                const request = { header: new Headers() };
+                yield interceptorFn(request);
+                expect(request.header.get('Authorization')).toBe(`Bearer ${token}`);
+            }
+        }));
+        it('should work with stream requests', () => __awaiter(void 0, void 0, void 0, function* () {
+            const jwtToken = 'test-jwt-token';
+            const interceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)(jwtToken);
+            const interceptorFn = interceptor(mockNext);
+            const streamRequest = Object.assign(Object.assign({}, mockRequest), { stream: true });
+            mockNext.mockResolvedValue(mockResponse);
+            const result = yield interceptorFn(streamRequest);
+            expect(streamRequest.header.get('Authorization')).toBe(`Bearer ${jwtToken}`);
+            expect(result).toBe(mockResponse);
+        }));
+        it('should throw error for empty JWT token', () => __awaiter(void 0, void 0, void 0, function* () {
+            const interceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)('');
+            const interceptorFn = interceptor(mockNext);
+            try {
+                yield interceptorFn(mockRequest);
+                expect.fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(connect_1.ConnectError);
+            }
+        }));
+        it('should throw Unauthenticated error code for empty JWT', () => __awaiter(void 0, void 0, void 0, function* () {
+            const interceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)('');
+            const interceptorFn = interceptor(mockNext);
+            try {
+                yield interceptorFn(mockRequest);
+                expect.fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(connect_1.ConnectError);
+                expect(error.code).toBe(connect_1.Code.Unauthenticated);
+            }
+        }));
+        it('should throw error for null JWT token', () => __awaiter(void 0, void 0, void 0, function* () {
+            const interceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)(null);
+            const interceptorFn = interceptor(mockNext);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+        }));
+        it('should throw error for undefined JWT token', () => __awaiter(void 0, void 0, void 0, function* () {
+            const interceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)(undefined);
+            const interceptorFn = interceptor(mockNext);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+        }));
+        it('should not call next when JWT validation fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            const interceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)('');
+            const interceptorFn = interceptor(mockNext);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+            // next should never be called if validation fails
+            expect(mockNext).not.toHaveBeenCalled();
+        }));
+        it('should propagate response from next interceptor', () => __awaiter(void 0, void 0, void 0, function* () {
+            const jwtToken = 'test-jwt-token';
+            const interceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)(jwtToken);
+            const interceptorFn = interceptor(mockNext);
+            const customResponse = Object.assign(Object.assign({}, mockResponse), { message: { $typeName: 'custom.Message', userId: 'user123' } });
+            mockNext.mockResolvedValue(customResponse);
+            const result = yield interceptorFn(mockRequest);
+            expect(result).toBe(customResponse);
+            expect(result.message.userId).toBe('user123');
+        }));
+    });
+    describe('createHeadersInterceptor', () => {
+        let mockNext;
+        let mockRequest;
+        let mockResponse;
+        beforeEach(() => {
+            mockNext = vi.fn();
+            mockRequest = {
+                header: new Headers(),
+            };
+            mockResponse = {
+                header: new Headers(),
+                message: { $typeName: 'test.Message' },
+                trailer: new Headers(),
+            };
+        });
+        it('should set expected headers from header mapping', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            const result = yield interceptorFn(mockRequest);
+            expect(mockRequest.header.get('X-Original-Host')).toBe('example.com');
+            expect(mockRequest.header.get('X-shop-id')).toBe('shop123');
+            expect(mockRequest.header.get('X-Sitepath')).toBe('/path');
+            expect(mockRequest.header.get('X-locale')).toBe('en');
+            expect(mockRequest.header.get('X-region')).toBe('US');
+            expect(mockNext).toHaveBeenCalledWith(mockRequest);
+            expect(result).toBe(mockResponse);
+        }));
+        it('should throw error when x-original-host is missing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            try {
+                yield interceptorFn(mockRequest);
+                expect.fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(connect_1.ConnectError);
+                expect(error.code).toBe(connect_1.Code.InvalidArgument);
+                expect(error.message).toContain('Original host');
+            }
+        }));
+        it('should throw error when x-shop-id is missing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            try {
+                yield interceptorFn(mockRequest);
+                expect.fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(connect_1.ConnectError);
+                expect(error.message).toContain('Shop id');
+            }
+        }));
+        it('should throw error when x-sitepath is missing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': 'shop123',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            try {
+                yield interceptorFn(mockRequest);
+                expect.fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(connect_1.ConnectError);
+                expect(error.message).toContain('Sitepath');
+            }
+        }));
+        it('should throw error when x-locale is missing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            try {
+                yield interceptorFn(mockRequest);
+                expect.fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(connect_1.ConnectError);
+                expect(error.message).toContain('Locale');
+            }
+        }));
+        it('should throw error when x-region is missing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            try {
+                yield interceptorFn(mockRequest);
+                expect.fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(connect_1.ConnectError);
+                expect(error.message).toContain('Region');
+            }
+        }));
+        it('should throw error when x-original-host is null', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': null,
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+        }));
+        it('should throw error when x-shop-id is null', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': null,
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+        }));
+        it('should throw error when x-sitepath is null', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': 'shop123',
+                'x-sitepath': null,
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+        }));
+        it('should throw error when x-locale is null', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-locale': null,
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+        }));
+        it('should throw error when x-region is null', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': null,
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+        }));
+        it('should work with stream requests', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            const streamRequest = {
+                header: new Headers(),
+                stream: true,
+            };
+            mockNext.mockResolvedValue(mockResponse);
+            const result = yield interceptorFn(streamRequest);
+            expect(streamRequest.header.get('X-Original-Host')).toBe('example.com');
+            expect(streamRequest.header.get('X-shop-id')).toBe('shop123');
+            expect(result).toBe(mockResponse);
+        }));
+        it('should not call next when header validation fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                // Missing x-shop-id
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+            // next should never be called if validation fails
+            expect(mockNext).not.toHaveBeenCalled();
+        }));
+        it('should propagate response from next interceptor', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            const customResponse = Object.assign(Object.assign({}, mockResponse), { message: { $typeName: 'custom.Message', requestId: 'req123' } });
+            mockNext.mockResolvedValue(customResponse);
+            const result = yield interceptor(mockNext)(mockRequest);
+            expect(result).toBe(customResponse);
+            expect(result.message.requestId).toBe('req123');
+        }));
+        it('should handle headers with special characters', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': 'example.com:8080',
+                'x-shop-id': 'shop-123-456',
+                'x-sitepath': '/en-GB/products',
+                'x-locale': 'en_GB',
+                'x-region': 'EU-West-1',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            mockNext.mockResolvedValue(mockResponse);
+            const result = yield interceptorFn(mockRequest);
+            expect(mockRequest.header.get('X-Original-Host')).toBe('example.com:8080');
+            expect(mockRequest.header.get('X-shop-id')).toBe('shop-123-456');
+            expect(mockRequest.header.get('X-Sitepath')).toBe('/en-GB/products');
+            expect(result).toBe(mockResponse);
+        }));
+        it('should handle empty string headers (should fail validation)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const customHeaders = {
+                'x-original-host': '',
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const interceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const interceptorFn = interceptor(mockNext);
+            // Empty string is falsy, so validation should fail
+            yield expect(interceptorFn(mockRequest)).rejects.toThrow();
+        }));
+    });
+    describe('interceptor integration', () => {
+        it('should chain multiple interceptors in order', () => __awaiter(void 0, void 0, void 0, function* () {
+            const jwtToken = 'test-jwt';
+            const mockNext = vi.fn();
+            mockNext.mockResolvedValue({
+                header: new Headers(),
+                message: { $typeName: 'test.Message' },
+                trailer: new Headers(),
+            });
+            const mockCheckoutConfig = {
+                hostname: 'example.com',
+                cmsRemoteURL: 'https://cms.example.com',
+                enterpriseRemoteURL: 'https://enterprise.example.com',
+                cmsURL: 'https://cms-local.example.com',
+                enterpriseURL: 'https://enterprise.example.com',
+                secureCookiePassword: 'secure-cookie-password',
+                forestAPIKey: 'forest-api-key',
+                saleChannelAccessKey: 'test-sales-channel-access',
+                salesChannelAPISecret: 'test-sales-channel-secret',
+                storeAccessKey: 'test-store-access',
+                storeAPISecret: 'test-store-secret',
+                isProduction: false,
+                posthogKey: 'posthog-key',
+                posthogDomain: 'posthog.example.com',
+                posthogHost: 'posthog.example.com',
+                assetsPath: '/assets',
+                assetsDomain: 'assets.example.com',
+                turnstileKey: 'turnstile-key',
+                turnstileSecret: 'turnstile-secret',
+                redis: {
+                    user: 'redis-user',
+                    host: 'localhost',
+                    password: 'redis-password',
+                    port: 6379,
+                },
+            };
+            // Create interceptors
+            const authInterceptor = (0, interceptors_1.createAuthenticationInterceptor)(mockCheckoutConfig);
+            const customerAuthInterceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)(jwtToken);
+            const loggingInterceptor = (0, interceptors_1.createLoggingInterceptor)();
+            // Chain them together
+            const chainedInterceptor = authInterceptor(customerAuthInterceptor(loggingInterceptor(mockNext)));
+            const mockRequest = {
+                header: new Headers(),
+                method: {
+                    toString: () => 'TestService/TestMethod',
+                },
+                message: { $typeName: 'test.Message' },
+            };
+            yield chainedInterceptor(mockRequest);
+            // Verify all headers are set
+            expect(mockRequest.header.get('X-Store-Key')).toBe('test-store-secret');
+            expect(mockRequest.header.get('X-SA-Key')).toBe('test-store-access');
+            expect(mockRequest.header.get('Authorization')).toBe(`Bearer ${jwtToken}`);
+            expect(mockNext).toHaveBeenCalled();
+        }));
+        it('should handle errors in chained interceptors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const jwtToken = '';
+            const mockNext = vi.fn();
+            mockNext.mockResolvedValue({
+                header: new Headers(),
+                message: { $typeName: 'test.Message' },
+                trailer: new Headers(),
+            });
+            const mockCheckoutConfig = {
+                hostname: 'example.com',
+                cmsRemoteURL: 'https://cms.example.com',
+                enterpriseRemoteURL: 'https://enterprise.example.com',
+                cmsURL: 'https://cms-local.example.com',
+                enterpriseURL: 'https://enterprise.example.com',
+                secureCookiePassword: 'secure-cookie-password',
+                forestAPIKey: 'forest-api-key',
+                saleChannelAccessKey: 'test-sales-channel-access',
+                salesChannelAPISecret: 'test-sales-channel-secret',
+                storeAccessKey: 'test-store-access',
+                storeAPISecret: 'test-store-secret',
+                isProduction: false,
+                posthogKey: 'posthog-key',
+                posthogDomain: 'posthog.example.com',
+                posthogHost: 'posthog.example.com',
+                assetsPath: '/assets',
+                assetsDomain: 'assets.example.com',
+                turnstileKey: 'turnstile-key',
+                turnstileSecret: 'turnstile-secret',
+                redis: {
+                    user: 'redis-user',
+                    host: 'localhost',
+                    password: 'redis-password',
+                    port: 6379,
+                },
+            };
+            // Chain: auth -> customer auth (will fail) -> logging
+            const authInterceptor = (0, interceptors_1.createAuthenticationInterceptor)(mockCheckoutConfig);
+            const customerAuthInterceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)(jwtToken);
+            const loggingInterceptor = (0, interceptors_1.createLoggingInterceptor)();
+            const chainedInterceptor = authInterceptor(customerAuthInterceptor(loggingInterceptor(mockNext)));
+            const mockRequest = {
+                header: new Headers(),
+                method: {
+                    toString: () => 'TestService/TestMethod',
+                },
+                message: { $typeName: 'test.Message' },
+            };
+            // Should fail at customer auth interceptor
+            yield expect(chainedInterceptor(mockRequest)).rejects.toThrow();
+            // Auth headers should still be set before error
+            expect(mockRequest.header.get('X-Store-Key')).toBe('test-store-secret');
+            // But next should not be called
+            expect(mockNext).not.toHaveBeenCalled();
+        }));
+        it('should work with all interceptors including headers', () => __awaiter(void 0, void 0, void 0, function* () {
+            const jwtToken = 'test-jwt';
+            const mockNext = vi.fn();
+            mockNext.mockResolvedValue({
+                header: new Headers(),
+                message: { $typeName: 'test.Message' },
+                trailer: new Headers(),
+            });
+            const mockCheckoutConfig = {
+                hostname: 'example.com',
+                cmsRemoteURL: 'https://cms.example.com',
+                enterpriseRemoteURL: 'https://enterprise.example.com',
+                cmsURL: 'https://cms-local.example.com',
+                enterpriseURL: 'https://enterprise.example.com',
+                secureCookiePassword: 'secure-cookie-password',
+                forestAPIKey: 'forest-api-key',
+                saleChannelAccessKey: 'test-sales-channel-access',
+                salesChannelAPISecret: 'test-sales-channel-secret',
+                storeAccessKey: 'test-store-access',
+                storeAPISecret: 'test-store-secret',
+                isProduction: false,
+                posthogKey: 'posthog-key',
+                posthogDomain: 'posthog.example.com',
+                posthogHost: 'posthog.example.com',
+                assetsPath: '/assets',
+                assetsDomain: 'assets.example.com',
+                turnstileKey: 'turnstile-key',
+                turnstileSecret: 'turnstile-secret',
+                redis: {
+                    user: 'redis-user',
+                    host: 'localhost',
+                    password: 'redis-password',
+                    port: 6379,
+                },
+            };
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': 'shop123',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            // Chain all interceptors
+            const headersInterceptor = (0, interceptors_1.createHeadersInterceptor)(customHeaders);
+            const authInterceptor = (0, interceptors_1.createAuthenticationInterceptor)(mockCheckoutConfig);
+            const customerAuthInterceptor = (0, interceptors_1.createCustomerAuthenticationInterceptor)(jwtToken);
+            const loggingInterceptor = (0, interceptors_1.createLoggingInterceptor)();
+            const chainedInterceptor = headersInterceptor(authInterceptor(customerAuthInterceptor(loggingInterceptor(mockNext))));
+            const mockRequest = {
+                header: new Headers(),
+                method: {
+                    toString: () => 'TestService/TestMethod',
+                },
+                message: { $typeName: 'test.Message' },
+            };
+            yield chainedInterceptor(mockRequest);
+            // Verify all headers from all interceptors are set
+            expect(mockRequest.header.get('X-Original-Host')).toBe('example.com');
+            expect(mockRequest.header.get('X-shop-id')).toBe('shop123');
+            expect(mockRequest.header.get('X-Store-Key')).toBe('test-store-secret');
+            expect(mockRequest.header.get('Authorization')).toBe(`Bearer ${jwtToken}`);
+            expect(mockNext).toHaveBeenCalled();
+        }));
+        it('should validate headers before auth in chain', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockNext = vi.fn();
+            mockNext.mockResolvedValue({
+                header: new Headers(),
+                message: { $typeName: 'test.Message' },
+                trailer: new Headers(),
+            });
+            const mockCheckoutConfig = {
+                hostname: 'example.com',
+                cmsRemoteURL: 'https://cms.example.com',
+                enterpriseRemoteURL: 'https://enterprise.example.com',
+                cmsURL: 'https://cms-local.example.com',
+                enterpriseURL: 'https://enterprise.example.com',
+                secureCookiePassword: 'secure-cookie-password',
+                forestAPIKey: 'forest-api-key',
+                saleChannelAccessKey: 'test-sales-channel-access',
+                salesChannelAPISecret: 'test-sales-channel-secret',
+                storeAccessKey: 'test-store-access',
+                storeAPISecret: 'test-store-secret',
+                isProduction: false,
+                posthogKey: 'posthog-key',
+                posthogDomain: 'posthog.example.com',
+                posthogHost: 'posthog.example.com',
+                assetsPath: '/assets',
+                assetsDomain: 'assets.example.com',
+                turnstileKey: 'turnstile-key',
+                turnstileSecret: 'turnstile-secret',
+                redis: {
+                    user: 'redis-user',
+                    host: 'localhost',
+                    password: 'redis-password',
+                    port: 6379,
+                },
+            };
+            const invalidHeaders = {
+                // Missing x-shop-id
+                'x-original-host': 'example.com',
+                'x-sitepath': '/path',
+                'x-locale': 'en',
+                'x-region': 'US',
+            };
+            const headersInterceptor = (0, interceptors_1.createHeadersInterceptor)(invalidHeaders);
+            const authInterceptor = (0, interceptors_1.createAuthenticationInterceptor)(mockCheckoutConfig);
+            const chainedInterceptor = headersInterceptor(authInterceptor(mockNext));
+            const mockRequest = {
+                header: new Headers(),
+                message: { $typeName: 'test.Message' },
+            };
+            // Should fail at headers validation
+            yield expect(chainedInterceptor(mockRequest)).rejects.toThrow();
+            // Auth headers should not be set because headers validation failed
+            expect(mockRequest.header.get('X-Store-Key')).toBeNull();
+        }));
+    });
+});