@paakd/api 0.0.1 → 0.0.2

package/dist/src/auth.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.spec.d.ts","sourceRoot":"","sources":["../../src/auth.spec.ts"],"names":[],"mappings":""}

package/dist/src/auth.spec.js

@@ -0,0 +1,582 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const connect_1 = require("@connectrpc/connect");
+const connect_node_1 = require("@connectrpc/connect-node");
+const config_1 = require("@paakd/config");
+const auth_1 = require("./auth");
+const interceptors_1 = require("./interceptors");
+const test_utils_1 = require("./test-utils");
+// Mock dependencies
+vi.mock('@connectrpc/connect', () => __awaiter(void 0, void 0, void 0, function* () {
+    const actual = yield vi.importActual('@connectrpc/connect');
+    return Object.assign(Object.assign({}, actual), { createClient: vi.fn() });
+}));
+vi.mock('./compressor/brotli', () => ({
+    brotliCompression: {
+        name: 'brotli',
+        compress: vi.fn(),
+        decompress: vi.fn(),
+    },
+}));
+vi.mock('@connectrpc/connect-node', () => ({
+    createGrpcTransport: vi.fn(),
+}));
+vi.mock('@paakd/config', () => ({
+    getCheckoutConfig: vi.fn(),
+}));
+vi.mock('./interceptors', () => ({
+    createAuthenticationInterceptor: vi.fn(),
+    createCustomerAuthenticationInterceptor: vi.fn(),
+    createHeadersInterceptor: vi.fn(),
+}));
+vi.mock('../gen/src/proto/auth/v1/service_pb', () => ({
+    AuthService: {},
+}));
+vi.mock('../gen/src/proto/customers/v1/service_pb', () => ({
+    CustomerService: {},
+}));
+const mockGetCheckoutConfig = vi.mocked(config_1.getCheckoutConfig);
+const mockCreateGrpcTransport = vi.mocked(connect_node_1.createGrpcTransport);
+const mockCreateClient = vi.mocked(connect_1.createClient);
+const mockCreateAuthenticationInterceptor = vi.mocked(interceptors_1.createAuthenticationInterceptor);
+const mockCreateCustomerAuthenticationInterceptor = vi.mocked(interceptors_1.createCustomerAuthenticationInterceptor);
+const mockCreateHeadersInterceptor = vi.mocked(interceptors_1.createHeadersInterceptor);
+/**
+ * Setup function similar to testing-library's render.
+ * Initializes the testing environment with proper mocks
+ */
+function setupAuthService() {
+    (0, test_utils_1.clearAllMocks)();
+    const { config, interceptors, transport } = (0, test_utils_1.setupCommonMocks)();
+    const clients = {
+        auth: {
+            login: vi.fn(),
+            refreshToken: vi.fn(),
+        },
+        customer: {
+            changePassword: vi.fn(),
+        },
+    };
+    // Setup mock implementations
+    mockGetCheckoutConfig.mockResolvedValue(config);
+    mockCreateGrpcTransport.mockReturnValue(transport);
+    mockCreateHeadersInterceptor.mockImplementation(() => next => (req) => __awaiter(this, void 0, void 0, function* () {
+        return yield next(req);
+    }));
+    mockCreateAuthenticationInterceptor.mockImplementation(() => next => (req) => __awaiter(this, void 0, void 0, function* () {
+        return yield next(req);
+    }));
+    mockCreateCustomerAuthenticationInterceptor.mockImplementation(() => next => (req) => __awaiter(this, void 0, void 0, function* () {
+        return yield next(req);
+    }));
+    // mockCreateClient should intelligently return the right client
+    // The tests will set up their own expectations, but provide a smart default
+    mockCreateClient.mockImplementation(() => {
+        // Default to returning auth client, but tests can override as needed
+        return clients.auth;
+    });
+    return {
+        client: clients.auth,
+        clients,
+        config,
+        interceptors,
+        transport,
+    };
+}
+describe('Authentication Service', () => {
+    let consoleSpySpy;
+    beforeEach(() => {
+        consoleSpySpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleSpySpy.mockRestore();
+    });
+    describe('login', () => {
+        it('should successfully authenticate user with valid credentials', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const credentials = {
+                body: {
+                    email: 'user@example.com',
+                    password: 'password123',
+                },
+                headers: {
+                    'x-shop-id': '123',
+                },
+            };
+            const expectedResponse = {
+                jwt: 'token123',
+                refreshToken: 'refresh123',
+                expiresIn: 3600,
+            };
+            clients.auth.login.mockResolvedValue(expectedResponse);
+            const result = yield (0, auth_1.login)(credentials);
+            expect(result.status).toBe('success');
+            expect(result).toHaveProperty('value');
+            expect(clients.auth.login).toHaveBeenCalledWith({
+                email: credentials.body.email,
+                password: credentials.body.password,
+            });
+        }));
+        it('should reject user when credentials are invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Invalid credentials');
+            clients.auth.login.mockRejectedValue(error);
+            const result = yield (0, auth_1.login)({
+                body: {
+                    email: 'user@example.com',
+                    password: 'wrongpassword',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+            expect(result).toHaveProperty('code');
+        }));
+        it('should handle network failures gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const networkError = (0, test_utils_1.createMockConnectError)(14, 'UNAVAILABLE', 'Service unavailable');
+            clients.auth.login.mockRejectedValue(networkError);
+            const result = yield (0, auth_1.login)({
+                body: {
+                    email: 'user@example.com',
+                    password: 'password123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should include custom headers in request context', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const customHeaders = {
+                'x-original-host': 'example.com',
+                'x-shop-id': '456',
+                'x-locale': 'en-US',
+            };
+            clients.auth.login.mockResolvedValue({
+                jwt: 'new-token',
+                refreshToken: 'refresh-token',
+            });
+            yield (0, auth_1.login)({
+                body: {
+                    email: 'user@example.com',
+                    password: 'password123',
+                },
+                headers: customHeaders,
+            });
+            expect(mockCreateHeadersInterceptor).toHaveBeenCalledWith(customHeaders);
+        }));
+        it('should use checkout configuration for enterprise URL', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients, config } = setupAuthService();
+            const jwt = 'token-xyz';
+            clients.auth.login.mockResolvedValue({ jwt });
+            yield (0, auth_1.login)({
+                body: {
+                    email: 'user@example.com',
+                    password: 'password123',
+                },
+                headers: {},
+            });
+            expect(mockCreateGrpcTransport).toHaveBeenCalledWith(expect.objectContaining({
+                baseUrl: config.enterpriseURL,
+            }));
+        }));
+        it('should enable compression for optimized data transfer', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const jwt = 'token-for-compression-test';
+            clients.auth.login.mockResolvedValue({ jwt });
+            yield (0, auth_1.login)({
+                body: {
+                    email: 'user@example.com',
+                    password: 'password123',
+                },
+                headers: {},
+            });
+            const transportConfig = mockCreateGrpcTransport.mock.calls[0][0];
+            expect(transportConfig).toHaveProperty('acceptCompression');
+            expect(transportConfig).toHaveProperty('sendCompression');
+        }));
+        it('should handle service unavailability', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const error = (0, test_utils_1.createMockConnectError)(14, 'UNAVAILABLE', 'Service temporarily unavailable');
+            clients.auth.login.mockRejectedValue(error);
+            const result = yield (0, auth_1.login)({
+                body: {
+                    email: 'user@example.com',
+                    password: 'password123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should support multiple concurrent login attempts', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const mockResponse = {
+                jwt: 'concurrent-token',
+                refreshToken: 'concurrent-refresh',
+            };
+            clients.auth.login.mockResolvedValue(mockResponse);
+            const results = yield Promise.all([
+                (0, auth_1.login)({
+                    body: {
+                        email: 'user1@example.com',
+                        password: 'password123',
+                    },
+                    headers: {},
+                }),
+                (0, auth_1.login)({
+                    body: {
+                        email: 'user2@example.com',
+                        password: 'password456',
+                    },
+                    headers: {},
+                }),
+                (0, auth_1.login)({
+                    body: {
+                        email: 'user3@example.com',
+                        password: 'password789',
+                    },
+                    headers: {},
+                }),
+            ]);
+            expect(results).toHaveLength(3);
+            expect(results.every(r => r.status === 'success')).toBe(true);
+        }));
+    });
+    describe('refreshToken', () => {
+        it('should refresh authentication token with valid refresh token', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const refreshTokenValue = 'refresh-token-123';
+            const expectedResponse = {
+                jwt: 'new-jwt-token',
+                refreshToken: 'new-refresh-token',
+                expiresIn: 3600,
+            };
+            clients.auth.refreshToken.mockResolvedValue(expectedResponse);
+            const result = yield (0, auth_1.refreshToken)({
+                body: {
+                    refreshToken: refreshTokenValue,
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(clients.auth.refreshToken).toHaveBeenCalledWith({
+                refreshToken: refreshTokenValue,
+            });
+        }));
+        it('should reject expired refresh tokens', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Refresh token expired');
+            clients.auth.refreshToken.mockRejectedValue(error);
+            const result = yield (0, auth_1.refreshToken)({
+                body: {
+                    refreshToken: 'expired-refresh-token',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should handle missing or malformed refresh tokens', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const error = (0, test_utils_1.createMockConnectError)(3, 'INVALID_ARGUMENT', 'Invalid refresh token format');
+            clients.auth.refreshToken.mockRejectedValue(error);
+            const result = yield (0, auth_1.refreshToken)({
+                body: {
+                    refreshToken: '',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should recover gracefully from service errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const serviceError = (0, test_utils_1.createMockConnectError)(13, 'INTERNAL', 'Internal server error');
+            clients.auth.refreshToken.mockRejectedValue(serviceError);
+            const result = yield (0, auth_1.refreshToken)({
+                body: {
+                    refreshToken: 'valid-refresh-token',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should use authentication interceptor for token refresh', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const refreshTokenValue = 'refresh-token-abc';
+            clients.auth.refreshToken.mockResolvedValue({
+                jwt: 'new-jwt-token',
+                refreshToken: 'new-refresh-token',
+            });
+            yield (0, auth_1.refreshToken)({
+                body: {
+                    refreshToken: refreshTokenValue,
+                },
+                headers: {},
+            });
+            expect(mockCreateAuthenticationInterceptor).toHaveBeenCalled();
+        }));
+    });
+    describe('changePassword', () => {
+        it('should successfully change user password with correct current password', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const passwordChange = {
+                body: {
+                    jwt: 'user-jwt-token',
+                    customerId: 'cust-1',
+                    oldPassword: 'oldpassword123',
+                    newPassword: 'newpassword456',
+                },
+                headers: {},
+            };
+            const success = { jwt: 'updated-jwt-token' };
+            clients.customer.changePassword.mockResolvedValue(success);
+            // For changePassword test, we need mockCreateClient to return customer client
+            mockCreateClient.mockReturnValue(clients.customer);
+            const result = yield (0, auth_1.changePassword)(passwordChange);
+            expect(result.status).toBe('success');
+            expect(result).toHaveProperty('value');
+        }));
+        it('should reject when current password is incorrect', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Current password is incorrect');
+            clients.customer.changePassword.mockRejectedValue(error);
+            mockCreateClient.mockReturnValue(clients.customer);
+            const result = yield (0, auth_1.changePassword)({
+                body: {
+                    jwt: 'user-jwt-token',
+                    customerId: 'cust-1',
+                    oldPassword: 'wrongpassword',
+                    newPassword: 'newpassword456',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should enforce password complexity requirements', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const error = (0, test_utils_1.createMockConnectError)(3, 'INVALID_ARGUMENT', 'Password does not meet complexity requirements');
+            clients.customer.changePassword.mockRejectedValue(error);
+            mockCreateClient.mockReturnValue(clients.customer);
+            const result = yield (0, auth_1.changePassword)({
+                body: {
+                    jwt: 'user-jwt-token',
+                    customerId: 'cust-1',
+                    oldPassword: 'oldpassword123',
+                    newPassword: 'weak',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should reject requests with invalid or expired JWT', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Invalid or expired JWT');
+            clients.customer.changePassword.mockRejectedValue(error);
+            mockCreateClient.mockReturnValue(clients.customer);
+            const result = yield (0, auth_1.changePassword)({
+                body: {
+                    jwt: 'expired-jwt-token',
+                    customerId: 'cust-1',
+                    oldPassword: 'oldpassword123',
+                    newPassword: 'newpassword456',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should not include JWT in service request', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const success = { jwt: 'updated-jwt-token' };
+            clients.customer.changePassword.mockResolvedValue(success);
+            mockCreateClient.mockReturnValue(clients.customer);
+            const jwtToken = 'user-jwt-token';
+            const passwordData = {
+                body: {
+                    jwt: jwtToken,
+                    customerId: 'cust-1',
+                    oldPassword: 'oldpassword123',
+                    newPassword: 'newpassword456',
+                },
+                headers: {},
+            };
+            yield (0, auth_1.changePassword)(passwordData);
+            // Verify that JWT is not passed directly to the service
+            const callArgs = clients.customer.changePassword.mock.calls[0][0];
+            expect(callArgs).not.toHaveProperty('jwt');
+        }));
+        it('should apply three interceptors in correct order', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients, interceptors } = setupAuthService();
+            const success = { jwt: 'updated-jwt-token' };
+            clients.customer.changePassword.mockResolvedValue(success);
+            mockCreateClient.mockReturnValue(clients.customer);
+            const headers = {
+                'x-shop-id': '123',
+            };
+            const jwt = 'user-jwt-token';
+            yield (0, auth_1.changePassword)({
+                body: {
+                    customerId: 'cust-1',
+                    oldPassword: 'oldpassword123',
+                    newPassword: 'newpassword456',
+                    jwt,
+                },
+                headers,
+            });
+            expect(mockCreateHeadersInterceptor).toHaveBeenCalledWith(headers);
+            expect(mockCreateAuthenticationInterceptor).toHaveBeenCalled();
+            expect(mockCreateCustomerAuthenticationInterceptor).toHaveBeenCalledWith(jwt);
+        }));
+        it('should handle database errors gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const dbError = (0, test_utils_1.createMockConnectError)(13, 'INTERNAL', 'Database error occurred');
+            clients.customer.changePassword.mockRejectedValue(dbError);
+            mockCreateClient.mockReturnValue(clients.customer);
+            const result = yield (0, auth_1.changePassword)({
+                body: {
+                    jwt: 'user-jwt-token',
+                    customerId: 'cust-1',
+                    oldPassword: 'oldpassword123',
+                    newPassword: 'newpassword456',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should handle permission errors when user cannot change password', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const error = (0, test_utils_1.createMockConnectError)(7, 'PERMISSION_DENIED', 'User does not have permission to change password');
+            clients.customer.changePassword.mockRejectedValue(error);
+            mockCreateClient.mockReturnValue(clients.customer);
+            const result = yield (0, auth_1.changePassword)({
+                body: {
+                    jwt: 'restricted-jwt-token',
+                    customerId: 'cust-1',
+                    oldPassword: 'oldpassword123',
+                    newPassword: 'newpassword456',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+    });
+    describe('Common Authentication Behavior', () => {
+        it('should load configuration once per request', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            clients.auth.login.mockResolvedValue({
+                jwt: 'token123',
+                refreshToken: 'refresh123',
+            });
+            yield (0, auth_1.login)({
+                body: {
+                    email: 'user@example.com',
+                    password: 'password123',
+                },
+                headers: {},
+            });
+            yield (0, auth_1.login)({
+                body: {
+                    email: 'user2@example.com',
+                    password: 'password456',
+                },
+                headers: {},
+            });
+            expect(mockGetCheckoutConfig).toHaveBeenCalledTimes(2);
+        }));
+        it('should support different error scenarios across functions', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const errorScenarios = [
+                {
+                    code: 16,
+                    message: 'UNAUTHENTICATED',
+                    fn: auth_1.login,
+                    args: {
+                        body: {
+                            email: 'user@example.com',
+                            password: 'invalid',
+                        },
+                        headers: {},
+                    },
+                },
+                {
+                    code: 16,
+                    message: 'UNAUTHENTICATED',
+                    fn: auth_1.refreshToken,
+                    args: {
+                        body: {
+                            refreshToken: 'expired-token',
+                        },
+                        headers: {},
+                    },
+                },
+                {
+                    code: 16,
+                    message: 'UNAUTHENTICATED',
+                    fn: auth_1.changePassword,
+                    args: {
+                        body: {
+                            jwt: 'invalid-jwt',
+                            customerId: 'cust-1',
+                            oldPassword: 'old',
+                            newPassword: 'new',
+                        },
+                        headers: {},
+                    },
+                },
+            ];
+            for (const scenario of errorScenarios) {
+                const error = (0, test_utils_1.createMockConnectError)(scenario.code, scenario.message, scenario.message);
+                if (scenario.fn === auth_1.login) {
+                    clients.auth.login.mockRejectedValueOnce(error);
+                }
+                else if (scenario.fn === auth_1.refreshToken) {
+                    clients.auth.refreshToken.mockRejectedValueOnce(error);
+                }
+                else {
+                    clients.customer.changePassword.mockRejectedValueOnce(error);
+                }
+                const result = yield scenario.fn(scenario.args);
+                expect(result.status).toBe('failed');
+            }
+        }));
+        it('should handle edge cases with special characters and long inputs', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const jwt = 'special-chars-token-!@#$%^&*()';
+            clients.auth.login.mockResolvedValue({
+                jwt: 'new-token',
+            });
+            const result = yield (0, auth_1.login)({
+                body: {
+                    email: 'user+tag@example.com',
+                    password: 'P@ssw0rd!@#$%^&*()',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+        }));
+        it('should handle null or undefined headers gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clients } = setupAuthService();
+            const jwt = 'test-jwt-token';
+            clients.auth.login.mockResolvedValue({
+                jwt: 'token123',
+                refreshToken: 'refresh123',
+            });
+            const result = yield (0, auth_1.login)({
+                body: {
+                    email: 'user@example.com',
+                    password: 'password123',
+                },
+                headers: {
+                    'x-header': null,
+                },
+            });
+            expect(result.status).toBe('success');
+        }));
+    });
+});

package/dist/src/compressor/brotli.d.ts

@@ -0,0 +1,3 @@
+import { type Compression } from '@connectrpc/connect/protocol';
+export declare const brotliCompression: Compression;
+//# sourceMappingURL=brotli.d.ts.map

package/dist/src/compressor/brotli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brotli.d.ts","sourceRoot":"","sources":["../../../src/compressor/brotli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAI/D,eAAO,MAAM,iBAAiB,EAAE,WAqB/B,CAAA"}

package/dist/src/compressor/brotli.js

@@ -0,0 +1,30 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.brotliCompression = void 0;
+const brotli = require('brotli');
+exports.brotliCompression = {
+    name: 'br',
+    compress: (bytes) => __awaiter(void 0, void 0, void 0, function* () {
+        return new Uint8Array(brotli.compress(bytes, {
+            mode: 0, // 0 = generic, 1 = text, 2 = font (WOFF2)
+            quality: 9, // 0 - 11
+            lgwin: 22, // window size
+        }));
+    }),
+    decompress: (bytes, readMaxBytes) => __awaiter(void 0, void 0, void 0, function* () {
+        const decompressed = brotli.decompress(bytes);
+        if (decompressed.length > readMaxBytes) {
+            throw new Error('Decompressed size exceeds readMaxBytes limit');
+        }
+        return new Uint8Array(decompressed);
+    }),
+};

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './address';
+export * from './auth';
+export * from './policies';
+export * from './profile';
+export * from './registration';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,QAAQ,CAAA;AACtB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,gBAAgB,CAAA"}

package/dist/src/interceptors.d.ts

@@ -0,0 +1,16 @@
+import type { Message } from '@bufbuild/protobuf';
+import { type Interceptor, type StreamRequest, type UnaryRequest } from '@connectrpc/connect';
+import type { Checkout } from '@paakd/config';
+export interface RequestLogger {
+    onRequestHeader?: (header: Headers) => void;
+    onRequestMessage?: (message: Message) => void;
+    onResponseHeader?: (header: Headers) => void;
+    onResponseMessage?: (message: Message) => void;
+    onResponseTrailer?: (trailer: Headers) => void;
+    onError?: (error: unknown) => void;
+}
+export declare function createLoggingInterceptor(reqLogger?: (request: UnaryRequest | StreamRequest) => RequestLogger): Interceptor;
+export declare function createAuthenticationInterceptor(checkoutConfig: Checkout): Interceptor;
+export declare function createCustomerAuthenticationInterceptor(jwtKey: string): Interceptor;
+export declare function createHeadersInterceptor(headers: Record<string, string | null>): Interceptor;
+//# sourceMappingURL=interceptors.d.ts.map

package/dist/src/interceptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptors.d.ts","sourceRoot":"","sources":["../../src/interceptors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,aAAa,EAElB,KAAK,YAAY,EAElB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C,MAAM,WAAW,aAAa;IAC5B,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;IAC3C,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAC7C,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;IAC5C,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAC9C,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAC9C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACnC;AA4BD,wBAAgB,wBAAwB,CACtC,SAAS,GAAE,CACT,OAAO,EAAE,YAAY,GAAG,aAAa,KAClC,aAAoC,GACxC,WAAW,CAab;AAED,wBAAgB,+BAA+B,CAC7C,cAAc,EAAE,QAAQ,GACvB,WAAW,CASb;AAED,wBAAgB,uCAAuC,CACrD,MAAM,EAAE,MAAM,GACb,WAAW,CAYb;AAsFD,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,GACrC,WAAW,CA0Cb"}