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

package/dist/esm/customer/users/schema.js

@@ -1,4 +1,4 @@
-import { type } from 'arktype';
+import { z } from 'zod';
 import { RoleIdAssociationsSchema } from '../../authorization/schema.js';
 import { AggregateSchema } from '../../common/schema/aggregate.js';
 import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../../common/schema/dates.js';
@@ -14,78 +14,90 @@ export const UserStatus = {
     SUSPENDED: 'suspended',
     UNVERIFIED: 'unverified',
 };
-const UserStatusSchema = type.enumerated(UserStatus.ACTIVE, UserStatus.SUSPENDED, UserStatus.UNVERIFIED);
-export const UserNamePropertiesSchema = type({
-    givenName: optionallyNullishToUndefined(type('string')),
-    middleName: optionallyNullishToUndefined(type('string')),
-    familyName: optionallyNullishToUndefined(type('string')),
-    honorificPrefix: optionallyNullishToUndefined(type('string')),
-    honorificSuffix: optionallyNullishToUndefined(type('string')),
+const UserStatusSchema = z.enum([
+    UserStatus.ACTIVE,
+    UserStatus.SUSPENDED,
+    UserStatus.UNVERIFIED,
+]);
+export const UserNamePropertiesSchema = z.object({
+    givenName: optionallyNullishToUndefined(z.string()),
+    middleName: optionallyNullishToUndefined(z.string()),
+    familyName: optionallyNullishToUndefined(z.string()),
+    honorificPrefix: optionallyNullishToUndefined(z.string()),
+    honorificSuffix: optionallyNullishToUndefined(z.string()),
 });
 // export type UserNameProperties = typeof UserNamePropertiesSchema.inferOut;
-export const UpdateUserNamePropertiesSchema = type({
-    givenName: optionallyNullish(type('string')),
-    middleName: optionallyNullish(type('string')),
-    familyName: optionallyNullish(type('string')),
-    honorificPrefix: optionallyNullish(type('string')),
-    honorificSuffix: optionallyNullish(type('string')),
+export const UpdateUserNamePropertiesSchema = z.object({
+    givenName: optionallyNullish(z.string()),
+    middleName: optionallyNullish(z.string()),
+    familyName: optionallyNullish(z.string()),
+    honorificPrefix: optionallyNullish(z.string()),
+    honorificSuffix: optionallyNullish(z.string()),
 });
 // type UpsertUserNameProperties = typeof UpdateUserNamePropertiesSchema.inferOut;
-export const UserIdPropertySchema = type({
+export const UserIdPropertySchema = z.object({
     id: UserIdSchema,
 });
-export const RequiredEmailSchema = type('string.email');
-export const RequiredPhoneNumberSchema = type('string');
-export const VerifiedEmailOrPhonePropertiesSchema = type({
+export const RequiredEmailSchema = z.email();
+export const RequiredPhoneNumberSchema = z.string();
+export const VerifiedEmailOrPhonePropertiesSchema = z.object({
     email: optionallyNullishToUndefined(RequiredEmailSchema),
-    verifiedEmail: optionallyNullishToUndefined(type('boolean')),
+    verifiedEmail: optionallyNullishToUndefined(z.boolean()),
     phoneNumber: optionallyNullishToUndefined(RequiredPhoneNumberSchema),
-    verifiedPhoneNumber: optionallyNullishToUndefined(type('boolean')),
+    verifiedPhoneNumber: optionallyNullishToUndefined(z.boolean()),
 });
-export const EmailOrPhonePropertiesSchema = type({
+export const EmailOrPhonePropertiesSchema = z.object({
     email: optionallyNullishToUndefined(RequiredEmailSchema),
     phoneNumber: optionallyNullishToUndefined(RequiredPhoneNumberSchema),
 });
-export const UserAssociationsSchema = type({
+export const UserAssociationsSchema = z.object({
     roles: RoleIdAssociationsSchema.optional(),
 });
-const BaseSchema = UserIdPropertySchema.and(UserNamePropertiesSchema)
-    .and(VerifiedEmailOrPhonePropertiesSchema)
-    .and({
+const BaseSchema = z.object({
+    ...UserIdPropertySchema.shape,
+    ...UserNamePropertiesSchema.shape,
+    ...VerifiedEmailOrPhonePropertiesSchema.shape,
     status: UserStatusSchema,
     roles: optionallyUndefined(AggregateSchema),
 });
-export const UserSchema = BaseSchema.and({
+export const UserSchema = z.object({
+    ...BaseSchema.shape,
     lastLogin: OptionalDateSchema.optional(),
     createdAt: RequiredDateSchema,
     updatedAt: RequiredDateSchema,
     deletedAt: OptionalDateSchema.optional(),
     deactivatedAt: OptionalDateSchema.optional(),
-}).and(MetadataMapPropertySchema);
-export const UserPayloadSchema = BaseSchema.and({
+    ...MetadataMapPropertySchema.shape,
+});
+export const UserPayloadSchema = z.object({
+    ...BaseSchema.shape,
     lastLogin: OptionalDatePayloadSchema.optional(),
     createdAt: RequiredDatePayloadSchema,
     updatedAt: RequiredDatePayloadSchema,
-    'deletedAt?': OptionalDatePayloadSchema,
-    'deactivatedAt?': OptionalDatePayloadSchema,
-}).and(MetadataPayloadPropertySchema);
-export const InsertUserPayloadSchema = type({
+    deletedAt: OptionalDatePayloadSchema.optional(),
+    deactivatedAt: OptionalDatePayloadSchema.optional(),
+    ...MetadataPayloadPropertySchema.shape,
+});
+export const InsertUserPayloadSchema = z.object({
     id: UserIdSchema.optional(),
-})
-    .and(UserNamePropertiesSchema)
-    .and(VerifiedEmailOrPhonePropertiesSchema)
-    .and(UserAssociationsSchema)
-    .and(UpsertMetadataPropertyPayloadSchema);
-export const UpdateUserPayloadSchema = type({
-    suspended: type.boolean.optional(),
-})
-    .and(UpdateUserNamePropertiesSchema)
-    .and(VerifiedEmailOrPhonePropertiesSchema)
-    .and(UpsertMetadataPropertyPayloadSchema);
+    ...UserNamePropertiesSchema.shape,
+    ...VerifiedEmailOrPhonePropertiesSchema.shape,
+    ...UserAssociationsSchema.shape,
+    ...UpsertMetadataPropertyPayloadSchema.shape,
+});
+export const UpdateUserPayloadSchema = z.object({
+    suspended: z.boolean().optional(),
+    ...UpdateUserNamePropertiesSchema.shape,
+    ...VerifiedEmailOrPhonePropertiesSchema.shape,
+    ...UpsertMetadataPropertyPayloadSchema.shape,
+});
 /**
  * Association
  */
-export const UserAssociationReferenceSchema = UserIdPropertySchema.and(UserNamePropertiesSchema).and(EmailOrPhonePropertiesSchema.and(type({
+export const UserAssociationReferenceSchema = z.object({
+    ...UserIdPropertySchema.shape,
+    ...UserNamePropertiesSchema.shape,
+    ...EmailOrPhonePropertiesSchema.shape,
     status: UserStatusSchema.default('unverified'),
-    model: "'User'",
-})));
+    model: z.literal('User'),
+});

package/dist/esm/customer/users/schema.test.js

@@ -1,4 +1,3 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { generateUserId } from '../schema.js';
 import { InsertUserPayloadSchema, UserPayloadSchema, UserStatus, } from './schema.js';
@@ -13,12 +12,12 @@ describe('Customer - User', () => {
                 createdAt: new Date(),
                 updatedAt: new Date(),
             };
-            const result = UserPayloadSchema(item);
-            if (result instanceof type.errors) {
-                console.log(result.summary);
+            const result = UserPayloadSchema.safeParse(item);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.metadata).toBeUndefined();
             }
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata).to.undefined;
         });
     });
     describe('Insert User Payload', () => {
@@ -29,13 +28,13 @@ describe('Customer - User', () => {
                 familyName: 'Foo',
                 phoneNumber: '123',
             };
-            const result = InsertUserPayloadSchema(item);
-            if (result instanceof type.errors) {
-                console.log(result.summary);
+            const result = InsertUserPayloadSchema.safeParse(item);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.metadata).toBeUndefined();
+                expect(result.data.familyName).toBe(item.familyName);
             }
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata).to.undefined;
-            expect(result?.familyName).to.equal(item.familyName);
         });
         test('should serialize successfully', async () => {
             const item = {
@@ -43,16 +42,13 @@ describe('Customer - User', () => {
                 id: generateUserId(),
                 phoneNumber: '123',
                 metadata: new Map(),
-                // status: UserStatus.ACTIVE,
-                // createdAt: new Date(),
-                // updatedAt: new Date(),
             };
-            const result = InsertUserPayloadSchema(item);
-            if (result instanceof type.errors) {
-                console.log(result.summary);
+            const result = InsertUserPayloadSchema.safeParse(item);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.metadata).toBeNull();
             }
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata).to.null;
         });
         test('should serialize nulls successfully', async () => {
             const payload = {
@@ -70,11 +66,9 @@ describe('Customer - User', () => {
                 createdAt: '2025-04-02T03:50:40.812Z',
                 updatedAt: '2025-04-02T03:50:40.812Z',
             };
-            const result = UserPayloadSchema(payload);
-            if (result instanceof type.errors) {
-                console.log(result.summary);
-            }
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = UserPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
         });
         test('should serialize nulls successfully', async () => {
             const payload = {
@@ -92,16 +86,9 @@ describe('Customer - User', () => {
                 createdAt: '2025-04-02T03:50:40.812Z',
                 updatedAt: '2025-04-02T03:50:40.812Z',
             };
-            const test = type({
-                foo: 'string.numeric.parse',
-                bar: 'number',
-                baz: 'string.date.iso.parse',
-            });
-            const result = UserPayloadSchema(payload);
-            if (result instanceof type.errors) {
-                console.log(result.summary);
-            }
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = UserPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
         });
     });
 });

package/dist/esm/customer/users/utils.d.ts

@@ -1,6 +1,7 @@
+import type { z } from 'zod';
 import type { EmailOrPhonePropertiesSchema, UpdateUserNamePropertiesSchema } from './schema.js';
-type UserName = typeof UpdateUserNamePropertiesSchema.inferIn;
-type UserEmailOrPhone = typeof EmailOrPhonePropertiesSchema.inferIn;
+type UserName = z.input<typeof UpdateUserNamePropertiesSchema>;
+type UserEmailOrPhone = z.input<typeof EmailOrPhonePropertiesSchema>;
 type User = UserName & UserEmailOrPhone;
 export declare function getInitials(name: string | undefined): string | undefined;
 export declare function buildName(item?: Pick<UserName, 'givenName' | 'familyName'>): string;

package/dist/esm/customer/users/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/customer/users/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,8BAA8B,EAC/B,MAAM,aAAa,CAAC;AAErB,KAAK,QAAQ,GAAG,OAAO,8BAA8B,CAAC,OAAO,CAAC;AAC9D,KAAK,gBAAgB,GAAG,OAAO,4BAA4B,CAAC,OAAO,CAAC;AAEpE,KAAK,IAAI,GAAG,QAAQ,GAAG,gBAAgB,CAAC;AAExC,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAUxE;AAED,wBAAgB,SAAS,CACvB,IAAI,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,YAAY,CAAC,GAChD,MAAM,CAER;AAED,wBAAgB,eAAe,CAC7B,IAAI,CAAC,EAAE,IAAI,CACT,QAAQ,EACN,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,iBAAiB,GACjB,iBAAiB,CACpB,EACD,iBAAiB,UAAQ,GACxB,MAAM,CAUR;AAED,wBAAgB,cAAc,CAC5B,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,EAAE,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,GACtD,MAAM,CAER"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/customer/users/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EACV,4BAA4B,EAC5B,8BAA8B,EAC/B,MAAM,aAAa,CAAC;AAErB,KAAK,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAC/D,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAErE,KAAK,IAAI,GAAG,QAAQ,GAAG,gBAAgB,CAAC;AAExC,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAUxE;AAED,wBAAgB,SAAS,CACvB,IAAI,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,YAAY,CAAC,GAChD,MAAM,CAER;AAED,wBAAgB,eAAe,CAC7B,IAAI,CAAC,EAAE,IAAI,CACT,QAAQ,EACN,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,iBAAiB,GACjB,iBAAiB,CACpB,EACD,iBAAiB,UAAQ,GACxB,MAAM,CAUR;AAED,wBAAgB,cAAc,CAC5B,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,EAAE,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,GACtD,MAAM,CAER"}

package/dist/esm/customer/users/utils.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { getInitials, buildName, buildProperName, buildReference, } from './utils.js';
+import { buildName, buildProperName, buildReference, getInitials, } from './utils.js';
 describe('Customer Users - Utils', () => {
     describe('getInitials', () => {
         test('should return initials for single name', () => {

package/dist/esm/identity/schema.d.ts

@@ -1,7 +1,11 @@
+import { z } from 'zod';
 export declare const IdentityIdentifier: {
     readonly EMAIL: "email";
     readonly PHONE_NUMBER: "phoneNumber";
 };
 export type AnyIdentityIdentifier = (typeof IdentityIdentifier)[keyof typeof IdentityIdentifier];
-export declare const IdentityIdentifierSchema: import("arktype/internal/methods/string.ts").StringType<"email" | "phoneNumber", {}>;
+export declare const IdentityIdentifierSchema: z.ZodEnum<{
+    email: "email";
+    phoneNumber: "phoneNumber";
+}>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/esm/identity/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/identity/schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAC/B,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,wBAAwB,sFAGpC,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/identity/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAC/B,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,wBAAwB;;;EAG1B,CAAC"}

package/dist/esm/identity/schema.js

@@ -1,6 +1,9 @@
-import { type } from 'arktype';
+import { z } from 'zod';
 export const IdentityIdentifier = {
     EMAIL: 'email',
     PHONE_NUMBER: 'phoneNumber',
 };
-export const IdentityIdentifierSchema = type.enumerated(IdentityIdentifier.EMAIL, IdentityIdentifier.PHONE_NUMBER);
+export const IdentityIdentifierSchema = z.enum([
+    IdentityIdentifier.EMAIL,
+    IdentityIdentifier.PHONE_NUMBER,
+]);

package/dist/esm/identity/schema.test.js

@@ -1,4 +1,3 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { IdentityIdentifier, IdentityIdentifierSchema } from './schema.js';
 describe('Identity - Schema', () => {
@@ -10,29 +9,35 @@ describe('Identity - Schema', () => {
     });
     describe('IdentityIdentifierSchema', () => {
         test('should accept valid email identifier', () => {
-            const result = IdentityIdentifierSchema('email');
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBe('email');
+            const result = IdentityIdentifierSchema.safeParse('email');
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe('email');
+            }
         });
         test('should accept valid phone number identifier', () => {
-            const result = IdentityIdentifierSchema('phoneNumber');
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBe('phoneNumber');
+            const result = IdentityIdentifierSchema.safeParse('phoneNumber');
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe('phoneNumber');
+            }
         });
         test('should reject invalid identifiers', () => {
-            expect(IdentityIdentifierSchema('username')).toBeInstanceOf(type.errors);
-            expect(IdentityIdentifierSchema('invalid')).toBeInstanceOf(type.errors);
-            expect(IdentityIdentifierSchema('')).toBeInstanceOf(type.errors);
+            expect(IdentityIdentifierSchema.safeParse('invalid').success).toBe(false);
+            expect(IdentityIdentifierSchema.safeParse('username').success).toBe(false);
+            expect(IdentityIdentifierSchema.safeParse('sms').success).toBe(false);
         });
         test('should reject non-string values', () => {
-            expect(IdentityIdentifierSchema(123)).toBeInstanceOf(type.errors);
-            expect(IdentityIdentifierSchema(null)).toBeInstanceOf(type.errors);
-            expect(IdentityIdentifierSchema(undefined)).toBeInstanceOf(type.errors);
+            expect(IdentityIdentifierSchema.safeParse(123).success).toBe(false);
+            expect(IdentityIdentifierSchema.safeParse(null).success).toBe(false);
+            expect(IdentityIdentifierSchema.safeParse(undefined).success).toBe(false);
         });
         test('should be case sensitive', () => {
-            expect(IdentityIdentifierSchema('Email')).toBeInstanceOf(type.errors);
-            expect(IdentityIdentifierSchema('PHONE_NUMBER')).toBeInstanceOf(type.errors);
-            expect(IdentityIdentifierSchema('phonenumber')).toBeInstanceOf(type.errors);
+            expect(IdentityIdentifierSchema.safeParse('EMAIL').success).toBe(false);
+            expect(IdentityIdentifierSchema.safeParse('PHONE_NUMBER').success).toBe(false);
+            expect(IdentityIdentifierSchema.safeParse('phonenumber').success).toBe(false);
         });
     });
 });

package/dist/esm/oauth/authorize/schema/grants/authorization-code.d.ts

@@ -1,29 +1,32 @@
-export declare const AuthorizationCodeSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    response_type: "code";
-    client_id: string;
-    redirect_uri?: string | undefined;
-    scope?: string | undefined;
-    state?: string | undefined;
-    nonce?: string | undefined;
-    display?: "page" | "popup" | "touch" | "wap" | undefined;
-    prompt?: "none" | "login" | "consent" | "select_account" | undefined;
-    max_age?: number | undefined;
-    code_challenge_method?: "S256" | "plain" | undefined;
-    code_challenge?: string | undefined;
-    audience?: string | undefined;
-} | {
-    response_type: "code";
-    client_id: string;
-    redirect_uri?: string | undefined;
-    scope?: string | undefined;
-    state?: string | undefined;
-    nonce?: string | undefined;
-    display?: "page" | "popup" | "touch" | "wap" | undefined;
-    prompt?: "none" | "login" | "consent" | "select_account" | undefined;
-    max_age?: number | undefined;
-    code_challenge_method: "S256" | "plain";
-    code_challenge: string;
-    audience?: string | undefined;
-}, {}>;
-export type AuthorizationCodePayload = typeof AuthorizationCodeSchema.inferOut;
+import { z } from 'zod';
+export declare const AuthorizationCodeSchema: z.ZodObject<{
+    code_challenge_method: z.ZodOptional<z.ZodEnum<{
+        S256: "S256";
+        plain: "plain";
+    }>>;
+    code_challenge: z.ZodOptional<z.ZodString>;
+    audience: z.ZodOptional<z.ZodString>;
+    nonce: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodEnum<{
+        page: "page";
+        popup: "popup";
+        touch: "touch";
+        wap: "wap";
+    }>>;
+    prompt: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        login: "login";
+        consent: "consent";
+        select_account: "select_account";
+    }>>;
+    max_age: z.ZodOptional<z.ZodNumber>;
+    response_type: z.ZodEnum<{
+        code: "code";
+    }>;
+    client_id: z.ZodString;
+    redirect_uri: z.ZodOptional<z.ZodURL>;
+    scope: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AuthorizationCodePayload = z.output<typeof AuthorizationCodeSchema>;
 //# sourceMappingURL=authorization-code.d.ts.map

package/dist/esm/oauth/authorize/schema/grants/authorization-code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authorization-code.d.ts","sourceRoot":"","sources":["../../../../../../src/oauth/authorize/schema/grants/authorization-code.ts"],"names":[],"mappings":"AA8DA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,CAAC;AACvB,MAAM,MAAM,wBAAwB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"authorization-code.d.ts","sourceRoot":"","sources":["../../../../../../src/oauth/authorize/schema/grants/authorization-code.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyDxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBhC,CAAC;AACL,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/esm/oauth/authorize/schema/grants/authorization-code.js

@@ -1,50 +1,69 @@
-import { type } from 'arktype';
+import { z } from 'zod';
 import { AppIdSchema } from '../../../../app/schema.js';
 import { AuthorizationDisplaySchema, AuthorizationPromptSchema, CodeChallengeMethodSchema, OptionalSchema, ResponseType, } from '../../../common/schema.js';
 /**
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.1
  * @see https://openid.net/specs/openid-connect-core-1_0.html#rfc.section.3.1.2.1
  */
-const ResponseTypeSchema = type.enumerated(ResponseType.CODE);
-const PKCESchema = type({
+const ResponseTypeSchema = z.enum([ResponseType.CODE]);
+const CodeChallengeSchema = z
+    .string()
+    .min(43, 'Code challenge must be at least 43 characters long.')
+    .max(128, 'Code challenge must be at most 128 characters long.')
+    .regex(/^[A-Za-z0-9\-_.~]+$/, 'Code challenge contains invalid characters.') // Base64url-encoded string
+    .describe('PKCE code challenge, derived from the code verifier.');
+// const PKCESchema = z.union([
+//   z.object({
+//     code_challenge_method: CodeChallengeMethodSchema.optional(),
+//     code_challenge: z.string().optional(),
+//   }),
+//   z.object({
+//     code_challenge_method: CodeChallengeMethodSchema,
+//     code_challenge: z.string().min(1),
+//   })
+// ]).refine((data) => {
+//   return (
+//     (data.code_challenge_method && data.code_challenge) ||
+//     (!data.code_challenge_method && !data.code_challenge)
+//   );
+// }, {
+//   message: 'code_challenge and code_challenge_method must both be present or both be absent',
+// });
+const OAuthSchema = z.object({
+    response_type: ResponseTypeSchema,
+    client_id: AppIdSchema,
+    redirect_uri: z.url().optional(),
+    scope: z.string().optional(),
+    state: z.string().optional(),
+});
+const OIDCSchema = z.object({
+    nonce: z.string().optional(),
+    display: AuthorizationDisplaySchema.optional(),
+    prompt: AuthorizationPromptSchema.optional(),
+    max_age: z.number().int().min(0).optional(),
+});
+export const AuthorizationCodeSchema = z
+    .object({
+    ...OAuthSchema.shape,
+    ...OIDCSchema.shape,
+    ...OptionalSchema.shape,
     code_challenge_method: CodeChallengeMethodSchema.optional(),
-    code_challenge: type('string').optional(),
-})
-    .or({
-    code_challenge_method: CodeChallengeMethodSchema,
-    code_challenge: type('string').moreThanLength(0),
+    code_challenge: CodeChallengeSchema.optional(),
 })
-    .narrow((data, ctx) => {
-    if ((data.code_challenge_method && data.code_challenge) ||
-        (!data.code_challenge_method && !data.code_challenge)) {
-        return true;
+    .superRefine((data, ctx) => {
+    // If one is present, the other must also be present
+    if (data.code_challenge && !data.code_challenge_method) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'code_challenge_method is required when code_challenge is present',
+            path: ['code_challenge_method'],
+        });
     }
-    if (data.code_challenge_method && !data.code_challenge) {
-        return ctx.reject({
-            expected: 'is required',
-            actual: '',
+    else if (!data.code_challenge && data.code_challenge_method) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'code_challenge is required when code_challenge_method is present',
             path: ['code_challenge'],
         });
     }
-    return ctx.reject({
-        expected: 'is required',
-        actual: '',
-        path: ['code_challenge_method'],
-    });
-});
-const OAuthSchema = type({
-    response_type: ResponseTypeSchema,
-    client_id: AppIdSchema,
-    redirect_uri: type('string.url').optional(),
-    scope: type('string').optional(),
-    state: type('string').optional(),
-});
-const OIDCSchema = type({
-    nonce: type('string').optional(),
-    display: AuthorizationDisplaySchema.optional(),
-    prompt: AuthorizationPromptSchema.optional(),
-    max_age: type.keywords.number.integer.atLeast(0).optional(),
 });
-export const AuthorizationCodeSchema = OAuthSchema.and(OIDCSchema)
-    .and(PKCESchema)
-    .and(OptionalSchema);