feat : speaking REST API 람다 함수 추가

ServerlessFunction/src/main/java/com/mzc/secondproject/serverless/domain/speaking/dto/request/ResetRequest.java

@@ -0,0 +1,12 @@
+package com.mzc.secondproject.serverless.domain.speaking.dto.request;
+
+/**
+ * 대화 초기화 요청 DTO
+ */
+public record ResetRequest(
+        String sessionId
+) {
+    public boolean isValid() {
+        return sessionId != null && !sessionId.isEmpty();
+    }
+}

ServerlessFunction/src/main/java/com/mzc/secondproject/serverless/domain/speaking/dto/request/SpeakingRequest.java

@@ -0,0 +1,32 @@
+package com.mzc.secondproject.serverless.domain.speaking.dto.request;
+
+/**
+ * Speaking API 요청 DTO
+ */
+public record SpeakingRequest(
+        String sessionId,   // 세션 ID (첫 요청 시 null)
+        String audio,       // 음성 데이터 (base64)
+        String text,        // 텍스트 입력
+        String level        // 레벨 (BEGINNER, INTERMEDIATE, ADVANCED)
+) {
+    /**
+     * 기본값 적용된 레벨 반환
+     */
+    public String getLevelOrDefault() {
+        return level != null && !level.isEmpty() ? level : "INTERMEDIATE";
+    }
+
+    /**
+     * 음성 입력인지 확인
+     */
+    public boolean hasAudio() {
+        return audio != null && !audio.isEmpty();
+    }
+
+    /**
+     * 텍스트 입력인지 확인
+     */
+    public boolean hasText() {
+        return text != null && !text.trim().isEmpty();
+    }
+}

ServerlessFunction/src/main/java/com/mzc/secondproject/serverless/domain/speaking/dto/response/SpeakingResponse.java

@@ -0,0 +1,12 @@
+package com.mzc.secondproject.serverless.domain.speaking.dto.response;
+
+/**
+ * Speaking API 응답 DTO
+ */
+public record SpeakingResponse(
+        String sessionId,         // 세션 ID (다음 요청에 사용)
+        String userTranscript,    // 사용자가 말한 내용 (STT 결과)
+        String aiText,            // AI 응답 텍스트
+        String aiAudioUrl,        // AI 응답 음성 URL (Polly)
+        double confidence         // STT 신뢰도
+) {}

ServerlessFunction/src/main/java/com/mzc/secondproject/serverless/domain/speaking/handler/websocket/SpeakingHandler.java

@@ -0,0 +1,157 @@
+package com.mzc.secondproject.serverless.domain.speaking.handler.websocket;
+
+import com.amazonaws.services.lambda.runtime.Context;
+import com.amazonaws.services.lambda.runtime.RequestHandler;
+import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
+import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.mzc.secondproject.serverless.common.util.JwtUtil;
+import com.mzc.secondproject.serverless.domain.speaking.service.SpeakingService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Speaking  API 핸들러
+ *
+ * POST /api/speaking/chat - 대화 (음성 또는 텍스트)
+ * POST /api/speaking/reset - 대화 초기화
+ */
+public class SpeakingHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
+
+    private static final Logger logger = LoggerFactory.getLogger(SpeakingHandler.class);
+    private static final Gson gson = new GsonBuilder().create();
+
+    private static final Map<String, String> CORS_HEADERS = Map.of(
+            "Content-Type", "application/json",
+            "Access-Control-Allow-Origin", "*",
+            "Access-Control-Allow-Headers", "Content-Type,Authorization",
+            "Access-Control-Allow-Methods", "POST,OPTIONS"
+    );
+
+    private final SpeakingService speakingService;
+
+    public SpeakingHandler() {
+        this.speakingService = new SpeakingService();
+    }
+
+    @Override
+    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent event, Context context) {
+        logger.info("Speaking  API request received");
+
+        // OPTIONS 요청 처리 (CORS preflight)
+        if ("OPTIONS".equalsIgnoreCase(event.getHttpMethod())) {
+            return response(200, Map.of("message", "OK"));
+        }
+
+        try {
+            // JWT 토큰 검증
+            String authHeader = event.getHeaders().get("Authorization");
+            if (authHeader == null || !authHeader.startsWith("Bearer ")) {
+                return response(401, Map.of("error", "Authorization header is required"));
+            }
+
+            String token = authHeader.substring(7);
+            if (!JwtUtil.isValid(token)) {
+                return response(401, Map.of("error", "Invalid or expired token"));
+            }
+
+            Optional<String> userIdOpt = JwtUtil.extractUserId(token);
+            if (userIdOpt.isEmpty()) {
+                return response(401, Map.of("error", "Invalid token"));
+            }
+
+            String userId = userIdOpt.get();
+            String path = event.getPath();
+            String body = event.getBody();
+
+            logger.info("Processing request: path={}, userId={}", path, userId);
+
+            // 라우팅
+            if (path.endsWith("/chat")) {
+                return handleChat(userId, body);
+            } else if (path.endsWith("/reset")) {
+                return handleReset(userId, body);
+            } else {
+                return response(404, Map.of("error", "Not found"));
+            }
+
+        } catch (Exception e) {
+            logger.error("Error processing request: {}", e.getMessage(), e);
+            return response(500, Map.of("error", "Internal server error: " + e.getMessage()));
+        }
+    }
+
+    /**
+     * 대화 처리 (음성 또는 텍스트)
+     */
+    private APIGatewayProxyResponseEvent handleChat(String userId, String body) {
+        if (body == null || body.isEmpty()) {
+            return response(400, Map.of("error", "Request body is required"));
+        }
+
+        JsonObject request = JsonParser.parseString(body).getAsJsonObject();
+
+        String sessionId = request.has("sessionId") ? request.get("sessionId").getAsString() : null;
+        String level = request.has("level") ? request.get("level").getAsString() : "INTERMEDIATE";
+        String audio = request.has("audio") ? request.get("audio").getAsString() : null;
+        String text = request.has("text") ? request.get("text").getAsString() : null;
+
+        SpeakingService.SpeakingResponse result;
+
+        if (audio != null && !audio.isEmpty()) {
+            // 음성 입력 처리
+            logger.info("Processing voice input");
+            result = speakingService.processVoiceInput(sessionId, userId, audio, level);
+        } else if (text != null && !text.trim().isEmpty()) {
+            // 텍스트 입력 처리
+            logger.info("Processing text input: {}", text);
+            result = speakingService.processTextInput(sessionId, userId, text.trim(), level);
+        } else {
+            return response(400, Map.of("error", "Either 'audio' or 'text' is required"));
+        }
+
+        return response(200, Map.of(
+                "sessionId", result.sessionId(),
+                "userTranscript", result.userTranscript(),
+                "aiText", result.aiText(),
+                "aiAudioUrl", result.aiAudioUrl(),
+                "confidence", result.confidence()
+        ));
+    }
+
+    /**
+     * 대화 초기화
+     */
+    private APIGatewayProxyResponseEvent handleReset(String userId, String body) {
+        if (body == null || body.isEmpty()) {
+            return response(400, Map.of("error", "Request body is required"));
+        }
+
+        JsonObject request = JsonParser.parseString(body).getAsJsonObject();
+        String sessionId = request.has("sessionId") ? request.get("sessionId").getAsString() : null;
+
+        if (sessionId == null || sessionId.isEmpty()) {
+            return response(400, Map.of("error", "sessionId is required"));
+        }
+
+        speakingService.resetConversation(sessionId);
+
+        return response(200, Map.of(
+                "message", "Conversation reset successfully",
+                "sessionId", sessionId
+        ));
+    }
+
+    private APIGatewayProxyResponseEvent response(int statusCode, Map<String, Object> body) {
+        return new APIGatewayProxyResponseEvent()
+                .withStatusCode(statusCode)
+                .withHeaders(CORS_HEADERS)
+                .withBody(gson.toJson(body));
+    }
+}

ServerlessFunction/src/main/java/com/mzc/secondproject/serverless/domain/speaking/model/SpeakingSession.java

@@ -0,0 +1,96 @@
+package com.mzc.secondproject.serverless.domain.speaking.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.*;
+
+/**
+ * Speaking WebSocket 연결 정보
+ * connectionId ↔ userId 매핑 + 대화 히스토리 저장
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@DynamoDbBean
+public class SpeakingSession {
+
+    // DynamoDB Key Prefixes
+    public static final String PK_PREFIX = "SPEAKING_SESSION#";
+    public static final String SK_METADATA = "METADATA";
+    public static final String GSI1PK_PREFIX = "SPEAKING_USER#";
+    public static final String GSI1SK_PREFIX = "SESSION#";
+
+    private String pk;          // SPEAKING_SESSION#{sessionId}
+    private String sk;          // METADATA
+    private String gsi1pk;      // SPEAKING_USER#{userId}
+    private String gsi1sk;      // SESSION#{sessionId}
+
+    private String sessionId;
+    private String userId;
+    private String createdAt;
+    private String updatedAt;
+    private Long ttl;           // 자동 삭제용 (24시간)
+
+    // Speaking 전용 필드
+    private String conversationHistory;  // 대화 히스토리 (JSON)
+    private String targetLevel;          // 목표 레벨 (BEGINNER, INTERMEDIATE, ADVANCED)
+
+    /**
+     * 세션 생성 팩토리 메서드
+     */
+    public static SpeakingSession create(String sessionId, String userId, String level) {
+        String now = java.time.Instant.now().toString();
+        // 24시간 후 자동 삭제
+        long ttl = java.time.Instant.now().plusSeconds(86400).getEpochSecond();
+
+        return SpeakingSession.builder()
+                .pk(PK_PREFIX + sessionId)
+                .sk(SK_METADATA)
+                .gsi1pk(GSI1PK_PREFIX + userId)
+                .gsi1sk(GSI1SK_PREFIX + sessionId)
+                .sessionId(sessionId)
+                .userId(userId)
+                .createdAt(now)
+                .updatedAt(now)
+                .ttl(ttl)
+                .conversationHistory("[]")
+                .targetLevel(level != null ? level.toUpperCase() : "INTERMEDIATE")
+                .build();
+    }
+
+    /**
+     * 업데이트 시간 갱신
+     */
+    public void touch() {
+        this.updatedAt = java.time.Instant.now().toString();
+        // TTL 연장 (24시간)
+        this.ttl = java.time.Instant.now().plusSeconds(86400).getEpochSecond();
+    }
+
+    @DynamoDbPartitionKey
+    @DynamoDbAttribute("PK")
+    public String getPk() {
+        return pk;
+    }
+
+    @DynamoDbSortKey
+    @DynamoDbAttribute("SK")
+    public String getSk() {
+        return sk;
+    }
+
+    @DynamoDbSecondaryPartitionKey(indexNames = "GSI1")
+    @DynamoDbAttribute("GSI1PK")
+    public String getGsi1pk() {
+        return gsi1pk;
+    }
+
+    @DynamoDbSecondarySortKey(indexNames = "GSI1")
+    @DynamoDbAttribute("GSI1SK")
+    public String getGsi1sk() {
+        return gsi1sk;
+    }
+}

ServerlessFunction/src/main/java/com/mzc/secondproject/serverless/domain/speaking/repository/SpeakingSessionRepository.java

@@ -0,0 +1,74 @@
+package com.mzc.secondproject.serverless.domain.speaking.repository;
+
+import com.mzc.secondproject.serverless.common.config.AwsClients;
+import com.mzc.secondproject.serverless.common.config.EnvConfig;
+import com.mzc.secondproject.serverless.domain.speaking.model.SpeakingSession;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
+import software.amazon.awssdk.enhanced.dynamodb.Key;
+import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
+
+import java.util.Optional;
+
+/**
+ * Speaking WebSocket 연결 정보 Repository
+ */
+public class SpeakingSessionRepository {
+
+    private static final Logger logger = LoggerFactory.getLogger(SpeakingSessionRepository.class);
+    private static final String TABLE_NAME = EnvConfig.getRequired("CHAT_TABLE_NAME");
+
+    private final DynamoDbTable<SpeakingSession> table;
+
+    public SpeakingSessionRepository() {
+        this.table = AwsClients.dynamoDbEnhanced().table(
+                TABLE_NAME,
+                TableSchema.fromBean(SpeakingSession.class)
+        );
+    }
+
+    /**
+     * 연결 정보 저장
+     */
+    public void save(SpeakingSession session) {
+        table.putItem(session);
+        logger.debug("Speaking session saved: sessionId={}, userId={}",
+                session.getSessionId(), session.getUserId());
+    }
+
+    /**
+     * sessionId로 연결 정보 조회
+     */
+    public Optional<SpeakingSession> findBySessionId(String sessionId) {
+        Key key = Key.builder()
+                .partitionValue(SpeakingSession.PK_PREFIX + sessionId)
+                .sortValue(SpeakingSession.SK_METADATA)
+                .build();
+
+        SpeakingSession session = table.getItem(key);
+        return Optional.ofNullable(session);
+    }
+
+    /**
+     * 연결 정보 업데이트 (대화 히스토리 등)
+     */
+    public void update(SpeakingSession session) {
+        session.touch(); // 업데이트 시간 및 TTL 갱신
+        table.putItem(session);
+        logger.debug("Speaking session updated: sessionId={}", session.getSessionId());
+    }
+
+    /**
+     * 연결 정보 삭제
+     */
+    public void delete(String sessionId) {
+        Key key = Key.builder()
+                .partitionValue(SpeakingSession.PK_PREFIX + sessionId)
+                .sortValue(SpeakingSession.SK_METADATA)
+                .build();
+
+        table.deleteItem(key);
+        logger.info("Speaking session deleted: sessionId={}", sessionId);
+    }
+}