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

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

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

@@ -1,29 +1,5 @@
-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']]);
 }

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,132 @@
+import { describe, expect, test, vi } from 'vitest';
+import { HttpError } from '../errors/http.js';
+import { ValidationError } from '../errors/validation.js';
+import { addPaginationToURL, defaultMutationRequestHeaders, defaultRequestHeaders, jsonBody, responseToHttpError, toHttpError, } from './utils.js';
+describe('Common Resources - Utils', () => {
+    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

@@ -1,6 +1,7 @@
-export declare const AggregateSchema: import("arktype/internal/methods/object.ts").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/esm/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/esm/common/schema/aggregate.js

@@ -1,5 +1,5 @@
-import { type } from 'arktype';
-export const AggregateSchema = type({
-    ids: type('string[]').optional(),
-    count: type('number').optional(),
+import { z } from 'zod';
+export const AggregateSchema = z.object({
+    ids: z.array(z.string()).optional(),
+    count: z.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":""}

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

@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'vitest';
+import { AggregateSchema } from './aggregate.js';
+describe('Common Schema - Aggregate', () => {
+    describe('AggregateSchema', () => {
+        test('should accept valid aggregate with ids and count', () => {
+            const result = AggregateSchema.safeParse({
+                ids: ['id1', 'id2', 'id3'],
+                count: 25,
+            });
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
+                ids: ['id1', 'id2', 'id3'],
+                count: 25,
+            });
+        });
+        test('should accept aggregate with only ids', () => {
+            const result = AggregateSchema.safeParse({
+                ids: ['id1', 'id2'],
+            });
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
+                ids: ['id1', 'id2'],
+            });
+        });
+        test('should accept aggregate with only count', () => {
+            const result = AggregateSchema.safeParse({
+                count: 42,
+            });
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
+                count: 42,
+            });
+        });
+        test('should accept empty aggregate', () => {
+            const result = AggregateSchema.safeParse({});
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({});
+        });
+        test('should accept aggregate with empty ids array', () => {
+            const result = AggregateSchema.safeParse({
+                ids: [],
+                count: 0,
+            });
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
+                ids: [],
+                count: 0,
+            });
+        });
+        test('should reject invalid ids type', () => {
+            const result = AggregateSchema.safeParse({
+                ids: 'not-an-array',
+                count: 10,
+            });
+            expect(result.success).toBe(false);
+        });
+        test('should reject invalid count type', () => {
+            const result = AggregateSchema.safeParse({
+                ids: ['id1'],
+                count: 'not-a-number',
+            });
+            expect(result.success).toBe(false);
+        });
+        test('should reject non-string items in ids array', () => {
+            const result = AggregateSchema.safeParse({
+                ids: ['id1', 123, 'id3'],
+                count: 3,
+            });
+            expect(result.success).toBe(false);
+        });
+    });
+});