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

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

@@ -1,31 +1,42 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { RequiredDatePayloadSchema, RequiredDateSchema } from './dates.js';
 describe('Common - Dates', () => {
     describe('Date Schema', () => {
         test('should accept an iso string', async () => {
-            const result = RequiredDateSchema(new Date().toISOString());
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBeInstanceOf(Date);
+            const result = RequiredDateSchema.safeParse(new Date().toISOString());
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBeInstanceOf(Date);
+            }
         });
         test('should accept a Date object', async () => {
-            const result = RequiredDateSchema(new Date());
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBeInstanceOf(Date);
+            const result = RequiredDateSchema.safeParse(new Date());
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBeInstanceOf(Date);
+            }
         });
     });
     describe('Payload Schema', () => {
         test('should parse a Date to an ISO string', async () => {
             const iso = new Date().toISOString();
-            const result = RequiredDatePayloadSchema(new Date(iso));
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).to.equal(iso);
+            const result = RequiredDatePayloadSchema.safeParse(new Date(iso));
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(iso);
+            }
         });
         test('should parse an ISO to an ISO string', async () => {
             const iso = new Date().toISOString();
-            const result = RequiredDatePayloadSchema(iso);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).to.equal(iso);
+            const result = RequiredDatePayloadSchema.safeParse(iso);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(iso);
+            }
         });
     });
 });

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

@@ -1,2 +1,3 @@
-export declare const KSUIDSchema: (prefix: string) => import("arktype/internal/methods/string.ts").StringType<string, {}>;
+import { z } from 'zod';
+export declare const KSUIDSchema: (prefix: string) => z.ZodString;
 //# sourceMappingURL=id.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"id.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/id.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,wEACH,CAAC"}
+{"version":3,"file":"id.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,gBACmB,CAAC"}

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

@@ -1,2 +1,2 @@
-import { type } from 'arktype';
-export const KSUIDSchema = (prefix) => type(`/^${prefix}_[A-Za-z0-9]{27}$/`);
+import { z } from 'zod';
+export const KSUIDSchema = (prefix) => z.string().regex(new RegExp(`^${prefix}_[A-Za-z0-9]{27}$`));

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

@@ -1,4 +1,3 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { KSUIDSchema } from './id.js';
 describe('Common Schema - ID', () => {
@@ -6,8 +5,11 @@ describe('Common Schema - ID', () => {
         test('should accept valid KSUID with correct prefix', () => {
             const schema = KSUIDSchema('usr');
             const validId = 'usr_123456789012345678901234567';
-            const result = schema(validId);
-            expect(result).toBe(validId);
+            const result = schema.safeParse(validId);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(validId);
+            }
         });
         test('should accept KSUID with different prefixes', () => {
             const userSchema = KSUIDSchema('usr');
@@ -16,87 +18,109 @@ describe('Common Schema - ID', () => {
             const userId = 'usr_abcdefghijklmnopqrstuvwxy12';
             const appId = 'app_1234567890ABCDEFGHIJKLMNOP1';
             const activityId = 'act_abcDEF123456789012345678901';
-            expect(userSchema(userId)).toBe(userId);
-            expect(appSchema(appId)).toBe(appId);
-            expect(activitySchema(activityId)).toBe(activityId);
+            const userResult = userSchema.safeParse(userId);
+            expect(userResult.success).toBe(true);
+            if (userResult.success)
+                expect(userResult.data).toBe(userId);
+            const appResult = appSchema.safeParse(appId);
+            expect(appResult.success).toBe(true);
+            if (appResult.success)
+                expect(appResult.data).toBe(appId);
+            const activityResult = activitySchema.safeParse(activityId);
+            expect(activityResult.success).toBe(true);
+            if (activityResult.success)
+                expect(activityResult.data).toBe(activityId);
         });
         test('should accept KSUID with mixed alphanumeric characters', () => {
             const schema = KSUIDSchema('test');
             const mixedId = 'test_1a2B3c4D5e6F7g8H9i0JkLmNoPq';
-            const result = schema(mixedId);
-            expect(result).toBe(mixedId);
+            const result = schema.safeParse(mixedId);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(mixedId);
+            }
         });
         test('should reject KSUID with wrong prefix', () => {
             const schema = KSUIDSchema('usr');
             const wrongPrefixId = 'app_123456789012345678901234567';
-            const result = schema(wrongPrefixId);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = schema.safeParse(wrongPrefixId);
+            expect(result.success).toBe(false);
         });
         test('should reject KSUID with missing prefix', () => {
             const schema = KSUIDSchema('usr');
             const noPrefixId = '123456789012345678901234567';
-            const result = schema(noPrefixId);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = schema.safeParse(noPrefixId);
+            expect(result.success).toBe(false);
         });
         test('should reject KSUID with missing underscore', () => {
             const schema = KSUIDSchema('usr');
             const noUnderscoreId = 'usr123456789012345678901234567';
-            const result = schema(noUnderscoreId);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = schema.safeParse(noUnderscoreId);
+            expect(result.success).toBe(false);
         });
         test('should reject KSUID with incorrect suffix length (too short)', () => {
             const schema = KSUIDSchema('usr');
             const shortId = 'usr_12345678901234567890123456';
-            const result = schema(shortId);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = schema.safeParse(shortId);
+            expect(result.success).toBe(false);
         });
         test('should reject KSUID with incorrect suffix length (too long)', () => {
             const schema = KSUIDSchema('usr');
             const longId = 'usr_1234567890123456789012345678';
-            const result = schema(longId);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = schema.safeParse(longId);
+            expect(result.success).toBe(false);
         });
         test('should reject KSUID with invalid characters in suffix', () => {
             const schema = KSUIDSchema('usr');
             const invalidCharsId = 'usr_123456789012345678901234_*';
-            const result = schema(invalidCharsId);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = schema.safeParse(invalidCharsId);
+            expect(result.success).toBe(false);
         });
         test('should reject KSUID with special characters in suffix', () => {
             const schema = KSUIDSchema('usr');
             const specialCharsId = 'usr_12345678901234567890123456@';
-            const result = schema(specialCharsId);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = schema.safeParse(specialCharsId);
+            expect(result.success).toBe(false);
         });
         test('should reject KSUID with spaces', () => {
             const schema = KSUIDSchema('usr');
             const spaceId = 'usr_1234567890123456789012345 7';
-            const result = schema(spaceId);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = schema.safeParse(spaceId);
+            expect(result.success).toBe(false);
         });
         test('should reject empty string', () => {
             const schema = KSUIDSchema('usr');
-            const result = schema('');
-            expect(result).toBeInstanceOf(type.errors);
+            const result = schema.safeParse('');
+            expect(result.success).toBe(false);
         });
         test('should reject non-string values', () => {
             const schema = KSUIDSchema('usr');
-            expect(schema(123)).toBeInstanceOf(type.errors);
-            expect(schema(null)).toBeInstanceOf(type.errors);
-            expect(schema(undefined)).toBeInstanceOf(type.errors);
-            expect(schema({})).toBeInstanceOf(type.errors);
+            const result1 = schema.safeParse(123);
+            expect(result1.success).toBe(false);
+            const result2 = schema.safeParse(null);
+            expect(result2.success).toBe(false);
+            const result3 = schema.safeParse(undefined);
+            expect(result3.success).toBe(false);
+            const result4 = schema.safeParse({});
+            expect(result4.success).toBe(false);
         });
         test('should work with complex prefixes', () => {
             const complexSchema = KSUIDSchema('app_config');
             const validComplexId = 'app_config_123456789012345678901234567';
-            const result = complexSchema(validComplexId);
-            expect(result).toBe(validComplexId);
+            const result = complexSchema.safeParse(validComplexId);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(validComplexId);
+            }
         });
         test('should work with single character prefix', () => {
             const singleCharSchema = KSUIDSchema('a');
             const validSingleCharId = 'a_123456789012345678901234567';
-            const result = singleCharSchema(validSingleCharId);
-            expect(result).toBe(validSingleCharId);
+            const result = singleCharSchema.safeParse(validSingleCharId);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(validSingleCharId);
+            }
         });
         test('should create different schemas for different prefixes', () => {
             const userSchema = KSUIDSchema('usr');
@@ -104,11 +128,19 @@ describe('Common Schema - ID', () => {
             const userId = 'usr_123456789012345678901234567';
             const orgId = 'org_123456789012345678901234567';
             // User schema should accept user ID but reject org ID
-            expect(userSchema(userId)).toBe(userId);
-            expect(userSchema(orgId)).toBeInstanceOf(type.errors);
+            const userResult = userSchema.safeParse(userId);
+            expect(userResult.success).toBe(true);
+            if (userResult.success)
+                expect(userResult.data).toBe(userId);
+            const userOrgResult = userSchema.safeParse(orgId);
+            expect(userOrgResult.success).toBe(false);
             // Org schema should accept org ID but reject user ID
-            expect(orgSchema(orgId)).toBe(orgId);
-            expect(orgSchema(userId)).toBeInstanceOf(type.errors);
+            const orgResult = orgSchema.safeParse(orgId);
+            expect(orgResult.success).toBe(true);
+            if (orgResult.success)
+                expect(orgResult.data).toBe(orgId);
+            const orgUserResult = orgSchema.safeParse(userId);
+            expect(orgUserResult.success).toBe(false);
         });
     });
 });

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

@@ -1,21 +1,34 @@
+import { z } from 'zod';
 /**
  * Ref: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1
  */
 export declare const Algorithm: {
-    DEFAULT: string;
-    HS256: string;
-    HS384: string;
-    HS512: string;
-    RS256: string;
-    RS384: string;
-    RS512: string;
-    ES256: string;
-    ES384: string;
-    ES512: string;
-    PS256: string;
-    PS384: string;
-    PS512: string;
+    readonly DEFAULT: "RS256";
+    readonly HS256: "HS256";
+    readonly HS384: "HS384";
+    readonly HS512: "HS512";
+    readonly RS256: "RS256";
+    readonly RS384: "RS384";
+    readonly RS512: "RS512";
+    readonly ES256: "ES256";
+    readonly ES384: "ES384";
+    readonly ES512: "ES512";
+    readonly PS256: "PS256";
+    readonly PS384: "PS384";
+    readonly PS512: "PS512";
 };
 export type AnyAlgorithm = (typeof Algorithm)[keyof typeof Algorithm];
-export declare const AlgorithmSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export declare const AlgorithmSchema: z.ZodEnum<{
+    RS256: "RS256";
+    HS256: "HS256";
+    HS384: "HS384";
+    HS512: "HS512";
+    RS384: "RS384";
+    RS512: "RS512";
+    ES256: "ES256";
+    ES384: "ES384";
+    PS256: "PS256";
+    PS384: "PS384";
+    PS512: "PS512";
+}>;
 //# sourceMappingURL=jwt.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/jwt.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;CAerB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,eAAe,qEAY3B,CAAC"}
+{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/jwt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;CAeZ,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,eAAe;;;;;;;;;;;;EAYjB,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type } from 'arktype';
+import { z } from 'zod';
 /**
  * Ref: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1
  */
@@ -18,4 +18,16 @@ export const Algorithm = {
     PS384: 'PS384',
     PS512: 'PS512',
 };
-export const AlgorithmSchema = type.enumerated(Algorithm.HS256, Algorithm.HS384, Algorithm.HS512, Algorithm.RS256, Algorithm.RS384, Algorithm.RS512, Algorithm.ES256, Algorithm.ES384, Algorithm.PS256, Algorithm.PS384, Algorithm.PS512);
+export const AlgorithmSchema = z.enum([
+    Algorithm.HS256,
+    Algorithm.HS384,
+    Algorithm.HS512,
+    Algorithm.RS256,
+    Algorithm.RS384,
+    Algorithm.RS512,
+    Algorithm.ES256,
+    Algorithm.ES384,
+    Algorithm.PS256,
+    Algorithm.PS384,
+    Algorithm.PS512,
+]);

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

@@ -1,4 +1,3 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { Algorithm, AlgorithmSchema } from './jwt.js';
 describe('Common Schema - JWT', () => {
@@ -21,34 +20,41 @@ describe('Common Schema - JWT', () => {
     });
     describe('AlgorithmSchema', () => {
         test('should accept valid HMAC algorithms', () => {
-            expect(AlgorithmSchema('HS256')).not.toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema('HS384')).not.toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema('HS512')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema.safeParse('HS256').success).toBe(true);
+            expect(AlgorithmSchema.safeParse('HS384').success).toBe(true);
+            expect(AlgorithmSchema.safeParse('HS512').success).toBe(true);
         });
         test('should accept valid RSA algorithms', () => {
-            expect(AlgorithmSchema('RS256')).not.toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema('RS384')).not.toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema('RS512')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema.safeParse('RS256').success).toBe(true);
+            expect(AlgorithmSchema.safeParse('RS384').success).toBe(true);
+            expect(AlgorithmSchema.safeParse('RS512').success).toBe(true);
         });
         test('should accept valid ECDSA algorithms', () => {
-            expect(AlgorithmSchema('ES256')).not.toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema('ES384')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema.safeParse('ES256').success).toBe(true);
+            expect(AlgorithmSchema.safeParse('ES384').success).toBe(true);
         });
         test('should accept valid PSS algorithms', () => {
-            expect(AlgorithmSchema('PS256')).not.toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema('PS384')).not.toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema('PS512')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema.safeParse('PS256').success).toBe(true);
+            expect(AlgorithmSchema.safeParse('PS384').success).toBe(true);
+            expect(AlgorithmSchema.safeParse('PS512').success).toBe(true);
         });
         test('should reject invalid algorithms', () => {
-            expect(AlgorithmSchema('INVALID')).toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema('HS128')).toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema('RS128')).toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema('')).toBeInstanceOf(type.errors);
+            const result1 = AlgorithmSchema.safeParse('INVALID');
+            expect(result1.success).toBe(false);
+            const result2 = AlgorithmSchema.safeParse('HS128');
+            expect(result2.success).toBe(false);
+            const result3 = AlgorithmSchema.safeParse('RS128');
+            expect(result3.success).toBe(false);
+            const result4 = AlgorithmSchema.safeParse('');
+            expect(result4.success).toBe(false);
         });
         test('should reject non-string values', () => {
-            expect(AlgorithmSchema(123)).toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema(null)).toBeInstanceOf(type.errors);
-            expect(AlgorithmSchema(undefined)).toBeInstanceOf(type.errors);
+            const result1 = AlgorithmSchema.safeParse(123);
+            expect(result1.success).toBe(false);
+            const result2 = AlgorithmSchema.safeParse(null);
+            expect(result2.success).toBe(false);
+            const result3 = AlgorithmSchema.safeParse(undefined);
+            expect(result3.success).toBe(false);
         });
     });
 });

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

@@ -1,55 +1,38 @@
+import { z } from 'zod';
 /**
  * Value
  */
-export declare const MetadataValueSchema: import("arktype").BaseType<string | number | boolean, {}>;
+export declare const MetadataValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
 /**
  * Record
  */
-declare const MetadataRecordSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    [x: string]: string | number | boolean;
-}, {}>;
-export type MetadataRecord = typeof MetadataRecordSchema.inferOut;
+declare const MetadataRecordSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+export type MetadataRecord = z.output<typeof MetadataRecordSchema>;
 /**
  * Map
  */
-declare const MetadataMapSchema: import("arktype/internal/methods/object.ts").ObjectType<Map<string, string | number | boolean>, {}>;
-export type MetadataMap = typeof MetadataMapSchema.inferOut;
-export declare const MetadataPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: {
-    [x: string]: string | number | boolean;
-} | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
-    [x: string]: string | number | boolean;
-} | undefined>, {}>;
-export type MetadataPayload = typeof MetadataPayloadSchema.inferOut;
-export declare const MetadataPayloadPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
-        [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
-}, {}>;
-export type MetadataPayloadProperty = typeof MetadataPayloadPropertySchema.inferOut;
-export declare const UpsertMetadataPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: {
-    [x: string]: string | number | boolean;
-} | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
-    [x: string]: string | number | boolean;
-} | null>, {}>;
-export type UpsertMetadataInput = typeof UpsertMetadataPayloadSchema.inferIn;
-export type UpsertMetadataPayload = typeof UpsertMetadataPayloadSchema.inferOut;
-export declare const UpsertMetadataPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
-        [x: string]: string | number | boolean;
-    } | null>) | undefined;
-}, {}>;
-export type UpsertMetadataPropertyInput = typeof UpsertMetadataPropertyPayloadSchema.inferIn;
-export type UpsertMetadataPropertyPayload = typeof UpsertMetadataPropertyPayloadSchema.inferOut;
+declare const MetadataMapSchema: z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>;
+export type MetadataMap = z.output<typeof MetadataMapSchema>;
+export declare const MetadataPayloadSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>;
+export type MetadataPayload = z.output<typeof MetadataPayloadSchema>;
+export declare const MetadataPayloadPropertySchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+}, z.core.$strip>;
+export type MetadataPayloadProperty = z.output<typeof MetadataPayloadPropertySchema>;
+export declare const UpsertMetadataPayloadSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | null | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>;
+export type UpsertMetadataInput = z.input<typeof UpsertMetadataPayloadSchema>;
+export type UpsertMetadataPayload = z.output<typeof UpsertMetadataPayloadSchema>;
+export declare const UpsertMetadataPropertyPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | null | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+}, z.core.$strip>;
+export type UpsertMetadataPropertyInput = z.input<typeof UpsertMetadataPropertyPayloadSchema>;
+export type UpsertMetadataPropertyPayload = z.output<typeof UpsertMetadataPropertyPayloadSchema>;
 export declare function buildMetadataPayload(map: MetadataMap | MetadataRecord): MetadataRecord | undefined;
 export declare function buildUpsertMetadataPayload(map: MetadataMap | MetadataRecord): MetadataRecord | null;
 export declare function buildUpsertMetadataPayloadFromIterable(metadata: Iterable<[string, string | number | boolean]> | null): MetadataRecord | null;
-export declare const MetadataMapPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
-}, {}>;
-export type MetadataMapProperty = typeof MetadataMapPropertySchema.inferOut;
+export declare const MetadataMapPropertySchema: z.ZodObject<{
+    metadata: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Map<string, string | number | boolean>, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>;
+}, z.core.$strip>;
+export type MetadataMapProperty = z.output<typeof MetadataMapPropertySchema>;
 export {};
 //# sourceMappingURL=metadata.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/metadata.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,mBAAmB,2DAAoC,CAAC;AAErE;;GAEG;AACH,QAAA,MAAM,oBAAoB;;MAA4C,CAAC;AACvE,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAElE;;GAEG;AACH,QAAA,MAAM,iBAAiB,qGAEtB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAoB5D,eAAO,MAAM,qBAAqB;;;;mBAW/B,CAAC;AACJ,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC;AAEpE,eAAO,MAAM,6BAA6B;;;;;;MAExC,CAAC;AACH,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,2BAA2B;;;;cAWrC,CAAC;AACJ,MAAM,MAAM,mBAAmB,GAAG,OAAO,2BAA2B,CAAC,OAAO,CAAC;AAC7E,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,QAAQ,CAAC;AAEhF,eAAO,MAAM,mCAAmC;;;;;;MAE9C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,mCAAmC,CAAC,OAAO,CAAC;AACrD,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC;AAEtD,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,WAAW,GAAG,cAAc,GAChC,cAAc,GAAG,SAAS,CAgB5B;AAED,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,WAAW,GAAG,cAAc,GAChC,cAAc,GAAG,IAAI,CAMvB;AAED,wBAAgB,sCAAsC,CACpD,QAAQ,EAAE,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,GAC7D,cAAc,GAAG,IAAI,CAgBvB;AAQD,eAAO,MAAM,yBAAyB;;MAEpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,mBAAmB,+DAI9B,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,oBAAoB,yFAA4C,CAAC;AACvE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEnE;;GAEG;AACH,QAAA,MAAM,iBAAiB,6FAEtB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAuB7D,eAAO,MAAM,qBAAqB,iaAK9B,CAAC;AACL,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAErE,eAAO,MAAM,6BAA6B;;iBAExC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAC5C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,2BAA2B,waAOpC,CAAC;AACL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAC9E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC1C,OAAO,2BAA2B,CACnC,CAAC;AAEF,eAAO,MAAM,mCAAmC;;iBAE9C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,mCAAmC,CAC3C,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAClD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,WAAW,GAAG,cAAc,GAChC,cAAc,GAAG,SAAS,CAgB5B;AAED,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,WAAW,GAAG,cAAc,GAChC,cAAc,GAAG,IAAI,CAMvB;AAED,wBAAgB,sCAAsC,CACpD,QAAQ,EAAE,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,GAC7D,cAAc,GAAG,IAAI,CAgBvB;AASD,eAAO,MAAM,yBAAyB;;iBAEpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

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

@@ -1,50 +1,49 @@
-import { match, type } from 'arktype';
+import { z } from 'zod';
 /**
  * Value
  */
-export const MetadataValueSchema = type('string | number | boolean');
+export const MetadataValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+]);
 /**
  * Record
  */
-const MetadataRecordSchema = type({ '[string]': MetadataValueSchema });
+const MetadataRecordSchema = z.record(z.string(), MetadataValueSchema);
 /**
  * Map
  */
-const MetadataMapSchema = type.instanceOf((Map));
+const MetadataMapSchema = z.instanceof((Map));
 /**
- * Record To Map
+ * Record To Map transformation function
  */
-const MetadataMapMatch = match({
-    undefined: () => new Map(),
-})
-    .case(MetadataMapSchema, (s) => new Map(s))
-    .case(MetadataRecordSchema, (s) => new Map(Object.entries(s || {}).map(([key, value]) => [key, value])))
-    .default(() => new Map());
-export const MetadataPayloadSchema = type('undefined | null')
-    .or(MetadataMapSchema)
-    .or(MetadataRecordSchema)
-    .pipe((map) => (map ? buildMetadataPayload(map) : undefined))
-    .narrow((n, ctx) => n && Object.keys(n).length > 10
-    ? ctx.reject({
-        expected: '10 items or less',
-        actual: `${Object.keys(n).length}`,
-    })
-    : true);
-export const MetadataPayloadPropertySchema = type({
-    'metadata?': MetadataPayloadSchema,
+function transformToMetadataMap(input) {
+    if (input == null) {
+        return new Map();
+    }
+    if (input instanceof Map) {
+        return new Map(input);
+    }
+    return new Map(Object.entries(input || {}).map(([key, value]) => [key, value]));
+}
+export const MetadataPayloadSchema = z
+    .union([z.undefined(), z.null(), MetadataMapSchema, MetadataRecordSchema])
+    .transform((map) => (map ? buildMetadataPayload(map) : undefined))
+    .refine((n) => !n || Object.keys(n).length <= 10, {
+    message: 'Metadata must have 10 items or less',
+});
+export const MetadataPayloadPropertySchema = z.object({
+    metadata: MetadataPayloadSchema.optional(),
+});
+export const UpsertMetadataPayloadSchema = z
+    .union([z.undefined(), z.null(), MetadataMapSchema, MetadataRecordSchema])
+    .pipe(z.transform((map) => (map ? buildUpsertMetadataPayload(map) || null : map)))
+    .refine((n) => !n || Object.keys(n).length <= 10, {
+    message: 'Metadata must have 10 items or less',
 });
-export const UpsertMetadataPayloadSchema = type('undefined | null')
-    .or(MetadataMapSchema)
-    .or(MetadataRecordSchema)
-    .pipe((map) => (map ? buildUpsertMetadataPayload(map) || null : null))
-    .narrow((n, ctx) => n && Object.keys(n).length > 10
-    ? ctx.reject({
-        expected: '10 items or less',
-        actual: `${Object.keys(n).length}`,
-    })
-    : true);
-export const UpsertMetadataPropertyPayloadSchema = type({
-    'metadata?': UpsertMetadataPayloadSchema,
+export const UpsertMetadataPropertyPayloadSchema = z.object({
+    metadata: UpsertMetadataPayloadSchema.optional(),
 });
 export function buildMetadataPayload(map) {
     if (!(map instanceof Map)) {
@@ -81,8 +80,10 @@ export function buildUpsertMetadataPayloadFromIterable(metadata) {
 /**
  * Map
  */
-const ToMetadataMapSchema = MetadataMapMatch.default(() => new Map());
-export const MetadataMapPropertySchema = type({
+const ToMetadataMapSchema = z
+    .union([z.undefined(), z.null(), MetadataMapSchema, MetadataRecordSchema])
+    .pipe(z.transform(transformToMetadataMap));
+export const MetadataMapPropertySchema = z.object({
     metadata: ToMetadataMapSchema,
 });
 // export const metadataAttributeScope = scope({