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

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

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

package/dist/esm/common/resources/operations.d.ts

@@ -1,7 +1,8 @@
 import type { Authorization } from './authorization.js';
 export declare function listItemsWithAuthorization<Result>(url: URL, authorization: Authorization): Promise<Result>;
 export declare function getItemWithAuthorization<Result>(url: URL, authorization: Authorization): Promise<Result>;
-export declare function updateItemWithAuthorization<Result, Mutation>(url: URL, authorization: Authorization, item: Mutation): Promise<Result>;
-export declare function insertItemWithAuthorization<Result, Mutation>(url: URL, authorization: Authorization, item?: Mutation): Promise<Result>;
+export declare function patchItemWithAuthorization<Result, Mutation>(url: URL, authorization: Authorization, item: Mutation): Promise<Result>;
+export declare function putItemWithAuthorization<Result, Mutation>(url: URL, authorization: Authorization, item: Mutation): Promise<Result>;
+export declare function postItemWithAuthorization<Result, Mutation>(url: URL, authorization: Authorization, item?: Mutation): Promise<Result>;
 export declare function deleteItemWithAuthorization<Result>(url: URL, authorization: Authorization): Promise<Result>;
 //# sourceMappingURL=operations.d.ts.map

package/dist/esm/common/resources/operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../../src/common/resources/operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AASxD,wBAAsB,0BAA0B,CAAC,MAAM,EACrD,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,MAAM,CAAC,CAoBjB;AAED,wBAAsB,wBAAwB,CAAC,MAAM,EACnD,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,MAAM,CAAC,CAoBjB;AAED,wBAAsB,2BAA2B,CAAC,MAAM,EAAE,QAAQ,EAChE,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED,wBAAsB,2BAA2B,CAAC,MAAM,EAAE,QAAQ,EAChE,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,EAC5B,IAAI,CAAC,EAAE,QAAQ,GACd,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED,wBAAsB,2BAA2B,CAAC,MAAM,EACtD,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,MAAM,CAAC,CAoBjB"}
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../../src/common/resources/operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AASxD,wBAAsB,0BAA0B,CAAC,MAAM,EACrD,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,MAAM,CAAC,CAoBjB;AAED,wBAAsB,wBAAwB,CAAC,MAAM,EACnD,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,MAAM,CAAC,CAoBjB;AAED,wBAAsB,0BAA0B,CAAC,MAAM,EAAE,QAAQ,EAC/D,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,QAAQ,EAC7D,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,MAAM,CAAC,CAEjB;AA8BD,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,QAAQ,EAC9D,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,EAC5B,IAAI,CAAC,EAAE,QAAQ,GACd,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED,wBAAsB,2BAA2B,CAAC,MAAM,EACtD,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,MAAM,CAAC,CAoBjB"}

package/dist/esm/common/resources/operations.js

@@ -17,7 +17,7 @@ export async function listItemsWithAuthorization(url, authorization) {
 }
 export async function getItemWithAuthorization(url, authorization) {
     try {
-        console.debug('Get item', { url });
+        console.debug('GET item', { url });
         const response = await fetch(url, authorization({
             method: 'GET',
             headers: defaultRequestHeaders(),
@@ -31,11 +31,17 @@ export async function getItemWithAuthorization(url, authorization) {
         throw toHttpError(error);
     }
 }
-export async function updateItemWithAuthorization(url, authorization, item) {
+export async function patchItemWithAuthorization(url, authorization, item) {
+    return mutateItemWithAuthorization('PATCH', url, authorization, item);
+}
+export async function putItemWithAuthorization(url, authorization, item) {
+    return mutateItemWithAuthorization('PUT', url, authorization, item);
+}
+async function mutateItemWithAuthorization(method, url, authorization, item) {
     try {
-        console.debug('Update item', { url, item });
+        console.debug(`${method} item`, { url, item });
         const response = await fetch(url, authorization({
-            method: 'PUT',
+            method,
             headers: defaultMutationRequestHeaders(),
             body: JSON.stringify(item),
         }));
@@ -48,9 +54,9 @@ export async function updateItemWithAuthorization(url, authorization, item) {
         throw toHttpError(error);
     }
 }
-export async function insertItemWithAuthorization(url, authorization, item) {
+export async function postItemWithAuthorization(url, authorization, item) {
     try {
-        console.debug('Insert item', { url, item });
+        console.debug('POST item', { url, item });
         const response = await fetch(url, authorization({
             method: 'POST',
             headers: defaultMutationRequestHeaders(),

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

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

package/dist/esm/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/esm/common/resources/operations.test.js

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

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

@@ -1,18 +1,9 @@
-import { type } from 'arktype';
 import { HttpError } from '../errors/http.js';
 import type { Pagination } from '../schema/pagination.js';
-/**
- * Parse schema data that is calling the API
- */
-export declare function parseEgressSchema<S>(output: S | type.errors): S;
-/**
- * Parse schema data that is returning from the API
- */
-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