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

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

@@ -1,4 +1,3 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { AuthorizationDisplay, AuthorizationDisplaySchema, AuthorizationPrompt, AuthorizationPromptSchema, CodeChallengeMethod, CodeChallengeMethodSchema, GrantType, GrantTypeLabel, OAuthScope, OIDCScope, OptionalSchema, ResponseType, Scope, ScopeSchema, } from './schema.js';
 describe('OAuth Common Schema', () => {
@@ -60,14 +59,14 @@ describe('OAuth Common Schema', () => {
             expect(CodeChallengeMethod.PLAIN).toBe('plain');
         });
         test('CodeChallengeMethodSchema should validate valid methods', () => {
-            const validResult1 = CodeChallengeMethodSchema('S256');
+            const validResult1 = CodeChallengeMethodSchema.parse('S256');
             expect(validResult1).toBe('S256');
-            const validResult2 = CodeChallengeMethodSchema('plain');
+            const validResult2 = CodeChallengeMethodSchema.parse('plain');
             expect(validResult2).toBe('plain');
         });
         test('CodeChallengeMethodSchema should reject invalid methods', () => {
-            const invalidResult = CodeChallengeMethodSchema('invalid_method');
-            expect(invalidResult).toBeInstanceOf(type.errors);
+            const invalidResult = CodeChallengeMethodSchema.safeParse('invalid_method');
+            expect(invalidResult.success).toBe(false);
         });
         test('AnyCodeChallengeMethod type should work with valid values', () => {
             const validMethods = ['S256', 'plain'];
@@ -86,13 +85,13 @@ describe('OAuth Common Schema', () => {
         test('AuthorizationDisplaySchema should validate valid display values', () => {
             const validDisplays = ['page', 'popup', 'touch', 'wap'];
             for (const display of validDisplays) {
-                const result = AuthorizationDisplaySchema(display);
+                const result = AuthorizationDisplaySchema.parse(display);
                 expect(result).toBe(display);
             }
         });
         test('AuthorizationDisplaySchema should reject invalid display values', () => {
-            const invalidResult = AuthorizationDisplaySchema('invalid_display');
-            expect(invalidResult).toBeInstanceOf(type.errors);
+            const invalidResult = AuthorizationDisplaySchema.safeParse('invalid_display');
+            expect(invalidResult.success).toBe(false);
         });
         test('AnyAuthorizationDisplay type should work with valid values', () => {
             const validDisplays = [
@@ -116,13 +115,13 @@ describe('OAuth Common Schema', () => {
         test('AuthorizationPromptSchema should validate valid prompt values', () => {
             const validPrompts = ['none', 'login', 'consent', 'select_account'];
             for (const prompt of validPrompts) {
-                const result = AuthorizationPromptSchema(prompt);
+                const result = AuthorizationPromptSchema.parse(prompt);
                 expect(result).toBe(prompt);
             }
         });
         test('AuthorizationPromptSchema should reject invalid prompt values', () => {
-            const invalidResult = AuthorizationPromptSchema('invalid_prompt');
-            expect(invalidResult).toBeInstanceOf(type.errors);
+            const invalidResult = AuthorizationPromptSchema.safeParse('invalid_prompt');
+            expect(invalidResult.success).toBe(false);
         });
         test('AnyAuthorizationPrompt type should work with valid values', () => {
             const validPrompts = [
@@ -138,18 +137,18 @@ describe('OAuth Common Schema', () => {
     });
     describe('OptionalSchema', () => {
         test('should validate object with optional audience', () => {
-            const validWithAudience = OptionalSchema({
+            const validWithAudience = OptionalSchema.parse({
                 audience: 'https://api.example.com',
             });
             expect(validWithAudience).toEqual({
                 audience: 'https://api.example.com',
             });
-            const validWithoutAudience = OptionalSchema({});
+            const validWithoutAudience = OptionalSchema.parse({});
             expect(validWithoutAudience).toEqual({});
         });
         test('should reject non-string audience values', () => {
-            const invalidResult = OptionalSchema({ audience: 123 });
-            expect(invalidResult).toBeInstanceOf(type.errors);
+            const invalidResult = OptionalSchema.safeParse({ audience: 123 });
+            expect(invalidResult.success).toBe(false);
         });
         test('should allow additional properties to be filtered', () => {
             // Depending on schema configuration, extra properties might be filtered
@@ -157,7 +156,7 @@ describe('OAuth Common Schema', () => {
                 audience: 'https://api.example.com',
                 extraProperty: 'should be handled based on schema config',
             };
-            const result = OptionalSchema(input);
+            const result = OptionalSchema.parse(input);
             // The result depends on schema configuration (onUndeclaredKey behavior)
             expect(result).toHaveProperty('audience', 'https://api.example.com');
         });
@@ -222,15 +221,15 @@ describe('OAuth Common Schema', () => {
                 'offline_access',
             ];
             for (const scope of validScopes) {
-                const result = ScopeSchema(scope);
+                const result = ScopeSchema.parse(scope);
                 expect(result).toBe(scope);
             }
         });
         test('ScopeSchema should reject non-string values', () => {
             const invalidValues = [123, true, null, undefined, {}, []];
             for (const value of invalidValues) {
-                const result = ScopeSchema(value);
-                expect(result).toBeInstanceOf(type.errors);
+                const result = ScopeSchema.safeParse(value);
+                expect(result.success).toBe(false);
             }
         });
     });
@@ -263,25 +262,25 @@ describe('OAuth Common Schema', () => {
     describe('Schema edge cases', () => {
         test('should handle empty strings appropriately', () => {
             const emptyString = '';
-            const scopeResult = ScopeSchema(emptyString);
+            const scopeResult = ScopeSchema.parse(emptyString);
             expect(scopeResult).toBe(emptyString); // Empty string is valid string
-            const challengeResult = CodeChallengeMethodSchema(emptyString);
-            expect(challengeResult).toBeInstanceOf(type.errors); // Empty string not valid enum
+            const challengeResult = CodeChallengeMethodSchema.safeParse(emptyString);
+            expect(challengeResult.success).toBe(false); // Empty string not valid enum
         });
         test('should handle whitespace and special characters', () => {
             const spacedScope = '  openid profile  ';
-            const result = ScopeSchema(spacedScope);
+            const result = ScopeSchema.parse(spacedScope);
             expect(result).toBe(spacedScope); // Preserves whitespace
             const specialScope = 'custom:read+write';
-            const specialResult = ScopeSchema(specialScope);
+            const specialResult = ScopeSchema.parse(specialScope);
             expect(specialResult).toBe(specialScope);
         });
         test('should validate complex optional schema scenarios', () => {
-            const complexValid = OptionalSchema({
+            const complexValid = OptionalSchema.parse({
                 audience: 'urn:example:audience',
             });
             expect(complexValid.audience).toBe('urn:example:audience');
-            const emptyValid = OptionalSchema({});
+            const emptyValid = OptionalSchema.parse({});
             expect(emptyValid).toEqual({});
         });
     });

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

@@ -1,10 +1,13 @@
-export declare const AuthorizationCodeSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    grant_type: "authorization_code";
-    code: string;
-    client_id: string;
-    redirect_uri: string;
-    client_secret?: string | undefined;
-    code_verifier?: string | undefined;
-}, {}>;
-export type AuthorizationCodePayload = typeof AuthorizationCodeSchema.inferOut;
+import { z } from 'zod';
+export declare const AuthorizationCodeSchema: z.ZodObject<{
+    code_verifier: z.ZodOptional<z.ZodString>;
+    grant_type: z.ZodEnum<{
+        authorization_code: "authorization_code";
+    }>;
+    code: z.ZodString;
+    client_id: z.ZodString;
+    client_secret: z.ZodOptional<z.ZodString>;
+    redirect_uri: z.ZodURL;
+}, z.core.$strip>;
+export type AuthorizationCodePayload = z.output<typeof AuthorizationCodeSchema>;
 //# sourceMappingURL=authorization-code.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"authorization-code.d.ts","sourceRoot":"","sources":["../../../../../../src/oauth/token/schema/grants/authorization-code.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,uBAAuB;;;;;;;MAMlB,CAAC;AACnB,MAAM,MAAM,wBAAwB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"authorization-code.d.ts","sourceRoot":"","sources":["../../../../../../src/oauth/token/schema/grants/authorization-code.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,uBAAuB;;;;;;;;;iBAOlC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

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

@@ -1,17 +1,18 @@
-import { type } from 'arktype';
+import { z } from 'zod';
 import { GrantType } from '../../../common/schema.js';
 /**
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.3
  * @see https://openid.net/specs/openid-connect-core-1_0.html#rfc.section.3.1.3.1
  */
-const GrantTypeSchema = type.enumerated(GrantType.AUTHORIZATION_CODE);
-const PKCESchema = type({
-    code_verifier: type('string').optional(),
+const GrantTypeSchema = z.enum([GrantType.AUTHORIZATION_CODE]);
+const PKCESchema = z.object({
+    code_verifier: z.string().optional(),
 });
-export const AuthorizationCodeSchema = type({
+export const AuthorizationCodeSchema = z.object({
     grant_type: GrantTypeSchema,
-    code: type('string'),
-    client_id: type('string'),
-    client_secret: type('string').optional(),
-    redirect_uri: type('string.url'),
-}).and(PKCESchema);
+    code: z.string(),
+    client_id: z.string(),
+    client_secret: z.string().optional(),
+    redirect_uri: z.url(),
+    ...PKCESchema.shape,
+});

package/dist/esm/oauth/token/schema/grants/client-credentials.d.ts

@@ -1,21 +1,26 @@
+import { z } from 'zod';
 /**
  * What the incoming body may look like.
  *
  * Note: the client_id and client_secrete may (likely) be in Authorization header
  */
-export declare const ClientCredentialsPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    grant_type: "client_credentials";
-    scope?: string | undefined;
-    client_id?: string | undefined;
-    client_secret?: string | undefined;
-    audience?: string | undefined;
-}, {}>;
-export declare const ClientCredentialsSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    grant_type: "client_credentials";
-    scope?: string | undefined;
-    audience?: string | undefined;
-    client_id: string;
-    client_secret: string;
-}, {}>;
-export type ClientCredentialsPayload = typeof ClientCredentialsSchema.inferOut;
+export declare const ClientCredentialsPayloadSchema: z.ZodObject<{
+    audience: z.ZodOptional<z.ZodString>;
+    grant_type: z.ZodEnum<{
+        client_credentials: "client_credentials";
+    }>;
+    scope: z.ZodOptional<z.ZodString>;
+    client_id: z.ZodOptional<z.ZodString>;
+    client_secret: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ClientCredentialsSchema: z.ZodObject<{
+    client_id: z.ZodString;
+    client_secret: z.ZodString;
+    audience: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    grant_type: z.ZodEnum<{
+        client_credentials: "client_credentials";
+    }>;
+}, z.core.$strip>;
+export type ClientCredentialsPayload = z.output<typeof ClientCredentialsSchema>;
 //# sourceMappingURL=client-credentials.d.ts.map

package/dist/esm/oauth/token/schema/grants/client-credentials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client-credentials.d.ts","sourceRoot":"","sources":["../../../../../../src/oauth/token/schema/grants/client-credentials.ts"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;;;;MAKrB,CAAC;AAEvB,eAAO,MAAM,uBAAuB;;;;;;MAMlC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"client-credentials.d.ts","sourceRoot":"","sources":["../../../../../../src/oauth/token/schema/grants/client-credentials.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;iBAMzC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;iBAOlC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/esm/oauth/token/schema/grants/client-credentials.js

@@ -1,22 +1,27 @@
-import { type } from 'arktype';
+import { z } from 'zod';
 import { AppIdSchema } from '../../../../app/schema.js';
 import { GrantType, OptionalSchema } from '../../../common/schema.js';
 /**
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-4.4.2
  */
-const GrantTypeSchema = type.enumerated(GrantType.CLIENT_CREDENTIALS);
+const GrantTypeSchema = z.enum([GrantType.CLIENT_CREDENTIALS]);
 /**
  * What the incoming body may look like.
  *
  * Note: the client_id and client_secrete may (likely) be in Authorization header
  */
-export const ClientCredentialsPayloadSchema = type({
+export const ClientCredentialsPayloadSchema = z.object({
     grant_type: GrantTypeSchema,
-    scope: type('string').optional(),
+    scope: z.string().optional(),
     client_id: AppIdSchema.optional(),
-    client_secret: type('string').optional(),
-}).and(OptionalSchema);
-export const ClientCredentialsSchema = ClientCredentialsPayloadSchema.omit('client_id', 'client_secret').and({
+    client_secret: z.string().optional(),
+    ...OptionalSchema.shape,
+});
+export const ClientCredentialsSchema = z.object({
+    ...ClientCredentialsPayloadSchema.omit({
+        client_id: true,
+        client_secret: true,
+    }).shape,
     client_id: AppIdSchema,
-    client_secret: type('string'),
+    client_secret: z.string(),
 });

package/dist/esm/oauth/token/schema/grants/refresh-token.d.ts

@@ -1,9 +1,12 @@
-export declare const RefreshTokenSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    grant_type: "refresh_token";
-    refresh_token: string;
-    client_id: string;
-    client_secret: string;
-    scope?: string | undefined;
-}, {}>;
-export type RefreshTokenPayload = typeof RefreshTokenSchema.inferOut;
+import { z } from 'zod';
+export declare const RefreshTokenSchema: z.ZodObject<{
+    grant_type: z.ZodEnum<{
+        refresh_token: "refresh_token";
+    }>;
+    refresh_token: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+    client_id: z.ZodString;
+    client_secret: z.ZodString;
+}, z.core.$strip>;
+export type RefreshTokenPayload = z.output<typeof RefreshTokenSchema>;
 //# sourceMappingURL=refresh-token.d.ts.map

package/dist/esm/oauth/token/schema/grants/refresh-token.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refresh-token.d.ts","sourceRoot":"","sources":["../../../../../../src/oauth/token/schema/grants/refresh-token.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,kBAAkB;;;;;;MAM7B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"refresh-token.d.ts","sourceRoot":"","sources":["../../../../../../src/oauth/token/schema/grants/refresh-token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,kBAAkB;;;;;;;;iBAM7B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/esm/oauth/token/schema/grants/refresh-token.js

@@ -1,14 +1,14 @@
-import { type } from 'arktype';
+import { z } from 'zod';
 import { AppIdSchema } from '../../../../app/schema.js';
 import { GrantType } from '../../../common/schema.js';
 /**
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-6
  */
-const GrantTypeSchema = type.enumerated(GrantType.REFRESH_TOKEN);
-export const RefreshTokenSchema = type({
+const GrantTypeSchema = z.enum([GrantType.REFRESH_TOKEN]);
+export const RefreshTokenSchema = z.object({
     grant_type: GrantTypeSchema,
-    refresh_token: type('string'),
-    scope: type('string').optional(),
+    refresh_token: z.string(),
+    scope: z.string().optional(),
     client_id: AppIdSchema,
-    client_secret: type('string'),
+    client_secret: z.string(),
 });

package/dist/esm/oauth/token/schema/schema.d.ts

@@ -1,28 +1,35 @@
+import type { z } from 'zod';
 export * from './grants/authorization-code.js';
 export * from './grants/client-credentials.js';
 export * from './grants/refresh-token.js';
 /**
  * Union(s)
  */
-export declare const Schema: import("arktype/internal/methods/object.ts").ObjectType<{
-    grant_type: "authorization_code";
-    code: string;
-    client_id: string;
-    redirect_uri: string;
-    client_secret?: string | undefined;
-    code_verifier?: string | undefined;
-} | {
-    grant_type: "client_credentials";
-    scope?: string | undefined;
-    audience?: string | undefined;
-    client_id: string;
-    client_secret: string;
-} | {
-    grant_type: "refresh_token";
-    refresh_token: string;
-    client_id: string;
-    client_secret: string;
-    scope?: string | undefined;
-}, {}>;
-export type Payload = typeof Schema.inferOut;
+export declare const Schema: z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+    code_verifier: z.ZodOptional<z.ZodString>;
+    grant_type: z.ZodEnum<{
+        authorization_code: "authorization_code";
+    }>;
+    code: z.ZodString;
+    client_id: z.ZodString;
+    client_secret: z.ZodOptional<z.ZodString>;
+    redirect_uri: z.ZodURL;
+}, z.core.$strip>, z.ZodObject<{
+    client_id: z.ZodString;
+    client_secret: z.ZodString;
+    audience: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    grant_type: z.ZodEnum<{
+        client_credentials: "client_credentials";
+    }>;
+}, z.core.$strip>]>, z.ZodObject<{
+    grant_type: z.ZodEnum<{
+        refresh_token: "refresh_token";
+    }>;
+    refresh_token: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+    client_id: z.ZodString;
+    client_secret: z.ZodString;
+}, z.core.$strip>]>;
+export type Payload = z.output<typeof Schema>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/esm/oauth/token/schema/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/oauth/token/schema/schema.ts"],"names":[],"mappings":"AAIA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAE1C;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;MAElB,CAAC;AACF,MAAM,MAAM,OAAO,GAAG,OAAO,MAAM,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/oauth/token/schema/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAM7B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAE1C;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;mBAElB,CAAC;AACF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,MAAM,CAAC,CAAC"}

package/dist/esm/oauth/token/schema/schema.test.js

@@ -1,4 +1,3 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { generateAppId } from '../../../app/utils.js';
 import { Schema } from './schema.js';
@@ -11,9 +10,12 @@ describe('OAuth Token - Schema', () => {
                 client_id: generateAppId(),
                 redirect_uri: 'https://example.com/callback',
             };
-            const result = Schema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            const result = Schema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(payload);
+            }
         });
         test('should accept authorization code with PKCE', () => {
             const payload = {
@@ -23,9 +25,12 @@ describe('OAuth Token - Schema', () => {
                 redirect_uri: 'https://example.com/callback',
                 code_verifier: 'pkce_verifier_123',
             };
-            const result = Schema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            const result = Schema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(payload);
+            }
         });
         test('should accept authorization code with client secret', () => {
             const payload = {
@@ -35,9 +40,12 @@ describe('OAuth Token - Schema', () => {
                 client_secret: 'secret_123',
                 redirect_uri: 'https://example.com/callback',
             };
-            const result = Schema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            const result = Schema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(payload);
+            }
         });
         test('should accept client credentials grant', () => {
             const payload = {
@@ -46,9 +54,12 @@ describe('OAuth Token - Schema', () => {
                 client_secret: 'secret_123',
                 scope: 'read write',
             };
-            const result = Schema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            const result = Schema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(payload);
+            }
         });
         test('should accept refresh token grant', () => {
             const payload = {
@@ -58,9 +69,12 @@ describe('OAuth Token - Schema', () => {
                 client_secret: 'secret_123',
                 scope: 'read',
             };
-            const result = Schema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            const result = Schema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(payload);
+            }
         });
         test('should reject invalid grant type', () => {
             const payload = {
@@ -69,8 +83,8 @@ describe('OAuth Token - Schema', () => {
                 client_id: generateAppId(),
                 redirect_uri: 'https://example.com/callback',
             };
-            const result = Schema(payload);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = Schema.safeParse(payload);
+            expect(result.success).toBe(false);
         });
         test('should reject authorization code without required fields', () => {
             const payload = {
@@ -78,8 +92,8 @@ describe('OAuth Token - Schema', () => {
                 client_id: generateAppId(),
                 // missing code and redirect_uri
             };
-            const result = Schema(payload);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = Schema.safeParse(payload);
+            expect(result.success).toBe(false);
         });
         test('should reject invalid redirect URI', () => {
             const payload = {
@@ -88,8 +102,8 @@ describe('OAuth Token - Schema', () => {
                 client_id: generateAppId(),
                 redirect_uri: 'not-a-valid-url',
             };
-            const result = Schema(payload);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = Schema.safeParse(payload);
+            expect(result.success).toBe(false);
         });
         test('should reject client credentials without required fields', () => {
             const payload = {
@@ -97,8 +111,8 @@ describe('OAuth Token - Schema', () => {
                 client_id: generateAppId(),
                 // missing client_secret
             };
-            const result = Schema(payload);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = Schema.safeParse(payload);
+            expect(result.success).toBe(false);
         });
         test('should reject refresh token without required fields', () => {
             const payload = {
@@ -106,15 +120,15 @@ describe('OAuth Token - Schema', () => {
                 client_id: 'app_123',
                 // missing refresh_token and client_secret
             };
-            const result = Schema(payload);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = Schema.safeParse(payload);
+            expect(result.success).toBe(false);
         });
         test('should reject completely invalid payload', () => {
             const payload = {
                 invalid: 'data',
             };
-            const result = Schema(payload);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = Schema.safeParse(payload);
+            expect(result.success).toBe(false);
         });
     });
 });

package/dist/esm/workspace/authorization/schema.d.ts

@@ -1,31 +1,48 @@
+import { z } from 'zod';
 export declare const DEFAULT_SESSION_DURATION: number;
 export declare const DEFAULT_REFRESH_TOKEN_DURATION: number;
 export declare const DEFAULT_ACCESS_TOKEN_DURATION: number;
-export declare const AuthorizationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    sessionDuration: import("arktype/internal/attributes.ts").Default<number, number>;
-    refreshTokenDuration: import("arktype/internal/attributes.ts").Default<number, number>;
-    accessTokenDuration: import("arktype/internal/attributes.ts").Default<number, number>;
-    accessTokenSignatureAlgorithm: import("arktype/internal/attributes.ts").Default<string, string>;
-    updatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
-    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
-    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 AuthorizationPayload = typeof AuthorizationPayloadSchema.inferOut;
-export declare const UpsertAuthorizationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    sessionDuration: import("arktype/internal/attributes.ts").Default<number, number>;
-    refreshTokenDuration: import("arktype/internal/attributes.ts").Default<number, number>;
-    accessTokenDuration: import("arktype/internal/attributes.ts").Default<number, number>;
-    accessTokenSignatureAlgorithm: import("arktype/internal/attributes.ts").Default<string, string>;
-    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 UpsertAuthorizationPayload = typeof UpsertAuthorizationPayloadSchema.inferOut;
+export declare const AuthorizationPayloadSchema: 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>>>;
+    updatedAt: 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>>>;
+    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>>>;
+    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>>>;
+    sessionDuration: z.ZodDefault<z.ZodNumber>;
+    refreshTokenDuration: z.ZodDefault<z.ZodNumber>;
+    accessTokenDuration: z.ZodDefault<z.ZodNumber>;
+    accessTokenSignatureAlgorithm: z.ZodDefault<z.ZodEnum<{
+        RS256: "RS256";
+        HS256: "HS256";
+        HS384: "HS384";
+        HS512: "HS512";
+        RS384: "RS384";
+        RS512: "RS512";
+        ES256: "ES256";
+        ES384: "ES384";
+        PS256: "PS256";
+        PS384: "PS384";
+        PS512: "PS512";
+    }>>;
+}, z.core.$strip>;
+export type AuthorizationPayload = z.output<typeof AuthorizationPayloadSchema>;
+export declare const UpsertAuthorizationPayloadSchema: 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>>>;
+    sessionDuration: z.ZodDefault<z.ZodNumber>;
+    refreshTokenDuration: z.ZodDefault<z.ZodNumber>;
+    accessTokenDuration: z.ZodDefault<z.ZodNumber>;
+    accessTokenSignatureAlgorithm: z.ZodDefault<z.ZodEnum<{
+        RS256: "RS256";
+        HS256: "HS256";
+        HS384: "HS384";
+        HS512: "HS512";
+        RS384: "RS384";
+        RS512: "RS512";
+        ES256: "ES256";
+        ES384: "ES384";
+        PS256: "PS256";
+        PS384: "PS384";
+        PS512: "PS512";
+    }>>;
+}, z.core.$strip>;
+export type UpsertAuthorizationPayload = z.output<typeof UpsertAuthorizationPayloadSchema>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/esm/workspace/authorization/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/workspace/authorization/schema.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,wBAAwB,QAAc,CAAC;AACpD,eAAO,MAAM,8BAA8B,QAAoB,CAAC;AAChE,eAAO,MAAM,6BAA6B,QAAc,CAAC;AASzD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;MAIF,CAAC;AACtC,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,QAAQ,CAAC;AAE9E,eAAO,MAAM,gCAAgC;;;;;;;;;;MAE5C,CAAC;AACF,MAAM,MAAM,0BAA0B,GACpC,OAAO,gCAAgC,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/workspace/authorization/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,wBAAwB,QAAc,CAAC;AACpD,eAAO,MAAM,8BAA8B,QAAoB,CAAC;AAChE,eAAO,MAAM,6BAA6B,QAAc,CAAC;AASzD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;iBAMrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE/E,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;iBAG3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAC/C,OAAO,gCAAgC,CACxC,CAAC"}