@go-mondo/identity-sdk 0.0.2-beta.8 → 0.0.2-beta.9

package/dist/cjs/common/resources/init.test.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const init_js_1 = require("./init.js");
+(0, vitest_1.describe)('Common Resources - Init', () => {
+    (0, vitest_1.describe)('MondoIdentity class', () => {
+        (0, vitest_1.describe)('constructor', () => {
+            (0, vitest_1.test)('should initialize with valid config including access token', () => {
+                const config = {
+                    accessToken: 'test-access-token',
+                    host: 'https://api.example.com',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                (0, vitest_1.expect)(mondoIdentity.config.accessToken).toBe('test-access-token');
+                (0, vitest_1.expect)(mondoIdentity.config.host.toString()).toBe(`${config.host}/`);
+            });
+            (0, vitest_1.test)('should use default host when not provided', () => {
+                const config = {
+                    accessToken: 'test-access-token',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                (0, vitest_1.expect)(mondoIdentity.config.accessToken).toBe('test-access-token');
+                (0, vitest_1.expect)(mondoIdentity.config.host.toString()).toBe('https://manage-api.mondoidentity.com/');
+            });
+            (0, vitest_1.test)('should parse URL host correctly', () => {
+                const config = {
+                    accessToken: 'test-token',
+                    host: 'https://custom-api.domain.com:8080/path',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                (0, vitest_1.expect)(mondoIdentity.config.host.toString()).toBe(config.host);
+            });
+            (0, vitest_1.test)('should throw error when access token is missing', () => {
+                const config = {
+                    host: 'https://api.example.com',
+                };
+                (0, vitest_1.expect)(() => new init_js_1.MondoIdentity(config)).toThrow('Invalid configuration');
+            });
+            (0, vitest_1.test)('should throw error when access token is empty', () => {
+                const config = {
+                    accessToken: '',
+                    host: 'https://api.example.com',
+                };
+                (0, vitest_1.expect)(() => new init_js_1.MondoIdentity(config)).toThrow('Invalid configuration');
+            });
+            (0, vitest_1.test)('should throw error when host is invalid URL', () => {
+                const config = {
+                    accessToken: 'test-token',
+                    host: 'not-a-valid-url',
+                };
+                (0, vitest_1.expect)(() => new init_js_1.MondoIdentity(config)).toThrow('Invalid configuration');
+            });
+            (0, vitest_1.test)('should throw error when host is not a string', () => {
+                const config = {
+                    accessToken: 'test-token',
+                    host: 123,
+                };
+                (0, vitest_1.expect)(() => new init_js_1.MondoIdentity(config)).toThrow('Invalid configuration');
+            });
+            (0, vitest_1.test)('should throw error when access token is not a string', () => {
+                const config = {
+                    accessToken: 123,
+                    host: 'https://api.example.com',
+                };
+                (0, vitest_1.expect)(() => new init_js_1.MondoIdentity(config)).toThrow('Invalid configuration');
+            });
+        });
+        (0, vitest_1.describe)('config property', () => {
+            (0, vitest_1.test)('should be readonly', () => {
+                const config = {
+                    accessToken: 'test-token',
+                    host: 'https://api.example.com',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                // Config should be accessible
+                (0, vitest_1.expect)(mondoIdentity.config).toBeDefined();
+                (0, vitest_1.expect)(mondoIdentity.config.accessToken).toBe('test-token');
+            });
+            (0, vitest_1.test)('should preserve original config values', () => {
+                const config = {
+                    accessToken: 'my-secret-token',
+                    host: 'https://staging-api.mondoidentity.com',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                (0, vitest_1.expect)(mondoIdentity.config.accessToken).toBe('my-secret-token');
+                (0, vitest_1.expect)(mondoIdentity.config.host).instanceOf(URL);
+                (0, vitest_1.expect)(mondoIdentity.config.host.toString()).toBe(`${config.host}/`);
+            });
+        });
+        (0, vitest_1.describe)('authorizer property', () => {
+            (0, vitest_1.test)('should return function that adds authorization header when access token is provided', () => {
+                const config = {
+                    accessToken: 'bearer-token-123',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                const authorizer = mondoIdentity.authorizer;
+                (0, vitest_1.expect)(typeof authorizer).toBe('function');
+                const mockRequest = {
+                    method: 'GET',
+                    headers: {},
+                };
+                const authorizedRequest = authorizer(mockRequest);
+                (0, vitest_1.expect)(authorizedRequest.headers).toBeInstanceOf(Headers);
+                const headers = authorizedRequest.headers;
+                (0, vitest_1.expect)(headers.get('authorization')).toBe('bearer-token-123');
+            });
+            (0, vitest_1.test)('should preserve existing headers when adding authorization', () => {
+                const config = {
+                    accessToken: 'test-token',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                const authorizer = mondoIdentity.authorizer;
+                const mockRequest = {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        'user-agent': 'test-client',
+                    },
+                };
+                const authorizedRequest = authorizer(mockRequest);
+                const headers = authorizedRequest.headers;
+                (0, vitest_1.expect)(headers.get('authorization')).toBe('test-token');
+                (0, vitest_1.expect)(headers.get('content-type')).toBe('application/json');
+                (0, vitest_1.expect)(headers.get('user-agent')).toBe('test-client');
+            });
+            (0, vitest_1.test)('should handle Headers object as input', () => {
+                const config = {
+                    accessToken: 'header-token',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                const authorizer = mondoIdentity.authorizer;
+                const existingHeaders = new Headers({
+                    accept: 'application/json',
+                });
+                const mockRequest = {
+                    method: 'GET',
+                    headers: existingHeaders,
+                };
+                const authorizedRequest = authorizer(mockRequest);
+                const headers = authorizedRequest.headers;
+                (0, vitest_1.expect)(headers.get('authorization')).toBe('header-token');
+                (0, vitest_1.expect)(headers.get('accept')).toBe('application/json');
+            });
+            (0, vitest_1.test)('should handle undefined headers', () => {
+                const config = {
+                    accessToken: 'undefined-headers-token',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                const authorizer = mondoIdentity.authorizer;
+                const mockRequest = {
+                    method: 'GET',
+                    // headers intentionally undefined
+                };
+                const authorizedRequest = authorizer(mockRequest);
+                const headers = authorizedRequest.headers;
+                (0, vitest_1.expect)(headers.get('authorization')).toBe('undefined-headers-token');
+            });
+            (0, vitest_1.test)('should return same request reference with modified headers', () => {
+                const config = {
+                    accessToken: 'reference-token',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                const authorizer = mondoIdentity.authorizer;
+                const mockRequest = {
+                    method: 'PUT',
+                    body: 'test-body',
+                };
+                const authorizedRequest = authorizer(mockRequest);
+                // Should be the same object reference
+                (0, vitest_1.expect)(authorizedRequest).toBe(mockRequest);
+                (0, vitest_1.expect)(authorizedRequest.method).toBe('PUT');
+                (0, vitest_1.expect)(authorizedRequest.body).toBe('test-body');
+            });
+            (0, vitest_1.test)('should be a getter that returns consistent function', () => {
+                const config = {
+                    accessToken: 'consistent-token',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                // Getting authorizer multiple times should return the same function behavior
+                const authorizer1 = mondoIdentity.authorizer;
+                const authorizer2 = mondoIdentity.authorizer;
+                const mockRequest1 = { method: 'GET' };
+                const mockRequest2 = { method: 'POST' };
+                const result1 = authorizer1(mockRequest1);
+                const result2 = authorizer2(mockRequest2);
+                const headers1 = result1.headers;
+                const headers2 = result2.headers;
+                (0, vitest_1.expect)(headers1.get('authorization')).toBe('consistent-token');
+                (0, vitest_1.expect)(headers2.get('authorization')).toBe('consistent-token');
+            });
+        });
+        (0, vitest_1.describe)('integration tests', () => {
+            (0, vitest_1.test)('should work with real-world configuration', () => {
+                const config = {
+                    accessToken: 'prod_12345abcdef67890',
+                    host: 'https://api.mondoidentity.com/v1',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                const authorizer = mondoIdentity.authorizer;
+                // Test configuration
+                (0, vitest_1.expect)(mondoIdentity.config.accessToken).toBe('prod_12345abcdef67890');
+                (0, vitest_1.expect)(mondoIdentity.config.host).instanceOf(URL);
+                (0, vitest_1.expect)(mondoIdentity.config.host.toString()).toBe(config.host);
+                // Test authorization
+                const apiRequest = {
+                    method: 'GET',
+                    headers: {
+                        accept: 'application/json',
+                        'user-agent': 'mondo-identity-sdk/1.0.0',
+                    },
+                };
+                const authorizedRequest = authorizer(apiRequest);
+                const headers = authorizedRequest.headers;
+                (0, vitest_1.expect)(headers.get('authorization')).toBe('prod_12345abcdef67890');
+                (0, vitest_1.expect)(headers.get('accept')).toBe('application/json');
+                (0, vitest_1.expect)(headers.get('user-agent')).toBe('mondo-identity-sdk/1.0.0');
+            });
+            (0, vitest_1.test)('should handle edge cases gracefully', () => {
+                const config = {
+                    accessToken: 'edge-case-token-with-special-chars!@#$%^&*()',
+                    host: 'https://localhost:3000',
+                };
+                const mondoIdentity = new init_js_1.MondoIdentity(config);
+                (0, vitest_1.expect)(() => {
+                    const authorizer = mondoIdentity.authorizer;
+                    const request = authorizer({ method: 'OPTIONS' });
+                    const headers = request.headers;
+                    headers.get('authorization');
+                }).not.toThrow();
+            });
+        });
+    });
+});

package/dist/cjs/common/resources/operations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=operations.test.d.ts.map

package/dist/cjs/common/resources/operations.test.d.ts.map

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

package/dist/cjs/common/resources/operations.test.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const http_js_1 = require("../errors/http.js");
+const validation_js_1 = require("../errors/validation.js");
+const operations_js_1 = require("./operations.js");
+// Mock console.debug to avoid noise in tests
+global.console.debug = vitest_1.vi.fn();
+// Mock fetch globally
+const mockFetch = vitest_1.vi.fn();
+global.fetch = mockFetch;
+(0, vitest_1.describe)('Common Resources - Operations', () => {
+    let mockAuthorization;
+    let testUrl;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        // Create mock authorization function
+        mockAuthorization = vitest_1.vi.fn((request) => ({
+            ...request,
+            headers: new Headers({
+                ...Object.fromEntries(request.headers?.entries() || []),
+                authorization: 'Bearer test-token',
+            }),
+        }));
+        testUrl = new URL('https://api.example.com/resource');
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.describe)('listItemsWithAuthorization', () => {
+        (0, vitest_1.test)('should successfully list items with valid response', async () => {
+            const mockData = { items: [{ id: 1, name: 'Item 1' }] };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockData),
+            });
+            const result = await (0, operations_js_1.listItemsWithAuthorization)(testUrl, mockAuthorization);
+            (0, vitest_1.expect)(result).toEqual(mockData);
+            (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith(testUrl, vitest_1.expect.objectContaining({
+                method: 'GET',
+                headers: vitest_1.expect.any(Headers),
+            }));
+            (0, vitest_1.expect)(mockAuthorization).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                method: 'GET',
+                headers: vitest_1.expect.any(Headers),
+            }));
+        });
+        (0, vitest_1.test)('should include correct default headers', async () => {
+            const mockData = { items: [] };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockData),
+            });
+            await (0, operations_js_1.listItemsWithAuthorization)(testUrl, mockAuthorization);
+            const authCall = mockAuthorization.mock.calls[0][0];
+            const headers = authCall.headers;
+            (0, vitest_1.expect)(headers.get('accept')).toBe('application/json');
+        });
+        (0, vitest_1.test)('should throw HttpError when response is not ok', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+                json: () => Promise.resolve({
+                    error: 'not_found',
+                    error_description: 'Resource not found',
+                }),
+            });
+            await (0, vitest_1.expect)((0, operations_js_1.listItemsWithAuthorization)(testUrl, mockAuthorization)).rejects.toThrow(http_js_1.HttpError);
+        });
+        (0, vitest_1.test)('should handle network errors', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('Network error'));
+            await (0, vitest_1.expect)((0, operations_js_1.listItemsWithAuthorization)(testUrl, mockAuthorization)).rejects.toThrow(http_js_1.HttpError);
+        });
+        (0, vitest_1.test)('should log debug information', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            await (0, operations_js_1.listItemsWithAuthorization)(testUrl, mockAuthorization);
+            (0, vitest_1.expect)(console.debug).toHaveBeenCalledWith('List items', {
+                url: testUrl,
+            });
+        });
+    });
+    (0, vitest_1.describe)('getItemWithAuthorization', () => {
+        (0, vitest_1.test)('should successfully get item with valid response', async () => {
+            const mockData = { id: 1, name: 'Test Item' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockData),
+            });
+            const result = await (0, operations_js_1.getItemWithAuthorization)(testUrl, mockAuthorization);
+            (0, vitest_1.expect)(result).toEqual(mockData);
+            (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith(testUrl, vitest_1.expect.objectContaining({
+                method: 'GET',
+                headers: vitest_1.expect.any(Headers),
+            }));
+        });
+        (0, vitest_1.test)('should handle authorization errors', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 401,
+                json: () => Promise.resolve({
+                    error: 'unauthorized',
+                    error_description: 'Invalid token',
+                }),
+            });
+            await (0, vitest_1.expect)((0, operations_js_1.getItemWithAuthorization)(testUrl, mockAuthorization)).rejects.toThrow(http_js_1.HttpError);
+        });
+        (0, vitest_1.test)('should log debug information', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            await (0, operations_js_1.getItemWithAuthorization)(testUrl, mockAuthorization);
+            (0, vitest_1.expect)(console.debug).toHaveBeenCalledWith('Get item', { url: testUrl });
+        });
+    });
+    (0, vitest_1.describe)('updateItemWithAuthorization', () => {
+        (0, vitest_1.test)('should successfully update item', async () => {
+            const updateData = { name: 'Updated Item' };
+            const responseData = { id: 1, name: 'Updated Item' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(responseData),
+            });
+            const result = await (0, operations_js_1.updateItemWithAuthorization)(testUrl, mockAuthorization, updateData);
+            (0, vitest_1.expect)(result).toEqual(responseData);
+            (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith(testUrl, vitest_1.expect.objectContaining({
+                method: 'PUT',
+                headers: vitest_1.expect.any(Headers),
+                body: JSON.stringify(updateData),
+            }));
+        });
+        (0, vitest_1.test)('should include correct headers for mutations', async () => {
+            const updateData = { name: 'Test' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            await (0, operations_js_1.updateItemWithAuthorization)(testUrl, mockAuthorization, updateData);
+            const authCall = mockAuthorization.mock.calls[0][0];
+            const headers = authCall.headers;
+            (0, vitest_1.expect)(headers.get('accept')).toBe('application/json');
+            (0, vitest_1.expect)(headers.get('content-type')).toBe('application/json');
+        });
+        (0, vitest_1.test)('should handle validation errors', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                json: () => Promise.resolve({
+                    error: 'validation_error',
+                    error_description: 'Invalid input',
+                    fields: { name: ['required'] },
+                }),
+            });
+            await (0, vitest_1.expect)((0, operations_js_1.updateItemWithAuthorization)(testUrl, mockAuthorization, {})).rejects.toThrow(validation_js_1.ValidationError);
+        });
+        (0, vitest_1.test)('should log debug information with item data', async () => {
+            const updateData = { name: 'Test Item' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            await (0, operations_js_1.updateItemWithAuthorization)(testUrl, mockAuthorization, updateData);
+            (0, vitest_1.expect)(console.debug).toHaveBeenCalledWith('Update item', {
+                url: testUrl,
+                item: updateData,
+            });
+        });
+    });
+    (0, vitest_1.describe)('insertItemWithAuthorization', () => {
+        (0, vitest_1.test)('should successfully insert item with data', async () => {
+            const insertData = { name: 'New Item' };
+            const responseData = { id: 1, name: 'New Item' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(responseData),
+            });
+            const result = await (0, operations_js_1.insertItemWithAuthorization)(testUrl, mockAuthorization, insertData);
+            (0, vitest_1.expect)(result).toEqual(responseData);
+            (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith(testUrl, vitest_1.expect.objectContaining({
+                method: 'POST',
+                headers: vitest_1.expect.any(Headers),
+                body: JSON.stringify(insertData),
+            }));
+        });
+        (0, vitest_1.test)('should handle insert without data (undefined body)', async () => {
+            const responseData = { id: 1, status: 'created' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(responseData),
+            });
+            const result = await (0, operations_js_1.insertItemWithAuthorization)(testUrl, mockAuthorization);
+            (0, vitest_1.expect)(result).toEqual(responseData);
+            (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith(testUrl, vitest_1.expect.objectContaining({
+                method: 'POST',
+                headers: vitest_1.expect.any(Headers),
+                body: undefined,
+            }));
+        });
+        (0, vitest_1.test)('should handle insert with null data', async () => {
+            const responseData = { id: 1 };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(responseData),
+            });
+            const result = await (0, operations_js_1.insertItemWithAuthorization)(testUrl, mockAuthorization, null);
+            (0, vitest_1.expect)(result).toEqual(responseData);
+            (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith(testUrl, vitest_1.expect.objectContaining({
+                method: 'POST',
+                body: undefined,
+            }));
+        });
+        (0, vitest_1.test)('should handle server errors', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                json: () => Promise.resolve({
+                    error: 'internal_error',
+                    error_description: 'Internal server error',
+                }),
+            });
+            await (0, vitest_1.expect)((0, operations_js_1.insertItemWithAuthorization)(testUrl, mockAuthorization, {})).rejects.toThrow(http_js_1.HttpError);
+        });
+        (0, vitest_1.test)('should log debug information', async () => {
+            const insertData = { name: 'Test' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            await (0, operations_js_1.insertItemWithAuthorization)(testUrl, mockAuthorization, insertData);
+            (0, vitest_1.expect)(console.debug).toHaveBeenCalledWith('Insert item', {
+                url: testUrl,
+                item: insertData,
+            });
+        });
+    });
+    (0, vitest_1.describe)('deleteItemWithAuthorization', () => {
+        (0, vitest_1.test)('should successfully delete item', async () => {
+            const responseData = { deleted: true };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(responseData),
+            });
+            const result = await (0, operations_js_1.deleteItemWithAuthorization)(testUrl, mockAuthorization);
+            (0, vitest_1.expect)(result).toEqual(responseData);
+            (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith(testUrl, vitest_1.expect.objectContaining({
+                method: 'DELETE',
+                headers: vitest_1.expect.any(Headers),
+            }));
+        });
+        (0, vitest_1.test)('should handle empty response body', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.reject(new Error('No JSON body')),
+            });
+            const result = await (0, operations_js_1.deleteItemWithAuthorization)(testUrl, mockAuthorization);
+            (0, vitest_1.expect)(result).toBeUndefined();
+        });
+        (0, vitest_1.test)('should use default headers (not mutation headers)', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            await (0, operations_js_1.deleteItemWithAuthorization)(testUrl, mockAuthorization);
+            const authCall = mockAuthorization.mock.calls[0][0];
+            const headers = authCall.headers;
+            (0, vitest_1.expect)(headers.get('accept')).toBe('application/json');
+            (0, vitest_1.expect)(headers.get('content-type')).toBeNull();
+        });
+        (0, vitest_1.test)('should handle not found errors', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+                json: () => Promise.resolve({
+                    error: 'not_found',
+                    error_description: 'Resource not found',
+                }),
+            });
+            await (0, vitest_1.expect)((0, operations_js_1.deleteItemWithAuthorization)(testUrl, mockAuthorization)).rejects.toThrow(http_js_1.HttpError);
+        });
+        (0, vitest_1.test)('should log debug information', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            await (0, operations_js_1.deleteItemWithAuthorization)(testUrl, mockAuthorization);
+            (0, vitest_1.expect)(console.debug).toHaveBeenCalledWith('Delete item', {
+                url: testUrl,
+            });
+        });
+    });
+    (0, vitest_1.describe)('authorization integration', () => {
+        (0, vitest_1.test)('should call authorization function for all operations', async () => {
+            const operations = [
+                () => (0, operations_js_1.listItemsWithAuthorization)(testUrl, mockAuthorization),
+                () => (0, operations_js_1.getItemWithAuthorization)(testUrl, mockAuthorization),
+                () => (0, operations_js_1.updateItemWithAuthorization)(testUrl, mockAuthorization, {}),
+                () => (0, operations_js_1.insertItemWithAuthorization)(testUrl, mockAuthorization, {}),
+                () => (0, operations_js_1.deleteItemWithAuthorization)(testUrl, mockAuthorization),
+            ];
+            // Mock successful responses for all operations
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            for (const operation of operations) {
+                await operation();
+                (0, vitest_1.expect)(mockAuthorization).toHaveBeenCalled();
+                vitest_1.vi.clearAllMocks();
+            }
+        });
+        (0, vitest_1.test)('should preserve authorization modifications across operations', async () => {
+            const customAuth = (request) => ({
+                ...request,
+                headers: new Headers({
+                    ...Object.fromEntries(request.headers?.entries() || []),
+                    authorization: 'Bearer custom-token',
+                    'x-custom-header': 'custom-value',
+                }),
+            });
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            await (0, operations_js_1.getItemWithAuthorization)(testUrl, customAuth);
+            const fetchCall = mockFetch.mock.calls[0];
+            const requestHeaders = fetchCall[1].headers;
+            (0, vitest_1.expect)(requestHeaders.get('authorization')).toBe('Bearer custom-token');
+            (0, vitest_1.expect)(requestHeaders.get('x-custom-header')).toBe('custom-value');
+        });
+    });
+    (0, vitest_1.describe)('error handling edge cases', () => {
+        (0, vitest_1.test)('should handle fetch throwing non-Error objects', async () => {
+            mockFetch.mockRejectedValueOnce('String error');
+            await (0, vitest_1.expect)((0, operations_js_1.listItemsWithAuthorization)(testUrl, mockAuthorization)).rejects.toThrow(http_js_1.HttpError);
+        });
+        (0, vitest_1.test)('should handle malformed JSON responses', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                json: () => Promise.reject(new Error('Invalid JSON')),
+            });
+            await (0, vitest_1.expect)((0, operations_js_1.getItemWithAuthorization)(testUrl, mockAuthorization)).rejects.toThrow();
+        });
+        (0, vitest_1.test)('should handle response with missing error fields', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                json: () => Promise.resolve({}),
+            });
+            await (0, vitest_1.expect)((0, operations_js_1.updateItemWithAuthorization)(testUrl, mockAuthorization, {})).rejects.toThrow(http_js_1.HttpError);
+        });
+    });
+});

package/dist/cjs/common/resources/utils.d.ts

@@ -12,7 +12,7 @@ export declare function parseIngressSchema<S>(output: S | type.errors): S;
 export declare function defaultRequestHeaders(): Headers;
 export declare function defaultMutationRequestHeaders(): Headers;
 export declare function jsonBody<R>(message: Request | Response): Promise<R | undefined>;
-export declare function addPaginationToURL(url: URL, pagination?: Pagination): URL;
+export declare function addPaginationToURL(url: URL, pagination?: Pagination | null): URL;
 export declare function responseToHttpError(response: Response): Promise<HttpError>;
 export declare function toHttpError(error: unknown): HttpError;
 //# sourceMappingURL=utils.d.ts.map

package/dist/cjs/common/resources/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/common/resources/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAU/D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAQhE;AAED,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C;AAED,wBAAgB,6BAA6B,IAAI,OAAO,CAMvD;AAED,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,OAAO,EAAE,OAAO,GAAG,QAAQ,GAC1B,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAMxB;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,GAAG,CAUzE;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,SAAS,CAAC,CAmCpB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAUrD"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/common/resources/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAU/D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAQhE;AAED,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C;AAED,wBAAgB,6BAA6B,IAAI,OAAO,CAMvD;AAED,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,OAAO,EAAE,OAAO,GAAG,QAAQ,GAC1B,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAMxB;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,GAAG,EACR,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,GAC7B,GAAG,CAUL;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,SAAS,CAAC,CAmCpB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAUrD"}

package/dist/cjs/common/resources/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/cjs/common/resources/utils.test.d.ts.map

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