@go-mondo/identity-sdk 0.0.2-beta.1 → 0.0.2-beta.13

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

@@ -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

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,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D,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.js

@@ -1,39 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseEgressSchema = parseEgressSchema;
-exports.parseIngressSchema = parseIngressSchema;
 exports.defaultRequestHeaders = defaultRequestHeaders;
 exports.defaultMutationRequestHeaders = defaultMutationRequestHeaders;
 exports.jsonBody = jsonBody;
 exports.addPaginationToURL = addPaginationToURL;
 exports.responseToHttpError = responseToHttpError;
 exports.toHttpError = toHttpError;
-const arktype_1 = require("arktype");
 const http_js_1 = require("../errors/http.js");
 const validation_js_1 = require("../errors/validation.js");
-/**
- * Parse schema data that is calling the API
- */
-function parseEgressSchema(output) {
-    if (output instanceof arktype_1.type.errors) {
-        console.warn(`Failed to parse egress payload: ${output.summary}`, {
-            error: output,
-        });
-        throw output;
-    }
-    return output;
-}
-/**
- * Parse schema data that is returning from the API
- */
-function parseIngressSchema(output) {
-    if (output instanceof arktype_1.type.errors) {
-        console.warn(`Failed to parse ingress payload: ${output.summary}`, {
-            error: output,
-        });
-    }
-    return output;
-}
 function defaultRequestHeaders() {
     return new Headers([['accept', 'application/json']]);
 }

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":""}

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

@@ -0,0 +1,134 @@
+"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 utils_js_1 = require("./utils.js");
+(0, vitest_1.describe)('Common Resources - Utils', () => {
+    (0, vitest_1.describe)('defaultRequestHeaders', () => {
+        (0, vitest_1.test)('should return headers with accept application/json', () => {
+            const headers = (0, utils_js_1.defaultRequestHeaders)();
+            (0, vitest_1.expect)(headers.get('accept')).toBe('application/json');
+        });
+    });
+    (0, vitest_1.describe)('defaultMutationRequestHeaders', () => {
+        (0, vitest_1.test)('should return headers with accept and content-type', () => {
+            const headers = (0, utils_js_1.defaultMutationRequestHeaders)();
+            (0, vitest_1.expect)(headers.get('accept')).toBe('application/json');
+            (0, vitest_1.expect)(headers.get('content-type')).toBe('application/json');
+        });
+    });
+    (0, vitest_1.describe)('jsonBody', () => {
+        (0, vitest_1.test)('should return parsed JSON from request', async () => {
+            const mockRequest = {
+                json: vitest_1.vi.fn().mockResolvedValue({ data: 'test' }),
+            };
+            const result = await (0, utils_js_1.jsonBody)(mockRequest);
+            (0, vitest_1.expect)(result).toEqual({ data: 'test' });
+        });
+        (0, vitest_1.test)('should return undefined when JSON parsing fails', async () => {
+            const mockRequest = {
+                json: vitest_1.vi.fn().mockRejectedValue(new Error('Invalid JSON')),
+            };
+            const result = await (0, utils_js_1.jsonBody)(mockRequest);
+            (0, vitest_1.expect)(result).toBeUndefined();
+        });
+    });
+    (0, vitest_1.describe)('addPaginationToURL', () => {
+        (0, vitest_1.test)('should add pagination params to URL', () => {
+            const url = new URL('https://example.com/api');
+            const pagination = { nextToken: 'token123', pageSize: '10' };
+            const result = (0, utils_js_1.addPaginationToURL)(url, pagination);
+            (0, vitest_1.expect)(result.searchParams.get('pagination[nextToken]')).toBe('token123');
+            (0, vitest_1.expect)(result.searchParams.get('pagination[pageSize]')).toBe('10');
+        });
+        (0, vitest_1.test)('should handle pageSize as number', () => {
+            const url = new URL('https://example.com/api');
+            const pagination = { pageSize: 25 };
+            const result = (0, utils_js_1.addPaginationToURL)(url, pagination);
+            (0, vitest_1.expect)(result.searchParams.get('pagination[pageSize]')).toBe('25');
+        });
+        (0, vitest_1.test)('should not add params when pagination is undefined', () => {
+            const url = new URL('https://example.com/api');
+            const result = (0, utils_js_1.addPaginationToURL)(url, undefined);
+            (0, vitest_1.expect)(result.searchParams.has('pagination[nextToken]')).toBe(false);
+            (0, vitest_1.expect)(result.searchParams.has('pagination[pageSize]')).toBe(false);
+        });
+        (0, vitest_1.test)('should not add params when values are null', () => {
+            const url = new URL('https://example.com/api');
+            const pagination = { nextToken: null, pageSize: null };
+            const result = (0, utils_js_1.addPaginationToURL)(url, pagination);
+            (0, vitest_1.expect)(result.searchParams.has('pagination[nextToken]')).toBe(false);
+            (0, vitest_1.expect)(result.searchParams.has('pagination[pageSize]')).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('responseToHttpError', () => {
+        (0, vitest_1.test)('should handle authorization errors', async () => {
+            const mockResponse = {
+                status: 401,
+                json: vitest_1.vi.fn().mockResolvedValue({
+                    error: 'unauthorized',
+                    error_description: 'Invalid token',
+                }),
+            };
+            const error = await (0, utils_js_1.responseToHttpError)(mockResponse);
+            (0, vitest_1.expect)(error).toBeInstanceOf(http_js_1.HttpError);
+            (0, vitest_1.expect)(error.message).toBe('Invalid token');
+            (0, vitest_1.expect)(error.statusCode).toBe(401);
+            (0, vitest_1.expect)(error.type).toBe('unauthorized');
+        });
+        (0, vitest_1.test)('should handle validation errors with fields', async () => {
+            const mockResponse = {
+                status: 400,
+                json: vitest_1.vi.fn().mockResolvedValue({
+                    error: 'validation_error',
+                    error_description: 'Validation failed',
+                    fields: { email: 'Invalid email format' },
+                }),
+            };
+            const error = await (0, utils_js_1.responseToHttpError)(mockResponse);
+            (0, vitest_1.expect)(error).toBeInstanceOf(validation_js_1.ValidationError);
+            (0, vitest_1.expect)(error.message).toBe('Validation failed');
+            (0, vitest_1.expect)(error.fields).toEqual({
+                email: 'Invalid email format',
+            });
+        });
+        (0, vitest_1.test)('should handle generic HTTP errors', async () => {
+            const mockResponse = {
+                status: 500,
+                json: vitest_1.vi.fn().mockResolvedValue({
+                    error: 'internal_error',
+                    error_description: 'Something went wrong',
+                }),
+            };
+            const error = await (0, utils_js_1.responseToHttpError)(mockResponse);
+            (0, vitest_1.expect)(error).toBeInstanceOf(http_js_1.HttpError);
+            (0, vitest_1.expect)(error.message).toBe('Something went wrong');
+            (0, vitest_1.expect)(error.statusCode).toBe(500);
+        });
+    });
+    (0, vitest_1.describe)('toHttpError', () => {
+        (0, vitest_1.test)('should return HttpError as-is', () => {
+            const httpError = new http_js_1.HttpError('Test error');
+            const result = (0, utils_js_1.toHttpError)(httpError);
+            (0, vitest_1.expect)(result).toBe(httpError);
+        });
+        (0, vitest_1.test)('should convert Error to HttpError', () => {
+            const error = new Error('Test message');
+            const result = (0, utils_js_1.toHttpError)(error);
+            (0, vitest_1.expect)(result).toBeInstanceOf(http_js_1.HttpError);
+            (0, vitest_1.expect)(result.message).toBe('Test message');
+        });
+        (0, vitest_1.test)('should handle objects with message property', () => {
+            const error = { message: 'Custom error' };
+            const result = (0, utils_js_1.toHttpError)(error);
+            (0, vitest_1.expect)(result).toBeInstanceOf(http_js_1.HttpError);
+            (0, vitest_1.expect)(result.message).toBe('Custom error');
+        });
+        (0, vitest_1.test)('should handle unknown error types', () => {
+            const result = (0, utils_js_1.toHttpError)('string error');
+            (0, vitest_1.expect)(result).toBeInstanceOf(http_js_1.HttpError);
+            (0, vitest_1.expect)(result.message).toBe('An unknown error occurred. Please try the operation again.');
+        });
+    });
+});

package/dist/cjs/common/schema/aggregate.d.ts

@@ -1,6 +1,7 @@
-export declare const AggregateSchema: import("arktype/out/methods/object").ObjectType<{
-    ids?: string[] | undefined;
-    count?: number | undefined;
-}, {}>;
-export type Aggregate = typeof AggregateSchema.inferOut;
+import { z } from 'zod';
+export declare const AggregateSchema: z.ZodObject<{
+    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    count: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type Aggregate = z.output<typeof AggregateSchema>;
 //# sourceMappingURL=aggregate.d.ts.map

package/dist/cjs/common/schema/aggregate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/aggregate.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;MAG1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,eAAe,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;iBAG1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/cjs/common/schema/aggregate.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateSchema = void 0;
-const arktype_1 = require("arktype");
-exports.AggregateSchema = (0, arktype_1.type)({
-    ids: (0, arktype_1.type)('string[]').optional(),
-    count: (0, arktype_1.type)('number').optional(),
+const zod_1 = require("zod");
+exports.AggregateSchema = zod_1.z.object({
+    ids: zod_1.z.array(zod_1.z.string()).optional(),
+    count: zod_1.z.number().optional(),
 });

package/dist/cjs/common/schema/aggregate.test.d.ts

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

package/dist/cjs/common/schema/aggregate.test.d.ts.map

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