[DEPLOY] : 3.0.3

MLS/Core/Core/Logger/Loggable.swift

@@ -0,0 +1,56 @@
+import OSLog
+
+public protocol Loggable {}
+
+public extension Loggable {
+    /// 모듈 이름을 자동으로 추출
+    /// - Returns: 타입이 정의된 모듈 이름 (예: "AuthFeature", "BookmarkFeature")
+    static var subsystem: String {
+        let fullName = String(reflecting: Self.self)
+        // "AuthFeature.LoginViewModel" -> "AuthFeature"
+        return fullName.components(separatedBy: ".").first ?? "Unknown"
+    }
+
+    /// 타입 이름을 카테고리로 사용
+    /// - Returns: 타입 이름 (예: "LoginViewModel", "BookmarkManager")
+    static var category: String {
+        String(describing: Self.self)
+    }
+
+    /// 타입별로 캐싱된 Logger 인스턴스
+    private static var logger: Logger {
+        LoggerStorage.logger(subsystem: subsystem, category: category)
+    }
+
+    /// 디버그 로그 (Debug 빌드에서만 출력)
+    /// - Parameter message: 로그 메시지 (.private로 보호되어 민감 정보도 안전하게 로깅)
+    func logDebug(_ message: String) {
+        #if DEBUG
+        Self.logger.debug("\(message, privacy: .private)")
+        #endif
+    }
+
+    /// 정보성 로그 (Notice 레벨)
+    /// - Parameter message: 로그 메시지
+    func logNotice(_ message: String) {
+        Self.logger.notice("\(message)")
+    }
+
+    /// 경고 로그 (비정상적이지만 처리 가능한 상황)
+    /// - Parameter message: 로그 메시지
+    func logWarning(_ message: String) {
+        Self.logger.warning("\(message)")
+    }
+
+    /// 에러 로그
+    /// - Parameter message: 로그 메시지
+    func logError(_ message: String) {
+        Self.logger.error("\(message)")
+    }
+
+    /// 치명적 에러 로그 (앱 크래시 직전 상황)
+    /// - Parameter message: 로그 메시지
+    func logCritical(_ message: String) {
+        Self.logger.critical("\(message)")
+    }
+}

MLS/Core/Core/Logger/LoggerStorage.swift

@@ -0,0 +1,47 @@
+import OSLog
+
+/// Logger를 NSCache에 저장하기 위한 Wrapper 클래스
+/// Logger는 struct이므로 class로 감싸야 NSCache에 저장 가능
+private final class LoggerBox {
+    let logger: Logger
+
+    init(logger: Logger) {
+        self.logger = logger
+    }
+}
+
+/// Logger 인스턴스를 캐싱하여 재사용하는 저장소
+/// NSCache를 사용하여 메모리 압박 시 자동으로 해제되며, Thread-safe하게 동작
+final class LoggerStorage {
+    static let shared = LoggerStorage()
+
+    /// 캐싱된 Logger 인스턴스들
+    /// NSCache는 메모리 부족 시 자동으로 오래된 항목을 제거
+    private let cache = NSCache<NSString, LoggerBox>()
+
+    private init() {}
+
+    /// Logger 인스턴스를 가져오거나 생성
+    /// - Parameters:
+    ///   - subsystem: 모듈 이름 (예: "AuthFeature")
+    ///   - category: 카테고리 이름 (예: "LoginViewModel")
+    /// - Returns: 캐싱되거나 새로 생성된 Logger 인스턴스
+    static func logger(subsystem: String, category: String) -> Logger {
+        shared.getOrCreateLogger(subsystem: subsystem, category: category)
+    }
+
+    private func getOrCreateLogger(subsystem: String, category: String) -> Logger {
+        let key = "\(subsystem).\(category)" as NSString
+
+        // 캐시에서 확인
+        if let box = cache.object(forKey: key) {
+            return box.logger
+        }
+
+        // 없으면 새로 생성 (NSCache는 thread-safe)
+        let newLogger = Logger(subsystem: subsystem, category: category)
+        let box = LoggerBox(logger: newLogger)
+        cache.setObject(box, forKey: key)
+        return newLogger
+    }
+}

MLS/Core/DIContainerTests/DIContainerTests.swift

@@ -1,19 +1,8 @@
 import XCTest
 
 @testable import Core
-@testable import Data
-@testable import DomainInterface
 
 class DIContainerTests: XCTestCase {
-    override func setUp() {
-        super.setUp()
-        DIContainer.resetForTesting()
-    }
-
-    override func tearDown() {
-        DIContainer.resetForTesting()
-        super.tearDown()
-    }
 
     /// 객체 등록 및 가져오기 테스트
     func testRegisterAndResolve() {
@@ -122,16 +111,3 @@ extension DIContainerTests {
         }
     }
 }
-
-// 테스트를 위한 서비스 초기화 함수
-extension DIContainer {
-    public static func resetForTesting() {
-        shared.resetForTesting()
-    }
-
-    private func resetForTesting() {
-        serviceQueue.sync {
-            services.removeAll()
-        }
-    }
-}

MLS/Core/DIContainerTests/LoggerTests.swift

@@ -0,0 +1,119 @@
+@testable import Core
+import Testing
+
+struct TestViewModel: Loggable {
+    func testLogs() {
+        logDebug("Debug 로그 테스트")
+        logNotice("Notice 로그 테스트")
+        logWarning("Warning 로그 테스트")
+        logError("Error 로그 테스트")
+        logCritical("Critical 로그 테스트")
+    }
+}
+
+class TestManager: Loggable {
+    func testLogs() {
+        logDebug("Debug 로그 (class)")
+        logNotice("Notice 로그 (class)")
+        logWarning("Warning 로그 (class)")
+        logError("Error 로그 (class)")
+        logCritical("Critical 로그 (class)")
+    }
+}
+
+struct LoggerTests {
+
+    @Test("Subsystem 자동 추출 검증 - Struct")
+    func testSubsystemExtractionStruct() async throws {
+        // subsystem은 타입이 정의된 모듈 이름이어야 함
+        let subsystem = TestViewModel.subsystem
+        let category = TestViewModel.category
+
+        // DIContainerTests 모듈에 정의되어 있으므로
+        #expect(subsystem == "DIContainerTests")
+        #expect(category == "TestViewModel")
+    }
+
+    @Test("Subsystem 자동 추출 검증 - Class")
+    func testSubsystemExtractionClass() async throws {
+        let subsystem = TestManager.subsystem
+        let category = TestManager.category
+
+        #expect(subsystem == "DIContainerTests")
+        #expect(category == "TestManager")
+    }
+
+    @Test("Struct에서 Loggable 사용 테스트")
+    func testLoggableWithStruct() async throws {
+        let viewModel = TestViewModel()
+
+        // 로그 출력 (Console.app에서 확인 가능)
+        // subsystem: "DIContainerTests", category: "TestViewModel"
+        viewModel.testLogs()
+
+        // 에러 없이 실행되면 성공
+        #expect(true)
+    }
+
+    @Test("Class에서 Loggable 사용 테스트")
+    func testLoggableWithClass() async throws {
+        let manager = TestManager()
+
+        // 로그 출력 (Console.app에서 확인 가능)
+        // subsystem: "DIContainerTests", category: "TestManager"
+        manager.testLogs()
+
+        // 에러 없이 실행되면 성공
+        #expect(true)
+    }
+
+    @Test("동시성 안전성 테스트 - 같은 Logger 동시 접근")
+    func testConcurrentLoggerAccess() async throws {
+        // 100개 스레드가 동시에 같은 Logger 사용
+        await withTaskGroup(of: Void.self) { group in
+            for i in 0..<100 {
+                group.addTask {
+                    let vm = TestViewModel()
+                    vm.logNotice("동시 로그 \(i)")
+                }
+            }
+        }
+
+        // 크래시 없이 완료되면 성공
+        #expect(true)
+    }
+
+    @Test("여러 타입에서 동시에 로깅")
+    func testMultipleTypesConcurrent() async throws {
+        let viewModel = TestViewModel()
+        let manager = TestManager()
+
+        // 동시에 로그 출력
+        await withTaskGroup(of: Void.self) { group in
+            group.addTask {
+                viewModel.testLogs()
+            }
+            group.addTask {
+                manager.testLogs()
+            }
+        }
+
+        // 에러 없이 실행되면 성공
+        #expect(true)
+    }
+
+    @Test("NSCache 캐싱 검증 - 반복 접근 시 정상 동작")
+    func testLoggerCaching() async throws {
+        let vm1 = TestViewModel()
+        let vm2 = TestViewModel()
+
+        // 같은 타입에서 여러 번 로깅 (NSCache에서 캐싱된 Logger 재사용)
+        vm1.logNotice("첫 번째 인스턴스")
+        vm2.logNotice("두 번째 인스턴스")
+        vm1.logNotice("다시 첫 번째")
+        vm2.logNotice("다시 두 번째")
+
+        // 크래시 없이 정상 동작하면 성공
+        #expect(true)
+    }
+}

MLS/Data/Data/Network/DTO/AlarmDTO/AlarmResponseDTO.swift

@@ -32,6 +32,7 @@ public struct AlarmResponseDTO: Decodable {
     }
 
     public struct NormalContent: Decodable {
+        public let id: Int
         public let type: String
         public let title: String
         public let link: String
@@ -50,13 +51,15 @@ public extension AlarmResponseDTO {
             switch content {
             case .normal(let normal):
                 return AlarmResponse(
+                    id: normal.id,
                     type: normal.type,
                     title: normal.title,
                     link: normal.link,
                     date: normal.date
                 )
             case .all(let all):
                 return AlarmResponse(
+                    id: all.alrim.id,
                     type: all.alrim.type,
                     title: all.alrim.title,
                     link: all.alrim.link,
@@ -72,6 +75,7 @@ public extension AlarmResponseDTO {
             switch content {
             case .all(let all):
                 return AllAlarmResponse(
+                    id: all.alrim.id,
                     type: all.alrim.type,
                     title: all.alrim.title,
                     link: all.alrim.link,

MLS/Data/Data/Network/Endpoints/AlarmEndPoint.swift

@@ -6,7 +6,7 @@ public enum AlarmEndPoint {
     public static func fetchPatchNotes(query: Encodable) -> ResponsableEndPoint<AlarmResponseDTO> {
         .init(
             baseURL: base,
-            path: "/api/v1/alrim/list/patch-notes",
+            path: "/api/v2/alrim/list/patch-notes",
             method: .GET,
             query: query
         )
@@ -15,7 +15,7 @@ public enum AlarmEndPoint {
     public static func fetchNotices(query: Encodable) -> ResponsableEndPoint<AlarmResponseDTO> {
         .init(
             baseURL: base,
-            path: "/api/v1/alrim/list/notices",
+            path: "/api/v2/alrim/list/notices",
             method: .GET,
             query: query
         )
@@ -24,7 +24,7 @@ public enum AlarmEndPoint {
     public static func fetchOutdatedEvents(query: Encodable) -> ResponsableEndPoint<AlarmResponseDTO> {
         .init(
             baseURL: base,
-            path: "/api/v1/alrim/list/events/outdated",
+            path: "/api/v2/alrim/list/events/outdated",
             method: .GET,
             query: query
         )
@@ -33,7 +33,7 @@ public enum AlarmEndPoint {
     public static func fetchOngoingEvents(query: Encodable) -> ResponsableEndPoint<AlarmResponseDTO> {
         .init(
             baseURL: base,
-            path: "/api/v1/alrim/list/events/ongoing",
+            path: "/api/v2/alrim/list/events/ongoing",
             method: .GET,
             query: query
         )
@@ -42,7 +42,7 @@ public enum AlarmEndPoint {
     public static func fetchAll(query: Encodable) -> ResponsableEndPoint<AlarmResponseDTO> {
         .init(
             baseURL: base,
-            path: "/api/v1/alrim/all",
+            path: "/api/v2/alrim/all",
             method: .GET,
             query: query
         )

MLS/Data/Data/Repository/AlarmAPIRepositoryImpl.swift

@@ -13,31 +13,31 @@ public class AlarmAPIRepositoryImpl: AlarmAPIRepository {
         self.tokenInterceptor = interceptor
     }
 
-    public func fetchPatchNotes(cursor: String?, pageSize: Int) -> Observable<PagedEntity<AlarmResponse>> {
+    public func fetchPatchNotes(cursor: Int?, pageSize: Int) -> Observable<PagedEntity<AlarmResponse>> {
         let endpoint = AlarmEndPoint.fetchPatchNotes(query: AlarmQuery(cursor: cursor, pageSize: pageSize))
         return provider.requestData(endPoint: endpoint, interceptor: tokenInterceptor)
             .map { $0.toAlarmDomain() }
     }
 
-    public func fetchNotices(cursor: String?, pageSize: Int) -> Observable<PagedEntity<AlarmResponse>> {
+    public func fetchNotices(cursor: Int?, pageSize: Int) -> Observable<PagedEntity<AlarmResponse>> {
         let endpoint = AlarmEndPoint.fetchNotices(query: AlarmQuery(cursor: cursor, pageSize: pageSize))
         return provider.requestData(endPoint: endpoint, interceptor: tokenInterceptor)
             .map { $0.toAlarmDomain() }
     }
 
-    public func fetchOutdatedEvents(cursor: String?, pageSize: Int) -> Observable<PagedEntity<AlarmResponse>> {
+    public func fetchOutdatedEvents(cursor: Int?, pageSize: Int) -> Observable<PagedEntity<AlarmResponse>> {
         let endpoint = AlarmEndPoint.fetchOutdatedEvents(query: AlarmQuery(cursor: cursor, pageSize: pageSize))
         return provider.requestData(endPoint: endpoint, interceptor: tokenInterceptor)
             .map { $0.toAlarmDomain() }
     }
 
-    public func fetchOngoingEvents(cursor: String?, pageSize: Int) -> Observable<PagedEntity<AlarmResponse>> {
+    public func fetchOngoingEvents(cursor: Int?, pageSize: Int) -> Observable<PagedEntity<AlarmResponse>> {
         let endpoint = AlarmEndPoint.fetchOngoingEvents(query: AlarmQuery(cursor: cursor, pageSize: pageSize))
         return provider.requestData(endPoint: endpoint, interceptor: tokenInterceptor)
             .map { $0.toAlarmDomain() }
     }
 
-    public func fetchAll(cursor: String?, pageSize: Int) -> Observable<PagedEntity<AllAlarmResponse>> {
+    public func fetchAll(cursor: Int?, pageSize: Int) -> Observable<PagedEntity<AllAlarmResponse>> {
         let endpoint = AlarmEndPoint.fetchAll(query: AlarmQuery(cursor: cursor, pageSize: pageSize))
         return provider.requestData(endPoint: endpoint, interceptor: tokenInterceptor)
             .map { $0.toAllAlarmDomain() }
@@ -52,7 +52,7 @@ public class AlarmAPIRepositoryImpl: AlarmAPIRepository {
 
 private extension AlarmAPIRepositoryImpl {
     struct AlarmQuery: Encodable {
-        let cursor: String?
+        let cursor: Int?
         let pageSize: Int
     }
 

MLS/Domain/Domain/UseCaseImpl/Alarm/FetchAllAlarmUseCaseImpl.swift

@@ -11,7 +11,7 @@ public class FetchAllAlarmUseCaseImpl: FetchAllAlarmUseCase {
         self.repository = repository
     }
 
-    public func execute(cursor: String?, pageSize: Int) -> Observable<PagedEntity<AllAlarmResponse>> {
-        return repository.fetchAll(cursor: cursor, pageSize: pageSize)
+    public func execute(id: Int?, pageSize: Int) -> Observable<PagedEntity<AllAlarmResponse>> {
+        return repository.fetchAll(cursor: id, pageSize: pageSize)
     }
 }