@go-mondo/identity-sdk 0.0.2-beta.7 → 0.0.2-beta.71

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 = {};
+            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 * 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.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);
+        });
+    });
+});

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 | undefined;
-        nextToken?: string | 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.d.ts

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

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

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

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

@@ -0,0 +1,114 @@
+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(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(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(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(z.string());
+            const result = StringCollectionSchema.safeParse({
+                items: 'not-an-array',
+            });
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('PaginationCollectionSchema', () => {
+        test('should accept valid paginated collection', () => {
+            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(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(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(z.string());
+            const result = StringPaginationCollectionSchema.safeParse({
+                items: ['item1'],
+                pagination: {
+                    pageSize: true,
+                },
+            });
+            expect(result.success).toBe(false);
+        });
+    });
+});

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

@@ -1,39 +1,56 @@
-export declare const RequiredDateSchema: import("arktype/internal/methods/object.ts").ObjectType<Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>), {}>;
-export declare const OptionalDateSchema: import("arktype").BaseType<Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined, {}>;
-export type AnyRequiredDateType = typeof RequiredDateSchema.inferIn;
-export type RequiredDate = typeof RequiredDateSchema.inferOut;
-export type AnyOptionalDate = typeof OptionalDateSchema.inferIn;
-export type OptionalDate = typeof OptionalDateSchema.inferOut;
-export declare const RequiredDatePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: string | Date) => import("arktype").Out<string>, {}>;
-export declare const OptionalDatePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: string | Date | undefined) => import("arktype").Out<string | undefined>, {}>;
-export type RequiredDatePayload = typeof RequiredDatePayloadSchema.inferOut;
-export type OptionalDatePayload = typeof OptionalDatePayloadSchema.inferOut;
+import * as z from 'zod/v4';
+export declare const RequiredDateSchema: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+export declare const OptionalDateSchema: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+export type AnyRequiredDateType = z.input<typeof RequiredDateSchema>;
+export type RequiredDate = z.output<typeof RequiredDateSchema>;
+export type AnyOptionalDate = z.input<typeof OptionalDateSchema>;
+export type OptionalDate = z.output<typeof OptionalDateSchema>;
+export declare const RequiredDatePayloadSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+export declare const OptionalDatePayloadSchema: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+export type RequiredDatePayload = z.output<typeof RequiredDatePayloadSchema>;
+export type OptionalDatePayload = z.output<typeof OptionalDatePayloadSchema>;
 /**
  * Created At
  */
-export declare const CreatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    createdAt: (In: string | Date) => import("arktype").Out<string>;
-}, {}>;
-export type CreatedAtPropertyPayload = typeof CreatedAtPropertyPayloadSchema.inferOut;
+export declare const CreatedAtPropertyPayloadSchema: z.ZodObject<{
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+}, z.core.$strip>;
+export type CreatedAtPropertyPayload = z.output<typeof CreatedAtPropertyPayloadSchema>;
+export declare const CreatedAtPropertySchema: z.ZodObject<{
+    createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+}, z.core.$strip>;
+export type CreatedAtProperty = z.output<typeof CreatedAtPropertySchema>;
 /**
  * Updated At
  */
-export declare const UpdatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    updatedAt: (In: string | Date) => import("arktype").Out<string>;
-}, {}>;
-export type UpdatedAtPropertyPayload = typeof UpdatedAtPropertyPayloadSchema.inferOut;
+export declare const UpdatedAtPropertyPayloadSchema: z.ZodObject<{
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+}, z.core.$strip>;
+export type UpdatedAtPropertyPayload = z.output<typeof UpdatedAtPropertyPayloadSchema>;
+export declare const UpdatedAtPropertySchema: z.ZodObject<{
+    updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+}, z.core.$strip>;
+export type UpdatedAtProperty = z.output<typeof UpdatedAtPropertySchema>;
 /**
  * Deleted At
  */
-export declare const DeletedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
-}, {}>;
-export type DeletedAtPropertyPayload = typeof DeletedAtPropertyPayloadSchema.inferOut;
+export declare const DeletedAtPropertyPayloadSchema: z.ZodObject<{
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+}, z.core.$strip>;
+export type DeletedAtPropertyPayload = z.output<typeof DeletedAtPropertyPayloadSchema>;
+export declare const DeletedAtPropertySchema: z.ZodObject<{
+    deletedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+}, z.core.$strip>;
+export type DeletedAtProperty = z.output<typeof DeletedAtPropertySchema>;
 /**
  * Deactivated At
  */
-export declare const DeactivatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
-}, {}>;
-export type DeactivatedAtPropertyPayload = typeof DeactivatedAtPropertyPayloadSchema.inferOut;
+export declare const DeactivatedAtPropertyPayloadSchema: z.ZodObject<{
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+}, z.core.$strip>;
+export type DeactivatedAtPropertyPayload = z.output<typeof DeactivatedAtPropertyPayloadSchema>;
+export declare const DeactivatedAtPropertySchema: z.ZodObject<{
+    deactivatedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+}, z.core.$strip>;
+export type DeactivatedAtProperty = z.output<typeof DeactivatedAtPropertySchema>;
 //# sourceMappingURL=dates.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/dates.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,yIAA2C,CAAC;AAC3E,eAAO,MAAM,kBAAkB,wHAAqC,CAAC;AAErE,MAAM,MAAM,mBAAmB,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AACpE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAE9D,MAAM,MAAM,eAAe,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAG9D,eAAO,MAAM,yBAAyB,mHAErC,CAAC;AACF,eAAO,MAAM,yBAAyB,2IAErC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,kCAAkC;;MAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GACtC,OAAO,kCAAkC,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/dates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,kBAAkB,wFAM7B,CAAC;AACH,eAAO,MAAM,kBAAkB,uGAAgC,CAAC;AAEhE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACrE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACjE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG/D,eAAO,MAAM,yBAAyB,iIAErC,CAAC;AACF,eAAO,MAAM,yBAAyB,uLAE1B,CAAC;AAEb,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC7E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,8BAA8B;;iBAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,8BAA8B,CACtC,CAAC;AACF,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,8BAA8B;;iBAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,8BAA8B,CACtC,CAAC;AACF,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,8BAA8B;;iBAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,8BAA8B,CACtC,CAAC;AACF,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,kCAAkC;;iBAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CACjD,OAAO,kCAAkC,CAC1C,CAAC;AACF,eAAO,MAAM,2BAA2B;;iBAEtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC1C,OAAO,2BAA2B,CACnC,CAAC"}

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

@@ -1,31 +1,49 @@
-import { type } from 'arktype';
+import * as z from 'zod/v4';
 // Normalizing to a Date object
-export const RequiredDateSchema = type('Date').or('string.date.iso.parse');
-export const OptionalDateSchema = RequiredDateSchema.or('undefined');
+export const RequiredDateSchema = z.union([
+    z.date(),
+    z
+        .string()
+        .datetime()
+        .transform((str) => new Date(str)),
+]);
+export const OptionalDateSchema = RequiredDateSchema.optional();
 // What the class property is serialized to
-export const RequiredDatePayloadSchema = RequiredDateSchema.pipe.try((d) => d.toISOString());
-export const OptionalDatePayloadSchema = OptionalDateSchema.pipe.try((d) => d?.toISOString());
+export const RequiredDatePayloadSchema = RequiredDateSchema.transform((d) => d.toISOString());
+export const OptionalDatePayloadSchema = OptionalDateSchema.transform((d) => d?.toISOString()).optional();
 /**
  * Created At
  */
-export const CreatedAtPropertyPayloadSchema = type({
+export const CreatedAtPropertyPayloadSchema = z.object({
     createdAt: RequiredDatePayloadSchema,
 });
+export const CreatedAtPropertySchema = z.object({
+    createdAt: RequiredDateSchema,
+});
 /**
  * Updated At
  */
-export const UpdatedAtPropertyPayloadSchema = type({
+export const UpdatedAtPropertyPayloadSchema = z.object({
     updatedAt: RequiredDatePayloadSchema,
 });
+export const UpdatedAtPropertySchema = z.object({
+    updatedAt: RequiredDateSchema,
+});
 /**
  * Deleted At
  */
-export const DeletedAtPropertyPayloadSchema = type({
-    'deletedAt?': OptionalDatePayloadSchema,
+export const DeletedAtPropertyPayloadSchema = z.object({
+    deletedAt: OptionalDatePayloadSchema,
+});
+export const DeletedAtPropertySchema = z.object({
+    deletedAt: OptionalDateSchema,
 });
 /**
  * Deactivated At
  */
-export const DeactivatedAtPropertyPayloadSchema = type({
-    'deactivatedAt?': OptionalDatePayloadSchema,
+export const DeactivatedAtPropertyPayloadSchema = z.object({
+    deactivatedAt: OptionalDatePayloadSchema,
+});
+export const DeactivatedAtPropertySchema = z.object({
+    deactivatedAt: OptionalDateSchema,
 });