refactor: enum casing (#19946)

server/src/controllers/activity.controller.ts

@@ -20,13 +20,13 @@ export class ActivityController {
   constructor(private service: ActivityService) {}
 
   @Get()
-  @Authenticated({ permission: Permission.ACTIVITY_READ })
+  @Authenticated({ permission: Permission.ActivityRead })
   getActivities(@Auth() auth: AuthDto, @Query() dto: ActivitySearchDto): Promise<ActivityResponseDto[]> {
     return this.service.getAll(auth, dto);
   }
 
   @Post()
-  @Authenticated({ permission: Permission.ACTIVITY_CREATE })
+  @Authenticated({ permission: Permission.ActivityCreate })
   async createActivity(
     @Auth() auth: AuthDto,
     @Body() dto: ActivityCreateDto,
@@ -40,14 +40,14 @@ export class ActivityController {
   }
 
   @Get('statistics')
-  @Authenticated({ permission: Permission.ACTIVITY_STATISTICS })
+  @Authenticated({ permission: Permission.ActivityStatistics })
   getActivityStatistics(@Auth() auth: AuthDto, @Query() dto: ActivityDto): Promise<ActivityStatisticsResponseDto> {
     return this.service.getStatistics(auth, dto);
   }
 
   @Delete(':id')
   @HttpCode(HttpStatus.NO_CONTENT)
-  @Authenticated({ permission: Permission.ACTIVITY_DELETE })
+  @Authenticated({ permission: Permission.ActivityDelete })
   deleteActivity(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.delete(auth, id);
   }

server/src/controllers/album.controller.ts

@@ -23,24 +23,24 @@ export class AlbumController {
   constructor(private service: AlbumService) {}
 
   @Get()
-  @Authenticated({ permission: Permission.ALBUM_READ })
+  @Authenticated({ permission: Permission.AlbumRead })
   getAllAlbums(@Auth() auth: AuthDto, @Query() query: GetAlbumsDto): Promise<AlbumResponseDto[]> {
     return this.service.getAll(auth, query);
   }
 
   @Post()
-  @Authenticated({ permission: Permission.ALBUM_CREATE })
+  @Authenticated({ permission: Permission.AlbumCreate })
   createAlbum(@Auth() auth: AuthDto, @Body() dto: CreateAlbumDto): Promise<AlbumResponseDto> {
     return this.service.create(auth, dto);
   }
 
   @Get('statistics')
-  @Authenticated({ permission: Permission.ALBUM_STATISTICS })
+  @Authenticated({ permission: Permission.AlbumStatistics })
   getAlbumStatistics(@Auth() auth: AuthDto): Promise<AlbumStatisticsResponseDto> {
     return this.service.getStatistics(auth);
   }
 
-  @Authenticated({ permission: Permission.ALBUM_READ, sharedLink: true })
+  @Authenticated({ permission: Permission.AlbumRead, sharedLink: true })
   @Get(':id')
   getAlbumInfo(
     @Auth() auth: AuthDto,
@@ -51,7 +51,7 @@ export class AlbumController {
   }
 
   @Patch(':id')
-  @Authenticated({ permission: Permission.ALBUM_UPDATE })
+  @Authenticated({ permission: Permission.AlbumUpdate })
   updateAlbumInfo(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -61,7 +61,7 @@ export class AlbumController {
   }
 
   @Delete(':id')
-  @Authenticated({ permission: Permission.ALBUM_DELETE })
+  @Authenticated({ permission: Permission.AlbumDelete })
   deleteAlbum(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto) {
     return this.service.delete(auth, id);
   }

server/src/controllers/api-key.controller.spec.ts

@@ -55,7 +55,7 @@ describe(APIKeyController.name, () => {
     it('should require a valid uuid', async () => {
       const { status, body } = await request(ctx.getHttpServer())
         .put(`/api-keys/123`)
-        .send({ name: 'new name', permissions: [Permission.ALL] });
+        .send({ name: 'new name', permissions: [Permission.All] });
       expect(status).toBe(400);
       expect(body).toEqual(factory.responses.badRequest(['id must be a UUID']));
     });

server/src/controllers/api-key.controller.ts

@@ -13,25 +13,25 @@ export class APIKeyController {
   constructor(private service: ApiKeyService) {}
 
   @Post()
-  @Authenticated({ permission: Permission.API_KEY_CREATE })
+  @Authenticated({ permission: Permission.ApiKeyCreate })
   createApiKey(@Auth() auth: AuthDto, @Body() dto: APIKeyCreateDto): Promise<APIKeyCreateResponseDto> {
     return this.service.create(auth, dto);
   }
 
   @Get()
-  @Authenticated({ permission: Permission.API_KEY_READ })
+  @Authenticated({ permission: Permission.ApiKeyRead })
   getApiKeys(@Auth() auth: AuthDto): Promise<APIKeyResponseDto[]> {
     return this.service.getAll(auth);
   }
 
   @Get(':id')
-  @Authenticated({ permission: Permission.API_KEY_READ })
+  @Authenticated({ permission: Permission.ApiKeyRead })
   getApiKey(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<APIKeyResponseDto> {
     return this.service.getById(auth, id);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.API_KEY_UPDATE })
+  @Authenticated({ permission: Permission.ApiKeyUpdate })
   updateApiKey(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -42,7 +42,7 @@ export class APIKeyController {
 
   @Delete(':id')
   @HttpCode(HttpStatus.NO_CONTENT)
-  @Authenticated({ permission: Permission.API_KEY_DELETE })
+  @Authenticated({ permission: Permission.ApiKeyDelete })
   deleteApiKey(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.delete(auth, id);
   }

server/src/controllers/asset-media.controller.ts

@@ -45,7 +45,7 @@ import { ImmichFileResponse, sendFile } from 'src/utils/file';
 import { FileNotEmptyValidator, UUIDParamDto } from 'src/validation';
 
 @ApiTags('Assets')
-@Controller(RouteKey.ASSET)
+@Controller(RouteKey.Asset)
 export class AssetMediaController {
   constructor(
     private logger: LoggingRepository,
@@ -56,7 +56,7 @@ export class AssetMediaController {
   @UseInterceptors(AssetUploadInterceptor, FileUploadInterceptor)
   @ApiConsumes('multipart/form-data')
   @ApiHeader({
-    name: ImmichHeader.CHECKSUM,
+    name: ImmichHeader.Checksum,
     description: 'sha1 checksum that can be used for duplicate detection before the file is uploaded',
     required: false,
   })

server/src/controllers/asset.controller.ts

@@ -19,7 +19,7 @@ import { AssetService } from 'src/services/asset.service';
 import { UUIDParamDto } from 'src/validation';
 
 @ApiTags('Assets')
-@Controller(RouteKey.ASSET)
+@Controller(RouteKey.Asset)
 export class AssetController {
   constructor(private service: AssetService) {}
 

server/src/controllers/auth.controller.ts

@@ -36,9 +36,9 @@ export class AuthController {
     return respondWithCookie(res, body, {
       isSecure: loginDetails.isSecure,
       values: [
-        { key: ImmichCookie.ACCESS_TOKEN, value: body.accessToken },
-        { key: ImmichCookie.AUTH_TYPE, value: AuthType.PASSWORD },
-        { key: ImmichCookie.IS_AUTHENTICATED, value: 'true' },
+        { key: ImmichCookie.AccessToken, value: body.accessToken },
+        { key: ImmichCookie.AuthType, value: AuthType.Password },
+        { key: ImmichCookie.IsAuthenticated, value: 'true' },
       ],
     });
   }
@@ -70,13 +70,13 @@ export class AuthController {
     @Res({ passthrough: true }) res: Response,
     @Auth() auth: AuthDto,
   ): Promise<LogoutResponseDto> {
-    const authType = (request.cookies || {})[ImmichCookie.AUTH_TYPE];
+    const authType = (request.cookies || {})[ImmichCookie.AuthType];
 
     const body = await this.service.logout(auth, authType);
     return respondWithoutCookie(res, body, [
-      ImmichCookie.ACCESS_TOKEN,
-      ImmichCookie.AUTH_TYPE,
-      ImmichCookie.IS_AUTHENTICATED,
+      ImmichCookie.AccessToken,
+      ImmichCookie.AuthType,
+      ImmichCookie.IsAuthenticated,
     ]);
   }
 

server/src/controllers/face.controller.ts

@@ -19,19 +19,19 @@ export class FaceController {
   constructor(private service: PersonService) {}
 
   @Post()
-  @Authenticated({ permission: Permission.FACE_CREATE })
+  @Authenticated({ permission: Permission.FaceCreate })
   createFace(@Auth() auth: AuthDto, @Body() dto: AssetFaceCreateDto) {
     return this.service.createFace(auth, dto);
   }
 
   @Get()
-  @Authenticated({ permission: Permission.FACE_READ })
+  @Authenticated({ permission: Permission.FaceRead })
   getFaces(@Auth() auth: AuthDto, @Query() dto: FaceDto): Promise<AssetFaceResponseDto[]> {
     return this.service.getFacesById(auth, dto);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.FACE_UPDATE })
+  @Authenticated({ permission: Permission.FaceUpdate })
   reassignFacesById(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -41,7 +41,7 @@ export class FaceController {
   }
 
   @Delete(':id')
-  @Authenticated({ permission: Permission.FACE_DELETE })
+  @Authenticated({ permission: Permission.FaceDelete })
   deleteFace(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto, @Body() dto: AssetFaceDeleteDto) {
     return this.service.deleteFace(auth, id, dto);
   }

server/src/controllers/library.controller.ts

@@ -19,32 +19,32 @@ export class LibraryController {
   constructor(private service: LibraryService) {}
 
   @Get()
-  @Authenticated({ permission: Permission.LIBRARY_READ, admin: true })
+  @Authenticated({ permission: Permission.LibraryRead, admin: true })
   getAllLibraries(): Promise<LibraryResponseDto[]> {
     return this.service.getAll();
   }
 
   @Post()
-  @Authenticated({ permission: Permission.LIBRARY_CREATE, admin: true })
+  @Authenticated({ permission: Permission.LibraryCreate, admin: true })
   createLibrary(@Body() dto: CreateLibraryDto): Promise<LibraryResponseDto> {
     return this.service.create(dto);
   }
 
   @Get(':id')
-  @Authenticated({ permission: Permission.LIBRARY_READ, admin: true })
+  @Authenticated({ permission: Permission.LibraryRead, admin: true })
   getLibrary(@Param() { id }: UUIDParamDto): Promise<LibraryResponseDto> {
     return this.service.get(id);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.LIBRARY_UPDATE, admin: true })
+  @Authenticated({ permission: Permission.LibraryUpdate, admin: true })
   updateLibrary(@Param() { id }: UUIDParamDto, @Body() dto: UpdateLibraryDto): Promise<LibraryResponseDto> {
     return this.service.update(id, dto);
   }
 
   @Delete(':id')
   @HttpCode(HttpStatus.NO_CONTENT)
-  @Authenticated({ permission: Permission.LIBRARY_DELETE, admin: true })
+  @Authenticated({ permission: Permission.LibraryDelete, admin: true })
   deleteLibrary(@Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.delete(id);
   }
@@ -58,14 +58,14 @@ export class LibraryController {
   }
 
   @Get(':id/statistics')
-  @Authenticated({ permission: Permission.LIBRARY_STATISTICS, admin: true })
+  @Authenticated({ permission: Permission.LibraryStatistics, admin: true })
   getLibraryStatistics(@Param() { id }: UUIDParamDto): Promise<LibraryStatsResponseDto> {
     return this.service.getStatistics(id);
   }
 
   @Post(':id/scan')
   @HttpCode(HttpStatus.NO_CONTENT)
-  @Authenticated({ permission: Permission.LIBRARY_UPDATE, admin: true })
+  @Authenticated({ permission: Permission.LibraryUpdate, admin: true })
   scanLibrary(@Param() { id }: UUIDParamDto) {
     return this.service.queueScan(id);
   }

server/src/controllers/memory.controller.ts

@@ -20,31 +20,31 @@ export class MemoryController {
   constructor(private service: MemoryService) {}
 
   @Get()
-  @Authenticated({ permission: Permission.MEMORY_READ })
+  @Authenticated({ permission: Permission.MemoryRead })
   searchMemories(@Auth() auth: AuthDto, @Query() dto: MemorySearchDto): Promise<MemoryResponseDto[]> {
     return this.service.search(auth, dto);
   }
 
   @Post()
-  @Authenticated({ permission: Permission.MEMORY_CREATE })
+  @Authenticated({ permission: Permission.MemoryCreate })
   createMemory(@Auth() auth: AuthDto, @Body() dto: MemoryCreateDto): Promise<MemoryResponseDto> {
     return this.service.create(auth, dto);
   }
 
   @Get('statistics')
-  @Authenticated({ permission: Permission.MEMORY_READ })
+  @Authenticated({ permission: Permission.MemoryRead })
   memoriesStatistics(@Auth() auth: AuthDto, @Query() dto: MemorySearchDto): Promise<MemoryStatisticsResponseDto> {
     return this.service.statistics(auth, dto);
   }
 
   @Get(':id')
-  @Authenticated({ permission: Permission.MEMORY_READ })
+  @Authenticated({ permission: Permission.MemoryRead })
   getMemory(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<MemoryResponseDto> {
     return this.service.get(auth, id);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.MEMORY_UPDATE })
+  @Authenticated({ permission: Permission.MemoryUpdate })
   updateMemory(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -55,7 +55,7 @@ export class MemoryController {
 
   @Delete(':id')
   @HttpCode(HttpStatus.NO_CONTENT)
-  @Authenticated({ permission: Permission.MEMORY_DELETE })
+  @Authenticated({ permission: Permission.MemoryDelete })
   deleteMemory(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.remove(auth, id);
   }

server/src/controllers/notification.controller.ts

@@ -19,31 +19,31 @@ export class NotificationController {
   constructor(private service: NotificationService) {}
 
   @Get()
-  @Authenticated({ permission: Permission.NOTIFICATION_READ })
+  @Authenticated({ permission: Permission.NotificationRead })
   getNotifications(@Auth() auth: AuthDto, @Query() dto: NotificationSearchDto): Promise<NotificationDto[]> {
     return this.service.search(auth, dto);
   }
 
   @Put()
-  @Authenticated({ permission: Permission.NOTIFICATION_UPDATE })
+  @Authenticated({ permission: Permission.NotificationUpdate })
   updateNotifications(@Auth() auth: AuthDto, @Body() dto: NotificationUpdateAllDto): Promise<void> {
     return this.service.updateAll(auth, dto);
   }
 
   @Delete()
-  @Authenticated({ permission: Permission.NOTIFICATION_DELETE })
+  @Authenticated({ permission: Permission.NotificationDelete })
   deleteNotifications(@Auth() auth: AuthDto, @Body() dto: NotificationDeleteAllDto): Promise<void> {
     return this.service.deleteAll(auth, dto);
   }
 
   @Get(':id')
-  @Authenticated({ permission: Permission.NOTIFICATION_READ })
+  @Authenticated({ permission: Permission.NotificationRead })
   getNotification(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<NotificationDto> {
     return this.service.get(auth, id);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.NOTIFICATION_UPDATE })
+  @Authenticated({ permission: Permission.NotificationUpdate })
   updateNotification(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -53,7 +53,7 @@ export class NotificationController {
   }
 
   @Delete(':id')
-  @Authenticated({ permission: Permission.NOTIFICATION_DELETE })
+  @Authenticated({ permission: Permission.NotificationDelete })
   deleteNotification(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.delete(auth, id);
   }

server/src/controllers/oauth.controller.ts

@@ -41,8 +41,8 @@ export class OAuthController {
       {
         isSecure: loginDetails.isSecure,
         values: [
-          { key: ImmichCookie.OAUTH_STATE, value: state },
-          { key: ImmichCookie.OAUTH_CODE_VERIFIER, value: codeVerifier },
+          { key: ImmichCookie.OAuthState, value: state },
+          { key: ImmichCookie.OAuthCodeVerifier, value: codeVerifier },
         ],
       },
     );
@@ -56,14 +56,14 @@ export class OAuthController {
     @GetLoginDetails() loginDetails: LoginDetails,
   ): Promise<LoginResponseDto> {
     const body = await this.service.callback(dto, request.headers, loginDetails);
-    res.clearCookie(ImmichCookie.OAUTH_STATE);
-    res.clearCookie(ImmichCookie.OAUTH_CODE_VERIFIER);
+    res.clearCookie(ImmichCookie.OAuthState);
+    res.clearCookie(ImmichCookie.OAuthCodeVerifier);
     return respondWithCookie(res, body, {
       isSecure: loginDetails.isSecure,
       values: [
-        { key: ImmichCookie.ACCESS_TOKEN, value: body.accessToken },
-        { key: ImmichCookie.AUTH_TYPE, value: AuthType.OAUTH },
-        { key: ImmichCookie.IS_AUTHENTICATED, value: 'true' },
+        { key: ImmichCookie.AccessToken, value: body.accessToken },
+        { key: ImmichCookie.AuthType, value: AuthType.OAuth },
+        { key: ImmichCookie.IsAuthenticated, value: 'true' },
       ],
     });
   }

server/src/controllers/partner.controller.ts

@@ -13,19 +13,19 @@ export class PartnerController {
   constructor(private service: PartnerService) {}
 
   @Get()
-  @Authenticated({ permission: Permission.PARTNER_READ })
+  @Authenticated({ permission: Permission.PartnerRead })
   getPartners(@Auth() auth: AuthDto, @Query() dto: PartnerSearchDto): Promise<PartnerResponseDto[]> {
     return this.service.search(auth, dto);
   }
 
   @Post(':id')
-  @Authenticated({ permission: Permission.PARTNER_CREATE })
+  @Authenticated({ permission: Permission.PartnerCreate })
   createPartner(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<PartnerResponseDto> {
     return this.service.create(auth, id);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.PARTNER_UPDATE })
+  @Authenticated({ permission: Permission.PartnerUpdate })
   updatePartner(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -35,7 +35,7 @@ export class PartnerController {
   }
 
   @Delete(':id')
-  @Authenticated({ permission: Permission.PARTNER_DELETE })
+  @Authenticated({ permission: Permission.PartnerDelete })
   removePartner(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.remove(auth, id);
   }

server/src/controllers/person.controller.ts

@@ -45,38 +45,38 @@ export class PersonController {
   }
 
   @Get()
-  @Authenticated({ permission: Permission.PERSON_READ })
+  @Authenticated({ permission: Permission.PersonRead })
   getAllPeople(@Auth() auth: AuthDto, @Query() options: PersonSearchDto): Promise<PeopleResponseDto> {
     return this.service.getAll(auth, options);
   }
 
   @Post()
-  @Authenticated({ permission: Permission.PERSON_CREATE })
+  @Authenticated({ permission: Permission.PersonCreate })
   createPerson(@Auth() auth: AuthDto, @Body() dto: PersonCreateDto): Promise<PersonResponseDto> {
     return this.service.create(auth, dto);
   }
 
   @Put()
-  @Authenticated({ permission: Permission.PERSON_UPDATE })
+  @Authenticated({ permission: Permission.PersonUpdate })
   updatePeople(@Auth() auth: AuthDto, @Body() dto: PeopleUpdateDto): Promise<BulkIdResponseDto[]> {
     return this.service.updateAll(auth, dto);
   }
 
   @Delete()
   @HttpCode(HttpStatus.NO_CONTENT)
-  @Authenticated({ permission: Permission.PERSON_DELETE })
+  @Authenticated({ permission: Permission.PersonDelete })
   deletePeople(@Auth() auth: AuthDto, @Body() dto: BulkIdsDto): Promise<void> {
     return this.service.deleteAll(auth, dto);
   }
 
   @Get(':id')
-  @Authenticated({ permission: Permission.PERSON_READ })
+  @Authenticated({ permission: Permission.PersonRead })
   getPerson(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<PersonResponseDto> {
     return this.service.getById(auth, id);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.PERSON_UPDATE })
+  @Authenticated({ permission: Permission.PersonUpdate })
   updatePerson(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -87,20 +87,20 @@ export class PersonController {
 
   @Delete(':id')
   @HttpCode(HttpStatus.NO_CONTENT)
-  @Authenticated({ permission: Permission.PERSON_DELETE })
+  @Authenticated({ permission: Permission.PersonDelete })
   deletePerson(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.delete(auth, id);
   }
 
   @Get(':id/statistics')
-  @Authenticated({ permission: Permission.PERSON_STATISTICS })
+  @Authenticated({ permission: Permission.PersonStatistics })
   getPersonStatistics(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<PersonStatisticsResponseDto> {
     return this.service.getStatistics(auth, id);
   }
 
   @Get(':id/thumbnail')
   @FileResponse()
-  @Authenticated({ permission: Permission.PERSON_READ })
+  @Authenticated({ permission: Permission.PersonRead })
   async getPersonThumbnail(
     @Res() res: Response,
     @Next() next: NextFunction,
@@ -111,7 +111,7 @@ export class PersonController {
   }
 
   @Put(':id/reassign')
-  @Authenticated({ permission: Permission.PERSON_REASSIGN })
+  @Authenticated({ permission: Permission.PersonReassign })
   reassignFaces(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -121,7 +121,7 @@ export class PersonController {
   }
 
   @Post(':id/merge')
-  @Authenticated({ permission: Permission.PERSON_MERGE })
+  @Authenticated({ permission: Permission.PersonMerge })
   mergePerson(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,

server/src/controllers/session.controller.ts

@@ -13,26 +13,26 @@ export class SessionController {
   constructor(private service: SessionService) {}
 
   @Post()
-  @Authenticated({ permission: Permission.SESSION_CREATE })
+  @Authenticated({ permission: Permission.SessionCreate })
   createSession(@Auth() auth: AuthDto, @Body() dto: SessionCreateDto): Promise<SessionCreateResponseDto> {
     return this.service.create(auth, dto);
   }
 
   @Get()
-  @Authenticated({ permission: Permission.SESSION_READ })
+  @Authenticated({ permission: Permission.SessionRead })
   getSessions(@Auth() auth: AuthDto): Promise<SessionResponseDto[]> {
     return this.service.getAll(auth);
   }
 
   @Delete()
-  @Authenticated({ permission: Permission.SESSION_DELETE })
+  @Authenticated({ permission: Permission.SessionDelete })
   @HttpCode(HttpStatus.NO_CONTENT)
   deleteAllSessions(@Auth() auth: AuthDto): Promise<void> {
     return this.service.deleteAll(auth);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.SESSION_UPDATE })
+  @Authenticated({ permission: Permission.SessionUpdate })
   updateSession(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -42,14 +42,14 @@ export class SessionController {
   }
 
   @Delete(':id')
-  @Authenticated({ permission: Permission.SESSION_DELETE })
+  @Authenticated({ permission: Permission.SessionDelete })
   @HttpCode(HttpStatus.NO_CONTENT)
   deleteSession(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.delete(auth, id);
   }
 
   @Post(':id/lock')
-  @Authenticated({ permission: Permission.SESSION_LOCK })
+  @Authenticated({ permission: Permission.SessionLock })
   @HttpCode(HttpStatus.NO_CONTENT)
   lockSession(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.lock(auth, id);

server/src/controllers/shared-link.controller.ts

@@ -24,7 +24,7 @@ export class SharedLinkController {
   constructor(private service: SharedLinkService) {}
 
   @Get()
-  @Authenticated({ permission: Permission.SHARED_LINK_READ })
+  @Authenticated({ permission: Permission.SharedLinkRead })
   getAllSharedLinks(@Auth() auth: AuthDto, @Query() dto: SharedLinkSearchDto): Promise<SharedLinkResponseDto[]> {
     return this.service.getAll(auth, dto);
   }
@@ -38,31 +38,31 @@ export class SharedLinkController {
     @Res({ passthrough: true }) res: Response,
     @GetLoginDetails() loginDetails: LoginDetails,
   ): Promise<SharedLinkResponseDto> {
-    const sharedLinkToken = request.cookies?.[ImmichCookie.SHARED_LINK_TOKEN];
+    const sharedLinkToken = request.cookies?.[ImmichCookie.SharedLinkToken];
     if (sharedLinkToken) {
       dto.token = sharedLinkToken;
     }
     const body = await this.service.getMine(auth, dto);
     return respondWithCookie(res, body, {
       isSecure: loginDetails.isSecure,
-      values: body.token ? [{ key: ImmichCookie.SHARED_LINK_TOKEN, value: body.token }] : [],
+      values: body.token ? [{ key: ImmichCookie.SharedLinkToken, value: body.token }] : [],
     });
   }
 
   @Get(':id')
-  @Authenticated({ permission: Permission.SHARED_LINK_READ })
+  @Authenticated({ permission: Permission.SharedLinkRead })
   getSharedLinkById(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<SharedLinkResponseDto> {
     return this.service.get(auth, id);
   }
 
   @Post()
-  @Authenticated({ permission: Permission.SHARED_LINK_CREATE })
+  @Authenticated({ permission: Permission.SharedLinkCreate })
   createSharedLink(@Auth() auth: AuthDto, @Body() dto: SharedLinkCreateDto) {
     return this.service.create(auth, dto);
   }
 
   @Patch(':id')
-  @Authenticated({ permission: Permission.SHARED_LINK_UPDATE })
+  @Authenticated({ permission: Permission.SharedLinkUpdate })
   updateSharedLink(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -72,7 +72,7 @@ export class SharedLinkController {
   }
 
   @Delete(':id')
-  @Authenticated({ permission: Permission.SHARED_LINK_DELETE })
+  @Authenticated({ permission: Permission.SharedLinkDelete })
   removeSharedLink(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.remove(auth, id);
   }

server/src/controllers/stack.controller.ts

@@ -14,32 +14,32 @@ export class StackController {
   constructor(private service: StackService) {}
 
   @Get()
-  @Authenticated({ permission: Permission.STACK_READ })
+  @Authenticated({ permission: Permission.StackRead })
   searchStacks(@Auth() auth: AuthDto, @Query() query: StackSearchDto): Promise<StackResponseDto[]> {
     return this.service.search(auth, query);
   }
 
   @Post()
-  @Authenticated({ permission: Permission.STACK_CREATE })
+  @Authenticated({ permission: Permission.StackCreate })
   createStack(@Auth() auth: AuthDto, @Body() dto: StackCreateDto): Promise<StackResponseDto> {
     return this.service.create(auth, dto);
   }
 
   @Delete()
-  @Authenticated({ permission: Permission.STACK_DELETE })
+  @Authenticated({ permission: Permission.StackDelete })
   @HttpCode(HttpStatus.NO_CONTENT)
   deleteStacks(@Auth() auth: AuthDto, @Body() dto: BulkIdsDto): Promise<void> {
     return this.service.deleteAll(auth, dto);
   }
 
   @Get(':id')
-  @Authenticated({ permission: Permission.STACK_READ })
+  @Authenticated({ permission: Permission.StackRead })
   getStack(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<StackResponseDto> {
     return this.service.get(auth, id);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.STACK_UPDATE })
+  @Authenticated({ permission: Permission.StackUpdate })
   updateStack(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -50,7 +50,7 @@ export class StackController {
 
   @Delete(':id')
   @HttpCode(HttpStatus.NO_CONTENT)
-  @Authenticated({ permission: Permission.STACK_DELETE })
+  @Authenticated({ permission: Permission.StackDelete })
   deleteStack(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.delete(auth, id);
   }

server/src/controllers/system-config.controller.ts

@@ -15,25 +15,25 @@ export class SystemConfigController {
   ) {}
 
   @Get()
-  @Authenticated({ permission: Permission.SYSTEM_CONFIG_READ, admin: true })
+  @Authenticated({ permission: Permission.SystemConfigRead, admin: true })
   getConfig(): Promise<SystemConfigDto> {
     return this.service.getSystemConfig();
   }
 
   @Get('defaults')
-  @Authenticated({ permission: Permission.SYSTEM_CONFIG_READ, admin: true })
+  @Authenticated({ permission: Permission.SystemConfigRead, admin: true })
   getConfigDefaults(): SystemConfigDto {
     return this.service.getDefaults();
   }
 
   @Put()
-  @Authenticated({ permission: Permission.SYSTEM_CONFIG_UPDATE, admin: true })
+  @Authenticated({ permission: Permission.SystemConfigUpdate, admin: true })
   updateConfig(@Body() dto: SystemConfigDto): Promise<SystemConfigDto> {
     return this.service.updateSystemConfig(dto);
   }
 
   @Get('storage-template-options')
-  @Authenticated({ permission: Permission.SYSTEM_CONFIG_READ, admin: true })
+  @Authenticated({ permission: Permission.SystemConfigRead, admin: true })
   getStorageTemplateOptions(): SystemConfigTemplateStorageOptionDto {
     return this.storageTemplateService.getStorageTemplateOptions();
   }

server/src/controllers/system-metadata.controller.ts

@@ -15,26 +15,26 @@ export class SystemMetadataController {
   constructor(private service: SystemMetadataService) {}
 
   @Get('admin-onboarding')
-  @Authenticated({ permission: Permission.SYSTEM_METADATA_READ, admin: true })
+  @Authenticated({ permission: Permission.SystemMetadataRead, admin: true })
   getAdminOnboarding(): Promise<AdminOnboardingUpdateDto> {
     return this.service.getAdminOnboarding();
   }
 
   @Post('admin-onboarding')
   @HttpCode(HttpStatus.NO_CONTENT)
-  @Authenticated({ permission: Permission.SYSTEM_METADATA_UPDATE, admin: true })
+  @Authenticated({ permission: Permission.SystemMetadataUpdate, admin: true })
   updateAdminOnboarding(@Body() dto: AdminOnboardingUpdateDto): Promise<void> {
     return this.service.updateAdminOnboarding(dto);
   }
 
   @Get('reverse-geocoding-state')
-  @Authenticated({ permission: Permission.SYSTEM_METADATA_READ, admin: true })
+  @Authenticated({ permission: Permission.SystemMetadataRead, admin: true })
   getReverseGeocodingState(): Promise<ReverseGeocodingStateResponseDto> {
     return this.service.getReverseGeocodingState();
   }
 
   @Get('version-check-state')
-  @Authenticated({ permission: Permission.SYSTEM_METADATA_READ, admin: true })
+  @Authenticated({ permission: Permission.SystemMetadataRead, admin: true })
   getVersionCheckState(): Promise<VersionCheckStateResponseDto> {
     return this.service.getVersionCheckState();
   }

server/src/controllers/tag.controller.ts

@@ -21,50 +21,50 @@ export class TagController {
   constructor(private service: TagService) {}
 
   @Post()
-  @Authenticated({ permission: Permission.TAG_CREATE })
+  @Authenticated({ permission: Permission.TagCreate })
   createTag(@Auth() auth: AuthDto, @Body() dto: TagCreateDto): Promise<TagResponseDto> {
     return this.service.create(auth, dto);
   }
 
   @Get()
-  @Authenticated({ permission: Permission.TAG_READ })
+  @Authenticated({ permission: Permission.TagRead })
   getAllTags(@Auth() auth: AuthDto): Promise<TagResponseDto[]> {
     return this.service.getAll(auth);
   }
 
   @Put()
-  @Authenticated({ permission: Permission.TAG_CREATE })
+  @Authenticated({ permission: Permission.TagCreate })
   upsertTags(@Auth() auth: AuthDto, @Body() dto: TagUpsertDto): Promise<TagResponseDto[]> {
     return this.service.upsert(auth, dto);
   }
 
   @Put('assets')
-  @Authenticated({ permission: Permission.TAG_ASSET })
+  @Authenticated({ permission: Permission.TagAsset })
   bulkTagAssets(@Auth() auth: AuthDto, @Body() dto: TagBulkAssetsDto): Promise<TagBulkAssetsResponseDto> {
     return this.service.bulkTagAssets(auth, dto);
   }
 
   @Get(':id')
-  @Authenticated({ permission: Permission.TAG_READ })
+  @Authenticated({ permission: Permission.TagRead })
   getTagById(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<TagResponseDto> {
     return this.service.get(auth, id);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.TAG_UPDATE })
+  @Authenticated({ permission: Permission.TagUpdate })
   updateTag(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto, @Body() dto: TagUpdateDto): Promise<TagResponseDto> {
     return this.service.update(auth, id, dto);
   }
 
   @Delete(':id')
   @HttpCode(HttpStatus.NO_CONTENT)
-  @Authenticated({ permission: Permission.TAG_DELETE })
+  @Authenticated({ permission: Permission.TagDelete })
   deleteTag(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<void> {
     return this.service.remove(auth, id);
   }
 
   @Put(':id/assets')
-  @Authenticated({ permission: Permission.TAG_ASSET })
+  @Authenticated({ permission: Permission.TagAsset })
   tagAssets(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -74,7 +74,7 @@ export class TagController {
   }
 
   @Delete(':id/assets')
-  @Authenticated({ permission: Permission.TAG_ASSET })
+  @Authenticated({ permission: Permission.TagAsset })
   untagAssets(
     @Auth() auth: AuthDto,
     @Body() dto: BulkIdsDto,

server/src/controllers/timeline.controller.ts

@@ -12,13 +12,13 @@ export class TimelineController {
   constructor(private service: TimelineService) {}
 
   @Get('buckets')
-  @Authenticated({ permission: Permission.ASSET_READ, sharedLink: true })
+  @Authenticated({ permission: Permission.AssetRead, sharedLink: true })
   getTimeBuckets(@Auth() auth: AuthDto, @Query() dto: TimeBucketDto) {
     return this.service.getTimeBuckets(auth, dto);
   }
 
   @Get('bucket')
-  @Authenticated({ permission: Permission.ASSET_READ, sharedLink: true })
+  @Authenticated({ permission: Permission.AssetRead, sharedLink: true })
   @ApiOkResponse({ type: TimeBucketAssetResponseDto })
   @Header('Content-Type', 'application/json')
   getTimeBucket(@Auth() auth: AuthDto, @Query() dto: TimeBucketAssetDto) {

server/src/controllers/trash.controller.ts

@@ -14,21 +14,21 @@ export class TrashController {
 
   @Post('empty')
   @HttpCode(HttpStatus.OK)
-  @Authenticated({ permission: Permission.ASSET_DELETE })
+  @Authenticated({ permission: Permission.AssetDelete })
   emptyTrash(@Auth() auth: AuthDto): Promise<TrashResponseDto> {
     return this.service.empty(auth);
   }
 
   @Post('restore')
   @HttpCode(HttpStatus.OK)
-  @Authenticated({ permission: Permission.ASSET_DELETE })
+  @Authenticated({ permission: Permission.AssetDelete })
   restoreTrash(@Auth() auth: AuthDto): Promise<TrashResponseDto> {
     return this.service.restore(auth);
   }
 
   @Post('restore/assets')
   @HttpCode(HttpStatus.OK)
-  @Authenticated({ permission: Permission.ASSET_DELETE })
+  @Authenticated({ permission: Permission.AssetDelete })
   restoreAssets(@Auth() auth: AuthDto, @Body() dto: BulkIdsDto): Promise<TrashResponseDto> {
     return this.service.restoreAssets(auth, dto);
   }

server/src/controllers/user-admin.controller.ts

@@ -21,25 +21,25 @@ export class UserAdminController {
   constructor(private service: UserAdminService) {}
 
   @Get()
-  @Authenticated({ permission: Permission.ADMIN_USER_READ, admin: true })
+  @Authenticated({ permission: Permission.AdminUserRead, admin: true })
   searchUsersAdmin(@Auth() auth: AuthDto, @Query() dto: UserAdminSearchDto): Promise<UserAdminResponseDto[]> {
     return this.service.search(auth, dto);
   }
 
   @Post()
-  @Authenticated({ permission: Permission.ADMIN_USER_CREATE, admin: true })
+  @Authenticated({ permission: Permission.AdminUserCreate, admin: true })
   createUserAdmin(@Body() createUserDto: UserAdminCreateDto): Promise<UserAdminResponseDto> {
     return this.service.create(createUserDto);
   }
 
   @Get(':id')
-  @Authenticated({ permission: Permission.ADMIN_USER_READ, admin: true })
+  @Authenticated({ permission: Permission.AdminUserRead, admin: true })
   getUserAdmin(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<UserAdminResponseDto> {
     return this.service.get(auth, id);
   }
 
   @Put(':id')
-  @Authenticated({ permission: Permission.ADMIN_USER_UPDATE, admin: true })
+  @Authenticated({ permission: Permission.AdminUserUpdate, admin: true })
   updateUserAdmin(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -49,7 +49,7 @@ export class UserAdminController {
   }
 
   @Delete(':id')
-  @Authenticated({ permission: Permission.ADMIN_USER_DELETE, admin: true })
+  @Authenticated({ permission: Permission.AdminUserDelete, admin: true })
   deleteUserAdmin(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -59,7 +59,7 @@ export class UserAdminController {
   }
 
   @Get(':id/statistics')
-  @Authenticated({ permission: Permission.ADMIN_USER_READ, admin: true })
+  @Authenticated({ permission: Permission.AdminUserRead, admin: true })
   getUserStatisticsAdmin(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -69,13 +69,13 @@ export class UserAdminController {
   }
 
   @Get(':id/preferences')
-  @Authenticated({ permission: Permission.ADMIN_USER_READ, admin: true })
+  @Authenticated({ permission: Permission.AdminUserRead, admin: true })
   getUserPreferencesAdmin(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<UserPreferencesResponseDto> {
     return this.service.getPreferences(auth, id);
   }
 
   @Put(':id/preferences')
-  @Authenticated({ permission: Permission.ADMIN_USER_UPDATE, admin: true })
+  @Authenticated({ permission: Permission.AdminUserUpdate, admin: true })
   updateUserPreferencesAdmin(
     @Auth() auth: AuthDto,
     @Param() { id }: UUIDParamDto,
@@ -85,7 +85,7 @@ export class UserAdminController {
   }
 
   @Post(':id/restore')
-  @Authenticated({ permission: Permission.ADMIN_USER_DELETE, admin: true })
+  @Authenticated({ permission: Permission.AdminUserDelete, admin: true })
   @HttpCode(HttpStatus.OK)
   restoreUserAdmin(@Auth() auth: AuthDto, @Param() { id }: UUIDParamDto): Promise<UserAdminResponseDto> {
     return this.service.restore(auth, id);

server/src/controllers/user.controller.ts

@@ -30,7 +30,7 @@ import { sendFile } from 'src/utils/file';
 import { UUIDParamDto } from 'src/validation';
 
 @ApiTags('Users')
-@Controller(RouteKey.USER)
+@Controller(RouteKey.User)
 export class UserController {
   constructor(
     private service: UserService,