@go-mondo/identity-sdk 0.0.1 → 0.0.2-beta.12

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, insertItemWithAuthorization, listItemsWithAuthorization, updateItemWithAuthorization, } 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 updateItemWithAuthorization(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 updateItemWithAuthorization(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(updateItemWithAuthorization(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 updateItemWithAuthorization(testUrl, mockAuthorization, updateData);
+            expect(console.debug).toHaveBeenCalledWith('Update 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 insertItemWithAuthorization(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 insertItemWithAuthorization(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 insertItemWithAuthorization(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(insertItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(HttpError);
+        });
+        test('should log debug information', async () => {
+            const insertData = { name: 'Test' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            await insertItemWithAuthorization(testUrl, mockAuthorization, insertData);
+            expect(console.debug).toHaveBeenCalledWith('Insert 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),
+                () => updateItemWithAuthorization(testUrl, mockAuthorization, {}),
+                () => insertItemWithAuthorization(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(updateItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(HttpError);
+        });
+    });
+});

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

@@ -0,0 +1,18 @@
+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 | null): URL;
+export declare function responseToHttpError(response: Response): Promise<HttpError>;
+export declare function toHttpError(error: unknown): HttpError;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +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,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/esm/common/resources/utils.js

@@ -0,0 +1,86 @@
+import { type } from 'arktype';
+import { HttpError } from '../errors/http.js';
+import { ValidationError } from '../errors/validation.js';
+/**
+ * Parse schema data that is calling the API
+ */
+export function parseEgressSchema(output) {
+    if (output instanceof 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
+ */
+export function parseIngressSchema(output) {
+    if (output instanceof type.errors) {
+        console.warn(`Failed to parse ingress payload: ${output.summary}`, {
+            error: output,
+        });
+    }
+    return output;
+}
+export function defaultRequestHeaders() {
+    return new Headers([['accept', 'application/json']]);
+}
+export function defaultMutationRequestHeaders() {
+    const headers = defaultRequestHeaders();
+    headers.append('Content-Type', 'application/json');
+    return headers;
+}
+export async function jsonBody(message) {
+    try {
+        return await message.json();
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+export function addPaginationToURL(url, pagination) {
+    if (pagination?.nextToken != null) {
+        url.searchParams.set('pagination[nextToken]', pagination.nextToken);
+    }
+    if (pagination?.pageSize != null) {
+        url.searchParams.set('pagination[pageSize]', String(pagination.pageSize));
+    }
+    return url;
+}
+export async function responseToHttpError(response) {
+    const body = await response.json();
+    // Authorization errors
+    if ([401, 403].includes(response.status)) {
+        return new HttpError(body?.error_description || 'Unauthorized', {
+            statusCode: response.status,
+            type: body?.error || 'authorization',
+        });
+    }
+    const { error: type, error_description: message, trace, fields, ...data } = body;
+    if (fields) {
+        return new ValidationError(message, {
+            statusCode: response.status,
+            type,
+            trace,
+            body: data,
+            fields,
+        });
+    }
+    return new HttpError(message, {
+        statusCode: response.status,
+        type,
+        trace,
+        body: data,
+    });
+}
+export function toHttpError(error) {
+    if (error instanceof HttpError) {
+        return error;
+    }
+    if (error && typeof error === 'object' && 'message' in error) {
+        return new HttpError(String(error.message));
+    }
+    return new HttpError();
+}

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

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

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

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

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

@@ -0,0 +1,6 @@
+export declare const AggregateSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    ids?: string[] | undefined;
+    count?: number | undefined;
+}, {}>;
+export type Aggregate = typeof AggregateSchema.inferOut;
+//# sourceMappingURL=aggregate.d.ts.map

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

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

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

@@ -0,0 +1,5 @@
+import { type } from 'arktype';
+export const AggregateSchema = type({
+    ids: type('string[]').optional(),
+    count: type('number').optional(),
+});

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

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

package/dist/esm/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":""}