@paakd/api 0.0.4 → 0.0.5

package/dist/src/auth.spec.js

@@ -1,582 +0,0 @@
-"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

@@ -1,3 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,30 +0,0 @@
-"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);
-    }),
-};