@hed-hog/core 0.0.368 → 0.0.371

package/src/oauth/oauth-callback-coordinator.service.spec.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, afterEach } from '@jest/globals';
+import { OAuthCallbackCoordinatorService } from './oauth-callback-coordinator.service';
+import {
+  OAuthCallbackAlreadyProcessedError,
+  OAuthCallbackInProgressError,
+  OAuthProviderException,
+} from './oauth.errors';
+
+const makeService = (prisma: any) => new OAuthCallbackCoordinatorService(prisma as any);
+
+const noLockPrisma = (overrides: any = {}) => ({
+  isPostgres: jest.fn().mockReturnValue(false),
+  isMysql: jest.fn().mockReturnValue(false),
+  getProvider: jest.fn().mockReturnValue('sqlite'),
+  ...overrides,
+});
+
+describe('OAuthCallbackCoordinatorService', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+  });
+
+  describe('execute (no distributed lock provider)', () => {
+    it('runs the callback and marks the key completed', async () => {
+      const service = makeService(noLockPrisma());
+      const callback = jest.fn().mockResolvedValue('ok');
+
+      await expect(service.execute('key-a', callback)).resolves.toBe('ok');
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect((service as any).isCompleted('key-a')).toBe(true);
+    });
+
+    it('rejects a second call with the same key as already processed', async () => {
+      const service = makeService(noLockPrisma());
+      await service.execute('key-b', jest.fn().mockResolvedValue(1));
+
+      await expect(
+        service.execute('key-b', jest.fn().mockResolvedValue(2)),
+      ).rejects.toThrow(OAuthCallbackAlreadyProcessedError);
+    });
+
+    it('does not mark completed when the callback throws a generic error', async () => {
+      const service = makeService(noLockPrisma());
+      await expect(
+        service.execute('key-c', jest.fn().mockRejectedValue(new Error('boom'))),
+      ).rejects.toThrow('boom');
+      expect((service as any).isCompleted('key-c')).toBe(false);
+    });
+
+    it('marks completed when the callback throws a callback_consumed provider error', async () => {
+      const service = makeService(noLockPrisma());
+      const err = new OAuthProviderException('google', 'callback_consumed', 'consumed');
+      await expect(service.execute('key-d', jest.fn().mockRejectedValue(err))).rejects.toBe(err);
+      expect((service as any).isCompleted('key-d')).toBe(true);
+    });
+  });
+
+  describe('execute (postgres advisory lock)', () => {
+    it('acquires the advisory lock and runs the callback', async () => {
+      const tx = { $queryRaw: jest.fn().mockResolvedValue([{ locked: true }]) };
+      const prisma = {
+        isPostgres: jest.fn().mockReturnValue(true),
+        isMysql: jest.fn().mockReturnValue(false),
+        getProvider: jest.fn().mockReturnValue('postgresql'),
+        $transaction: jest.fn(async (cb: any) => cb(tx)),
+      };
+      const service = makeService(prisma);
+      const callback = jest.fn().mockResolvedValue('done');
+
+      await expect(service.execute('pg-key', callback)).resolves.toBe('done');
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect((service as any).isCompleted('pg-key')).toBe(true);
+    });
+
+    it('throws InProgress and does not run the callback when the lock is held', async () => {
+      const tx = { $queryRaw: jest.fn().mockResolvedValue([{ locked: false }]) };
+      const prisma = {
+        isPostgres: jest.fn().mockReturnValue(true),
+        isMysql: jest.fn().mockReturnValue(false),
+        getProvider: jest.fn().mockReturnValue('postgresql'),
+        $transaction: jest.fn(async (cb: any) => cb(tx)),
+      };
+      const service = makeService(prisma);
+      const callback = jest.fn();
+
+      await expect(service.execute('pg-busy', callback)).rejects.toThrow(OAuthCallbackInProgressError);
+      expect(callback).not.toHaveBeenCalled();
+      expect((service as any).isCompleted('pg-busy')).toBe(false);
+    });
+  });
+
+  describe('completed-callback bookkeeping', () => {
+    it('expires completed entries after the TTL window', () => {
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
+      const service = makeService(noLockPrisma());
+
+      (service as any).markCompleted('ttl-key');
+      expect((service as any).isCompleted('ttl-key')).toBe(true);
+
+      // Advance beyond the 10 minute TTL.
+      jest.setSystemTime(new Date('2026-01-01T00:11:00.000Z'));
+      expect((service as any).isCompleted('ttl-key')).toBe(false);
+    });
+
+    it('prunes expired entries from the internal map', () => {
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
+      const service = makeService(noLockPrisma());
+      (service as any).markCompleted('old');
+
+      jest.setSystemTime(new Date('2026-01-01T00:11:00.000Z'));
+      (service as any).markCompleted('fresh');
+      (service as any).pruneCompletedCallbacks();
+
+      expect((service as any).completedCallbacks.has('old')).toBe(false);
+      expect((service as any).completedCallbacks.has('fresh')).toBe(true);
+    });
+  });
+
+  describe('shouldMarkCompleted', () => {
+    it('is true for already-processed and callback_consumed errors only', () => {
+      const service = makeService(noLockPrisma());
+      expect((service as any).shouldMarkCompleted(new OAuthCallbackAlreadyProcessedError())).toBe(true);
+      expect(
+        (service as any).shouldMarkCompleted(
+          new OAuthProviderException('g', 'callback_consumed', 'x'),
+        ),
+      ).toBe(true);
+      expect(
+        (service as any).shouldMarkCompleted(
+          new OAuthProviderException('g', 'upstream_failure', 'x'),
+        ),
+      ).toBe(false);
+      expect((service as any).shouldMarkCompleted(new Error('other'))).toBe(false);
+    });
+  });
+
+  describe('lock key derivation', () => {
+    it('derives a deterministic signed bigint within int64 bounds', () => {
+      const service = makeService(noLockPrisma());
+      const a = (service as any).toSignedBigInt('same');
+      const b = (service as any).toSignedBigInt('same');
+      expect(a).toBe(b);
+      expect(typeof a).toBe('bigint');
+      expect(a >= -(BigInt(1) << BigInt(63))).toBe(true);
+      expect(a < BigInt(1) << BigInt(63)).toBe(true);
+      expect((service as any).toSignedBigInt('other')).not.toBe(a);
+    });
+
+    it('derives a prefixed 48-char mysql lock name', () => {
+      const service = makeService(noLockPrisma());
+      const name = (service as any).toMysqlLockName('key');
+      expect(name.startsWith('oauth:')).toBe(true);
+      expect(name.slice('oauth:'.length)).toHaveLength(48);
+    });
+  });
+});

package/src/oauth/providers/facebook.provider.ts

@@ -26,11 +26,11 @@ export class FacebookProvider extends BaseOAuthProvider {
       'oauth-facebook-profile-id',
       'url',
     ]);
-    const profileId = Number(settings['oauth-facebook-profile-id']);
-    if (!profileId) throw new BadRequestException('Facebook OAuth profile not configured.');
+    const profileSlug = String(settings['oauth-facebook-profile-id'] ?? '').trim();
+    if (!profileSlug) throw new BadRequestException('Facebook OAuth profile not configured.');
 
     const profile = await this.prisma.integration_profile.findUnique({
-      where: { id: profileId },
+      where: { slug: profileSlug },
       include: { integration_provider: { select: { slug: true } } },
     });
     if (!profile) throw new BadRequestException('Facebook OAuth profile not found.');

package/src/oauth/providers/github.provider.ts

@@ -30,11 +30,11 @@ export class GithubProvider extends BaseOAuthProvider {
       'oauth-github-profile-id',
       'api-url',
     ]);
-    const profileId = Number(settings['oauth-github-profile-id']);
-    if (!profileId) throw new BadRequestException('GitHub OAuth profile not configured.');
+    const profileSlug = String(settings['oauth-github-profile-id'] ?? '').trim();
+    if (!profileSlug) throw new BadRequestException('GitHub OAuth profile not configured.');
 
     const profile = await this.prisma.integration_profile.findUnique({
-      where: { id: profileId },
+      where: { slug: profileSlug },
       include: { integration_provider: { select: { slug: true } } },
     });
     if (!profile) throw new BadRequestException('GitHub OAuth profile not found.');

package/src/oauth/providers/google.provider.ts

@@ -26,11 +26,11 @@ export class GoogleProvider extends BaseOAuthProvider {
       'oauth-google-profile-id',
       'url',
     ]);
-    const profileId = Number(settings['oauth-google-profile-id']);
-    if (!profileId) throw new BadRequestException('Google OAuth profile not configured.');
+    const profileSlug = String(settings['oauth-google-profile-id'] ?? '').trim();
+    if (!profileSlug) throw new BadRequestException('Google OAuth profile not configured.');
 
     const profile = await this.prisma.integration_profile.findUnique({
-      where: { id: profileId },
+      where: { slug: profileSlug },
       include: { integration_provider: { select: { slug: true } } },
     });
     if (!profile) throw new BadRequestException('Google OAuth profile not found.');

package/src/oauth/providers/microsoft-entra-id.provider.ts

@@ -40,11 +40,11 @@ export class MicrosoftEntraIdProvider extends BaseOAuthProvider {
       'oauth-microsoft-entra-id-profile-id',
       'url',
     ]);
-    const profileId = Number(settings['oauth-microsoft-entra-id-profile-id']);
-    if (!profileId) throw new BadRequestException('Microsoft Entra ID OAuth profile not configured.');
+    const profileSlug = String(settings['oauth-microsoft-entra-id-profile-id'] ?? '').trim();
+    if (!profileSlug) throw new BadRequestException('Microsoft Entra ID OAuth profile not configured.');
 
     const profile = await this.prisma.integration_profile.findUnique({
-      where: { id: profileId },
+      where: { slug: profileSlug },
       include: { integration_provider: { select: { slug: true } } },
     });
     if (!profile) throw new BadRequestException('Microsoft Entra ID OAuth profile not found.');

package/src/oauth/providers/microsoft.provider.ts

@@ -26,11 +26,11 @@ export class MicrosoftProvider extends BaseOAuthProvider {
       'oauth-microsoft-profile-id',
       'url',
     ]);
-    const profileId = Number(settings['oauth-microsoft-profile-id']);
-    if (!profileId) throw new BadRequestException('Microsoft OAuth profile not configured.');
+    const profileSlug = String(settings['oauth-microsoft-profile-id'] ?? '').trim();
+    if (!profileSlug) throw new BadRequestException('Microsoft OAuth profile not configured.');
 
     const profile = await this.prisma.integration_profile.findUnique({
-      where: { id: profileId },
+      where: { slug: profileSlug },
       include: { integration_provider: { select: { slug: true } } },
     });
     if (!profile) throw new BadRequestException('Microsoft OAuth profile not found.');

package/src/pdf/pdf.service.ts

@@ -15,6 +15,10 @@ export interface PdfGenerateOptions {
   margin?: { top?: string; right?: string; bottom?: string; left?: string };
   printBackground?: boolean;
   landscape?: boolean;
+  /** Explicit CSS page size (e.g. '1600px'). Takes precedence over `format`/`landscape` when set. */
+  width?: string;
+  /** Explicit CSS page size (e.g. '1131px'). Takes precedence over `format`/`landscape` when set. */
+  height?: string;
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -161,12 +165,21 @@ export class PdfService {
       await page.setViewportSize({ width: 794, height: 1123 });
       await page.setContent(html, { waitUntil: 'networkidle' });
 
-      const pdfBuffer = await page.pdf({
-        format: options.format ?? 'A4',
-        printBackground: options.printBackground ?? true,
-        landscape: options.landscape ?? false,
-        margin: options.margin ?? { top: '0', right: '0', bottom: '0', left: '0' },
-      });
+      const pdfBuffer = await page.pdf(
+        options.width && options.height
+          ? {
+              width: options.width,
+              height: options.height,
+              printBackground: options.printBackground ?? true,
+              margin: options.margin ?? { top: '0', right: '0', bottom: '0', left: '0' },
+            }
+          : {
+              format: options.format ?? 'A4',
+              printBackground: options.printBackground ?? true,
+              landscape: options.landscape ?? false,
+              margin: options.margin ?? { top: '0', right: '0', bottom: '0', left: '0' },
+            },
+      );
 
       return Buffer.from(pdfBuffer);
     } catch (error) {

package/src/profile/profile.controller.ts

@@ -44,9 +44,10 @@ export class ProfileController {
   async verifyBeforeAddMfa(
     @User() { id },
     @Body() data: VerifyBeforeAddMfaDto,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @Headers('origin') origin: string
   ) {
-    return this.profileService.verifyBeforeAddMfa(locale, id, data);
+    return this.profileService.verifyBeforeAddMfa(locale, id, data, origin);
   }
 
   @Post('totp/generate')
@@ -130,9 +131,10 @@ export class ProfileController {
     @User() { id },
     @Param('mfaId', ParseIntPipe) mfaId: number,
     @Body() data: RemoveMfaDto,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @Headers('origin') origin: string
   ) {
-    return this.profileService.removeMfa(locale, id, mfaId, data);
+    return this.profileService.removeMfa(locale, id, mfaId, data, origin);
   }
 
   @Post('recovery-codes/send-verification')
@@ -147,43 +149,48 @@ export class ProfileController {
   async regenerateRecoveryCodes(
     @User() { id },
     @Body() data: RegenerateRecoveryCodesDto,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @Headers('origin') origin: string
   ) {
-    return this.profileService.regenerateRecoveryCodes(locale, id, data);
+    return this.profileService.regenerateRecoveryCodes(locale, id, data, origin);
   }
 
   @Post('webauthn/generate')
   async generateWebAuthnRegistrationOptions(
     @User() { id },
     @Body() { name }: GenerateWebAuthnRegistrationOptionsDto,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @Headers('origin') origin: string
   ) {
-    return this.profileService.generateWebAuthnRegistrationOptions(locale, id, name);
+    return this.profileService.generateWebAuthnRegistrationOptions(locale, id, name, origin);
   }
 
   @Post('webauthn/verify')
   async verifyWebAuthnRegistration(
     @User() { id },
     @Body() { name, attestationResponse }: VerifyWebAuthnRegistrationDto,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @Headers('origin') origin: string
   ) {
-    return this.profileService.verifyWebAuthnRegistration(locale, id, name, attestationResponse);
+    return this.profileService.verifyWebAuthnRegistration(locale, id, name, attestationResponse, origin);
   }
 
   @Post('webauthn/authenticate/generate')
   async generateWebAuthnAuthenticationOptions(
     @User() { id },
-    @Locale() locale: string
+    @Locale() locale: string,
+    @Headers('origin') origin: string
   ) {
-    return this.profileService.generateWebAuthnAuthenticationOptions(locale, id);
+    return this.profileService.generateWebAuthnAuthenticationOptions(locale, id, origin);
   }
 
   @Post('webauthn/authenticate/verify')
   async verifyWebAuthnAuthentication(
     @User() { id },
-    @Body() { assertionResponse }: VerifyWebAuthnDto
+    @Body() { assertionResponse }: VerifyWebAuthnDto,
+    @Headers('origin') origin: string
   ) {
-    return this.profileService.verifyWebAuthnAuthentication(id, assertionResponse);
+    return this.profileService.verifyWebAuthnAuthentication(id, assertionResponse, origin);
   }
 
   @Delete('webauthn/:mfaId/remove')

package/src/profile/profile.service.ts

@@ -22,6 +22,7 @@ import { SecurityService } from '../security/security.service';
 import { SettingService } from '../setting/setting.service';
 import { TokenService } from '../token/token.service';
 import { UserService } from '../user/user.service';
+import { resolveWebAuthnOrigin } from '../utils/webauthn-origin';
 import { ChangeEmailDto } from './dto/change-email.dto';
 import { ChangePasswordDto } from './dto/change-password.dto';
 import { EmailVerificationDto } from './dto/email-verification-confirm.dto';
@@ -294,6 +295,8 @@ export class ProfileService {
       this.eventEmitter.emit(PROFILE_EMAIL_CHANGED, new ProfileEmailChangedEvent(userId, confirmedIdentifier.value));
     }
 
+    await this.user.registerUserActivity(userId, 'changeEmail');
+
     return { success: true };
   }
 
@@ -349,6 +352,7 @@ export class ProfileService {
     });
     if (name) {
       this.eventEmitter.emit(PROFILE_UPDATED, new ProfileUpdatedEvent(userid, name));
+      await this.user.registerUserActivity(userid, 'updateProfile');
     }
     return result;
   }
@@ -356,6 +360,7 @@ export class ProfileService {
   async updateAvatar(locale: string, userId: number, file: MulterFile) {
     const result = await this.user.changeAvatar(locale, userId, file);
     this.eventEmitter.emit(PROFILE_AVATAR_UPDATED, new ProfileAvatarUpdatedEvent(userId, result?.id ?? null));
+    await this.user.registerUserActivity(userId, 'avatar_changed');
     return result;
   }
 
@@ -405,6 +410,8 @@ export class ProfileService {
       });
     }
 
+    await this.user.registerUserActivity(userId, 'changePassword');
+
     return { success: true };
   }
 
@@ -656,7 +663,7 @@ export class ProfileService {
     }
   }
 
-  async removeMfa(locale: string, userId: number, mfaId: number, data: { token?: string; hash?: string; verificationType?: 'totp' | 'email' | 'recovery' | 'webauthn'; assertionResponse?: any }) {
+  async removeMfa(locale: string, userId: number, mfaId: number, data: { token?: string; hash?: string; verificationType?: 'totp' | 'email' | 'recovery' | 'webauthn'; assertionResponse?: any }, requestOrigin?: string) {
     try {
       const user = await this.prisma.user.findUnique({
         where: { id: userId },
@@ -700,7 +707,7 @@ export class ProfileService {
         }
 
         try {
-          await this.verifyWebAuthnAuthentication(userId, data.assertionResponse);
+          await this.verifyWebAuthnAuthentication(userId, data.assertionResponse, requestOrigin);
         } catch (error) {
           throw new BadRequestException(
             getLocaleText('invalidWebAuthn', locale, 'WebAuthn verification failed.')
@@ -899,7 +906,8 @@ export class ProfileService {
   async verifyBeforeAddMfa(
     locale: string,
     userId: number,
-    data: { verificationCode?: string; hash?: string; verificationType: 'totp' | 'email' | 'recovery' | 'webauthn'; assertionResponse?: any }
+    data: { verificationCode?: string; hash?: string; verificationType: 'totp' | 'email' | 'recovery' | 'webauthn'; assertionResponse?: any },
+    requestOrigin?: string
   ) {
     try {
       const user = await this.prisma.user.findUnique({
@@ -935,7 +943,7 @@ export class ProfileService {
         }
 
         try {
-          await this.verifyWebAuthnAuthentication(userId, data.assertionResponse);
+          await this.verifyWebAuthnAuthentication(userId, data.assertionResponse, requestOrigin);
         } catch (error) {
           throw new BadRequestException(
             getLocaleText('invalidWebAuthn', locale, 'WebAuthn verification failed.')
@@ -1087,7 +1095,7 @@ export class ProfileService {
     }
   }
 
-  async regenerateRecoveryCodes(locale: string, userId: number, data: { verificationCode?: string; hash?: string; verificationType?: 'totp' | 'email' | 'recovery' | 'webauthn'; assertionResponse?: any }) {
+  async regenerateRecoveryCodes(locale: string, userId: number, data: { verificationCode?: string; hash?: string; verificationType?: 'totp' | 'email' | 'recovery' | 'webauthn'; assertionResponse?: any }, requestOrigin?: string) {
     try {
       const user = await this.prisma.user.findUnique({
         where: { id: userId },
@@ -1125,7 +1133,7 @@ export class ProfileService {
           }
 
           try {
-            await this.verifyWebAuthnAuthentication(userId, data.assertionResponse);
+            await this.verifyWebAuthnAuthentication(userId, data.assertionResponse, requestOrigin);
           } catch (error) {
             throw new BadRequestException(
               getLocaleText('invalidWebAuthn', locale, 'WebAuthn verification failed.')
@@ -1213,7 +1221,7 @@ export class ProfileService {
     }
   }
 
-  async generateWebAuthnRegistrationOptions(locale: string, userId: number, name: string) {
+  async generateWebAuthnRegistrationOptions(locale: string, userId: number, name: string, requestOrigin?: string) {
     try {
       const user = await this.prisma.user.findFirst({
         where: { id: userId },
@@ -1244,8 +1252,7 @@ export class ProfileService {
       ]);
 
       const rpName = settings['system-name'] || 'HedHog';
-      const primaryOrigin = (process.env.CORS_ALLOWED_ORIGINS ?? '').split(/[\n,;]+/).map(u => u.trim()).filter(Boolean)[0] ?? 'http://localhost:3200';
-      const rpID = new URL(primaryOrigin).hostname;
+      const { rpID } = resolveWebAuthnOrigin(requestOrigin);
       const userEmail = user.user_identifier.find(ui => ui.type === 'email')?.value || `user${userId}@example.com`;
       const existingAuthenticators = user.user_mfa
         .filter(mfa => mfa.user_mfa_webauthn && mfa.user_mfa_webauthn.length > 0)
@@ -1295,7 +1302,8 @@ export class ProfileService {
     locale: string,
     userId: number,
     name: string,
-    attestationResponse: any
+    attestationResponse: any,
+    requestOrigin?: string
   ) {
     try {
       const challengeRecord = await this.prisma.user_mfa_challenge.findFirst({
@@ -1317,9 +1325,7 @@ export class ProfileService {
         );
       }
 
-      const primaryOrigin = (process.env.CORS_ALLOWED_ORIGINS ?? '').split(/[\n,;]+/).map(u => u.trim()).filter(Boolean)[0] ?? 'http://localhost:3200';
-      const rpID = new URL(primaryOrigin).hostname;
-      const expectedOrigin = primaryOrigin;
+      const { rpID, expectedOrigin } = resolveWebAuthnOrigin(requestOrigin);
       const verification: VerifiedRegistrationResponse = await verifyRegistrationResponse({
         response: attestationResponse,
         expectedChallenge: challengeRecord.hash,
@@ -1361,7 +1367,7 @@ export class ProfileService {
     }
   }
 
-  async generateWebAuthnAuthenticationOptions(locale: string, userId: number) {
+  async generateWebAuthnAuthenticationOptions(locale: string, userId: number, requestOrigin?: string) {
     try {
       const user = await this.prisma.user.findFirst({
         where: { id: userId },
@@ -1379,8 +1385,7 @@ export class ProfileService {
         );
       }
 
-      const primaryOrigin = (process.env.CORS_ALLOWED_ORIGINS ?? '').split(/[\n,;]+/).map(u => u.trim()).filter(Boolean)[0] ?? 'http://localhost:3200';
-      const rpID = new URL(primaryOrigin).hostname;
+      const { rpID } = resolveWebAuthnOrigin(requestOrigin);
       const allowCredentials = user.user_mfa
         .filter(mfa => mfa.user_mfa_webauthn && mfa.user_mfa_webauthn.length > 0)
         .map(mfa => ({
@@ -1408,7 +1413,7 @@ export class ProfileService {
     }
   }
 
-  async verifyWebAuthnAuthentication(userId: number, assertionResponse: any) {
+  async verifyWebAuthnAuthentication(userId: number, assertionResponse: any, requestOrigin?: string) {
     try {
       const challengeRecord = await this.prisma.user_mfa_challenge.findFirst({
         where: {
@@ -1433,9 +1438,7 @@ export class ProfileService {
       }
 
       const authenticator = challengeRecord.user_mfa.user_mfa_webauthn[0];
-      const primaryOrigin = (process.env.CORS_ALLOWED_ORIGINS ?? '').split(/[\n,;]+/).map(u => u.trim()).filter(Boolean)[0] ?? 'http://localhost:3200';
-      const rpID = new URL(primaryOrigin).hostname;
-      const expectedOrigin = primaryOrigin;
+      const { rpID, expectedOrigin } = resolveWebAuthnOrigin(requestOrigin);
       const verification: VerifiedAuthenticationResponse = await verifyAuthenticationResponse({
         response: assertionResponse,
         expectedChallenge: challengeRecord.hash,

package/src/route/dto/create.dto.ts

@@ -1,32 +1,32 @@
-import { getLocaleText } from '@hed-hog/api-locale';
-import { IsIn, IsOptional, IsString } from 'class-validator';
-import { HttpMethod } from '../../types/http-method';
-
-export type RouteType = 'HTTP' | 'MCP';
-
-const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
-
-export class CreateDTO {
-  @IsOptional()
-  @IsString({ message: (args) => getLocaleText('validation.urlMustBeString', args.value) })
-  url?: string;
-
-  @IsOptional()
-  @IsString({ message: (args) => getLocaleText('validation.methodMustBeString', args.value) })
-  @IsIn(HTTP_METHODS, {
-    message: (args) => getLocaleText('validation.methodMustBeValid', args.value),
-  })
-  method?: HttpMethod;
-
-  @IsOptional()
-  @IsIn(['HTTP', 'MCP'])
-  type?: RouteType;
-
-  @IsOptional()
-  @IsString()
-  tool_name?: string;
-
-  @IsOptional()
-  @IsString()
-  name?: string;
-}
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsIn, IsOptional, IsString } from 'class-validator';
+import { HttpMethod } from '../../types/http-method';
+
+export type RouteType = 'HTTP' | 'MCP';
+
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
+
+export class CreateDTO {
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.urlMustBeString', args.value) })
+  url?: string;
+
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.methodMustBeString', args.value) })
+  @IsIn(HTTP_METHODS, {
+    message: (args) => getLocaleText('validation.methodMustBeValid', args.value),
+  })
+  method?: HttpMethod;
+
+  @IsOptional()
+  @IsIn(['HTTP', 'MCP'])
+  type?: RouteType;
+
+  @IsOptional()
+  @IsString()
+  tool_name?: string;
+
+  @IsOptional()
+  @IsString()
+  name?: string;
+}

package/src/route/dto/update.dto.ts

@@ -1,31 +1,31 @@
-import { getLocaleText } from '@hed-hog/api-locale';
-import { IsIn, IsOptional, IsString } from 'class-validator';
-import { HttpMethod } from '../../types/http-method';
-import { RouteType } from './create.dto';
-
-const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
-
-export class UpdateDTO {
-  @IsOptional()
-  @IsString({ message: (args) => getLocaleText('validation.urlMustBeString', args.value) })
-  url?: string;
-
-  @IsOptional()
-  @IsString({ message: (args) => getLocaleText('validation.methodMustBeString', args.value) })
-  @IsIn(HTTP_METHODS, {
-    message: (args) => getLocaleText('validation.methodMustBeValid', args.value),
-  })
-  method?: HttpMethod;
-
-  @IsOptional()
-  @IsIn(['HTTP', 'MCP'])
-  type?: RouteType;
-
-  @IsOptional()
-  @IsString()
-  tool_name?: string;
-
-  @IsOptional()
-  @IsString()
-  name?: string;
-}
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsIn, IsOptional, IsString } from 'class-validator';
+import { HttpMethod } from '../../types/http-method';
+import { RouteType } from './create.dto';
+
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
+
+export class UpdateDTO {
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.urlMustBeString', args.value) })
+  url?: string;
+
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.methodMustBeString', args.value) })
+  @IsIn(HTTP_METHODS, {
+    message: (args) => getLocaleText('validation.methodMustBeValid', args.value),
+  })
+  method?: HttpMethod;
+
+  @IsOptional()
+  @IsIn(['HTTP', 'MCP'])
+  type?: RouteType;
+
+  @IsOptional()
+  @IsString()
+  tool_name?: string;
+
+  @IsOptional()
+  @IsString()
+  name?: string;
+}