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

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

@@ -1,7 +1,7 @@
 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';
+import { deleteItemWithAuthorization, getItemWithAuthorization, listItemsWithAuthorization, postItemWithAuthorization, putItemWithAuthorization, } from './operations.js';
 // Mock console.debug to avoid noise in tests
 global.console.debug = vi.fn();
 // Mock fetch globally
@@ -95,23 +95,53 @@ describe('Common Resources - Operations', () => {
             }));
         });
         test('should handle authorization errors', async () => {
-            mockFetch.mockResolvedValueOnce({
+            const unauthorizedResponse = {
                 ok: false,
                 status: 401,
                 json: () => Promise.resolve({
                     error: 'unauthorized',
                     error_description: 'Invalid token',
                 }),
-            });
+            };
+            mockFetch
+                .mockResolvedValueOnce(unauthorizedResponse)
+                .mockResolvedValueOnce(unauthorizedResponse);
             await expect(getItemWithAuthorization(testUrl, mockAuthorization)).rejects.toThrow(HttpError);
         });
+        test('should retry once with refresh when authorization fails', async () => {
+            const mockData = { id: 1, name: 'Refreshed Item' };
+            mockFetch
+                .mockResolvedValueOnce({
+                ok: false,
+                status: 401,
+                json: () => Promise.resolve({
+                    error: 'unauthorized',
+                    error_description: 'Expired token',
+                }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockData),
+            });
+            const result = await getItemWithAuthorization(testUrl, mockAuthorization);
+            expect(result).toEqual(mockData);
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+            expect(mockAuthorization).toHaveBeenNthCalledWith(1, expect.objectContaining({
+                method: 'GET',
+                headers: expect.any(Headers),
+            }));
+            expect(mockAuthorization).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                method: 'GET',
+                headers: expect.any(Headers),
+            }), { refresh: true });
+        });
         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 });
+            expect(console.debug).toHaveBeenCalledWith('GET item', { url: testUrl });
         });
     });
     describe('updateItemWithAuthorization', () => {
@@ -122,7 +152,7 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve(responseData),
             });
-            const result = await updateItemWithAuthorization(testUrl, mockAuthorization, updateData);
+            const result = await putItemWithAuthorization(testUrl, mockAuthorization, updateData);
             expect(result).toEqual(responseData);
             expect(mockFetch).toHaveBeenCalledWith(testUrl, expect.objectContaining({
                 method: 'PUT',
@@ -136,7 +166,7 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve({}),
             });
-            await updateItemWithAuthorization(testUrl, mockAuthorization, updateData);
+            await putItemWithAuthorization(testUrl, mockAuthorization, updateData);
             const authCall = mockAuthorization.mock.calls[0][0];
             const headers = authCall.headers;
             expect(headers.get('accept')).toBe('application/json');
@@ -152,7 +182,7 @@ describe('Common Resources - Operations', () => {
                     fields: { name: ['required'] },
                 }),
             });
-            await expect(updateItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(ValidationError);
+            await expect(putItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(ValidationError);
         });
         test('should log debug information with item data', async () => {
             const updateData = { name: 'Test Item' };
@@ -160,8 +190,8 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve({}),
             });
-            await updateItemWithAuthorization(testUrl, mockAuthorization, updateData);
-            expect(console.debug).toHaveBeenCalledWith('Update item', {
+            await putItemWithAuthorization(testUrl, mockAuthorization, updateData);
+            expect(console.debug).toHaveBeenCalledWith('PUT item', {
                 url: testUrl,
                 item: updateData,
             });
@@ -175,7 +205,7 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve(responseData),
             });
-            const result = await insertItemWithAuthorization(testUrl, mockAuthorization, insertData);
+            const result = await postItemWithAuthorization(testUrl, mockAuthorization, insertData);
             expect(result).toEqual(responseData);
             expect(mockFetch).toHaveBeenCalledWith(testUrl, expect.objectContaining({
                 method: 'POST',
@@ -189,7 +219,7 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve(responseData),
             });
-            const result = await insertItemWithAuthorization(testUrl, mockAuthorization);
+            const result = await postItemWithAuthorization(testUrl, mockAuthorization);
             expect(result).toEqual(responseData);
             expect(mockFetch).toHaveBeenCalledWith(testUrl, expect.objectContaining({
                 method: 'POST',
@@ -203,7 +233,7 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve(responseData),
             });
-            const result = await insertItemWithAuthorization(testUrl, mockAuthorization, null);
+            const result = await postItemWithAuthorization(testUrl, mockAuthorization, null);
             expect(result).toEqual(responseData);
             expect(mockFetch).toHaveBeenCalledWith(testUrl, expect.objectContaining({
                 method: 'POST',
@@ -219,7 +249,7 @@ describe('Common Resources - Operations', () => {
                     error_description: 'Internal server error',
                 }),
             });
-            await expect(insertItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(HttpError);
+            await expect(postItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(HttpError);
         });
         test('should log debug information', async () => {
             const insertData = { name: 'Test' };
@@ -227,8 +257,8 @@ describe('Common Resources - Operations', () => {
                 ok: true,
                 json: () => Promise.resolve({}),
             });
-            await insertItemWithAuthorization(testUrl, mockAuthorization, insertData);
-            expect(console.debug).toHaveBeenCalledWith('Insert item', {
+            await postItemWithAuthorization(testUrl, mockAuthorization, insertData);
+            expect(console.debug).toHaveBeenCalledWith('POST item', {
                 url: testUrl,
                 item: insertData,
             });
@@ -294,8 +324,8 @@ describe('Common Resources - Operations', () => {
             const operations = [
                 () => listItemsWithAuthorization(testUrl, mockAuthorization),
                 () => getItemWithAuthorization(testUrl, mockAuthorization),
-                () => updateItemWithAuthorization(testUrl, mockAuthorization, {}),
-                () => insertItemWithAuthorization(testUrl, mockAuthorization, {}),
+                () => putItemWithAuthorization(testUrl, mockAuthorization, {}),
+                () => postItemWithAuthorization(testUrl, mockAuthorization, {}),
                 () => deleteItemWithAuthorization(testUrl, mockAuthorization),
             ];
             // Mock successful responses for all operations
@@ -348,7 +378,7 @@ describe('Common Resources - Operations', () => {
                 status: 400,
                 json: () => Promise.resolve({}),
             });
-            await expect(updateItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(HttpError);
+            await expect(putItemWithAuthorization(testUrl, mockAuthorization, {})).rejects.toThrow(HttpError);
         });
     });
 });

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

@@ -1,14 +1,5 @@
-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>;

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,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"}
+{"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.js

@@ -1,37 +1,8 @@
 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';
+import { addPaginationToURL, defaultMutationRequestHeaders, defaultRequestHeaders, jsonBody, 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();
@@ -64,7 +35,7 @@ describe('Common Resources - Utils', () => {
     describe('addPaginationToURL', () => {
         test('should add pagination params to URL', () => {
             const url = new URL('https://example.com/api');
-            const pagination = { nextToken: 'token123', pageSize: '10' };
+            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');
@@ -83,7 +54,7 @@ describe('Common Resources - Utils', () => {
         });
         test('should not add params when values are null', () => {
             const url = new URL('https://example.com/api');
-            const pagination = { nextToken: null, pageSize: null };
+            const pagination = {};
             const result = addPaginationToURL(url, pagination);
             expect(result.searchParams.has('pagination[nextToken]')).toBe(false);
             expect(result.searchParams.has('pagination[pageSize]')).toBe(false);

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 * as z from 'zod/v4';
+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,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,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 * as z from 'zod/v4';
+export const AggregateSchema = z.object({
+    ids: z.array(z.string()).optional(),
+    count: z.number().optional(),
 });

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

@@ -1,73 +1,72 @@
-import { type } from 'arktype';
 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({
+            const result = AggregateSchema.safeParse({
                 ids: ['id1', 'id2', 'id3'],
                 count: 25,
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            // 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({
+            const result = AggregateSchema.safeParse({
                 ids: ['id1', 'id2'],
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
                 ids: ['id1', 'id2'],
             });
         });
         test('should accept aggregate with only count', () => {
-            const result = AggregateSchema({
+            const result = AggregateSchema.safeParse({
                 count: 42,
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
                 count: 42,
             });
         });
         test('should accept empty aggregate', () => {
-            const result = AggregateSchema({});
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({});
+            const result = AggregateSchema.safeParse({});
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({});
         });
         test('should accept aggregate with empty ids array', () => {
-            const result = AggregateSchema({
+            const result = AggregateSchema.safeParse({
                 ids: [],
                 count: 0,
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
                 ids: [],
                 count: 0,
             });
         });
         test('should reject invalid ids type', () => {
-            const result = AggregateSchema({
+            const result = AggregateSchema.safeParse({
                 ids: 'not-an-array',
                 count: 10,
             });
-            expect(result).toBeInstanceOf(type.errors);
+            expect(result.success).toBe(false);
         });
         test('should reject invalid count type', () => {
-            const result = AggregateSchema({
+            const result = AggregateSchema.safeParse({
                 ids: ['id1'],
                 count: 'not-a-number',
             });
-            expect(result).toBeInstanceOf(type.errors);
+            expect(result.success).toBe(false);
         });
         test('should reject non-string items in ids array', () => {
-            const result = AggregateSchema({
+            const result = AggregateSchema.safeParse({
                 ids: ['id1', 123, 'id3'],
                 count: 3,
             });
-            expect(result).toBeInstanceOf(type.errors);
+            expect(result.success).toBe(false);
         });
     });
 });

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

@@ -1,18 +1,17 @@
-import { type Pagination } from './pagination.js';
-export declare const CollectionSchema: import("arktype").Generic<[["t", unknown]], {
-    readonly items: "t[]";
-}, {}, {}>;
+import * as z from 'zod/v4';
+import { type PaginationPayload } from './pagination.js';
+export declare const CollectionSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodObject<{
+    items: z.ZodArray<T>;
+}, z.core.$strip>;
 export type Collection<I> = {
     items: I[];
 };
-export declare const PaginationCollectionSchema: import("arktype").Generic<[["t", unknown]], {
-    readonly items: "t[]";
-    readonly pagination: [import("arktype/internal/methods/object.ts").ObjectType<{
-        pageSize?: string | number | null | undefined;
-        nextToken?: string | null | undefined;
-    }, {}>, "?"];
-}, {}, {}>;
-export type PaginationCollection<I> = Collection<I> & {
-    pagination?: Pagination;
-};
+export declare const PaginationCollectionSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodObject<{
+    pagination: z.ZodOptional<z.ZodObject<{
+        pageSize: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>, z.ZodTransform<number | undefined, string | number | null>>>;
+        nextToken: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>, z.ZodTransform<string | undefined, string | null>>>;
+    }, z.core.$strip>>;
+    items: z.ZodArray<T>;
+}, z.core.$strip>;
+export type PaginationCollection<I> = Collection<I> & PaginationPayload;
 //# sourceMappingURL=collection.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/collection.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,iBAAiB,CAAC;AAEpE,eAAO,MAAM,gBAAgB;;UAAgC,CAAC;AAC9D,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,KAAK,EAAE,CAAC,EAAE,CAAC;CACZ,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;UAGrC,CAAC;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG;IACpD,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,CAAC"}
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/collection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,KAAK,iBAAiB,EAAoB,MAAM,iBAAiB,CAAC;AAE3E,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC;;iBAC5B,CAAC;AAC3C,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,KAAK,EAAE,CAAC,EAAE,CAAC;CACZ,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAC/D,YAAY,CAAC;;;;;;iBAKX,CAAC;AACL,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC"}

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

@@ -1,7 +1,7 @@
-import { type } from 'arktype';
+import * as z from 'zod/v4';
 import { PaginationSchema } from './pagination.js';
-export const CollectionSchema = type('<t>', { items: 't[]' });
-export const PaginationCollectionSchema = type('<t>', {
-    items: 't[]',
-    pagination: PaginationSchema.optional(),
+export const CollectionSchema = (itemSchema) => z.object({ items: z.array(itemSchema) });
+export const PaginationCollectionSchema = (itemSchema) => z.object({
+    items: z.array(itemSchema),
+    ...PaginationSchema.shape,
 });

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

@@ -1,96 +1,114 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
+import * as z from 'zod/v4';
 import { CollectionSchema, PaginationCollectionSchema } from './collection.js';
 describe('Common Schema - Collection', () => {
     describe('CollectionSchema', () => {
         test('should accept valid collection with string items', () => {
-            const StringCollectionSchema = CollectionSchema('string');
-            const result = StringCollectionSchema({
-                items: ['item1', 'item2', 'item3'],
-            });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            const StringCollectionSchema = CollectionSchema(z.string());
+            const result = StringCollectionSchema.safeParse({
                 items: ['item1', 'item2', 'item3'],
             });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: ['item1', 'item2', 'item3'],
+                });
+            }
         });
         test('should accept valid collection with number items', () => {
-            const NumberCollectionSchema = CollectionSchema('number');
-            const result = NumberCollectionSchema({
-                items: [1, 2, 3],
-            });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            const NumberCollectionSchema = CollectionSchema(z.number());
+            const result = NumberCollectionSchema.safeParse({
                 items: [1, 2, 3],
             });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: [1, 2, 3],
+                });
+            }
         });
         test('should accept empty collection', () => {
-            const StringCollectionSchema = CollectionSchema('string');
-            const result = StringCollectionSchema({
-                items: [],
-            });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            const StringCollectionSchema = CollectionSchema(z.string());
+            const result = StringCollectionSchema.safeParse({
                 items: [],
             });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: [],
+                });
+            }
         });
         test('should reject invalid items type', () => {
-            const StringCollectionSchema = CollectionSchema('string');
-            const result = StringCollectionSchema({
+            const StringCollectionSchema = CollectionSchema(z.string());
+            const result = StringCollectionSchema.safeParse({
                 items: 'not-an-array',
             });
-            expect(result).toBeInstanceOf(type.errors);
+            expect(result.success).toBe(false);
         });
     });
     describe('PaginationCollectionSchema', () => {
         test('should accept valid paginated collection', () => {
-            const StringPaginationCollectionSchema = PaginationCollectionSchema('string');
-            const result = StringPaginationCollectionSchema({
-                items: ['item1', 'item2'],
-                pagination: {
-                    pageSize: '10',
-                    nextToken: 'token123',
-                },
-            });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            const StringPaginationCollectionSchema = PaginationCollectionSchema(z.string());
+            const result = StringPaginationCollectionSchema.safeParse({
                 items: ['item1', 'item2'],
                 pagination: {
                     pageSize: '10',
                     nextToken: 'token123',
                 },
             });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: ['item1', 'item2'],
+                    pagination: {
+                        pageSize: 10,
+                        nextToken: 'token123',
+                    },
+                });
+            }
         });
         test('should accept collection without pagination', () => {
-            const StringPaginationCollectionSchema = PaginationCollectionSchema('string');
-            const result = StringPaginationCollectionSchema({
-                items: ['item1', 'item2'],
-            });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            const StringPaginationCollectionSchema = PaginationCollectionSchema(z.string());
+            const result = StringPaginationCollectionSchema.safeParse({
                 items: ['item1', 'item2'],
             });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: ['item1', 'item2'],
+                });
+            }
         });
         test('should accept collection with empty pagination', () => {
-            const StringPaginationCollectionSchema = PaginationCollectionSchema('string');
-            const result = StringPaginationCollectionSchema({
-                items: ['item1'],
-                pagination: {},
-            });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            const StringPaginationCollectionSchema = PaginationCollectionSchema(z.string());
+            const result = StringPaginationCollectionSchema.safeParse({
                 items: ['item1'],
                 pagination: {},
             });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: ['item1'],
+                    pagination: {},
+                });
+            }
         });
         test('should reject invalid pagination', () => {
-            const StringPaginationCollectionSchema = PaginationCollectionSchema('string');
-            const result = StringPaginationCollectionSchema({
+            const StringPaginationCollectionSchema = PaginationCollectionSchema(z.string());
+            const result = StringPaginationCollectionSchema.safeParse({
                 items: ['item1'],
                 pagination: {
                     pageSize: true,
                 },
             });
-            expect(result).toBeInstanceOf(type.errors);
+            expect(result.success).toBe(false);
         });
     });
 });