[
  {
    "word": "serendipity",
    "meaning": "... new meaning ..."
  },
  {
    "word": "effervescent",
    "meaning": "... new word ..."
  }
]

CREATE TABLE dictionary_word (
  word VARCHAR(255) PRIMARY KEY,
  meaning TEXT NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

@Entity
@Table(name = "dictionary_word")
public class DictionaryWord {
    @Id
    private String word;

    @Column(columnDefinition = "TEXT")
    private String meaning;

    @Column
    private Timestamp createdAt;

    @Column
    private Timestamp updatedAt;

    // getters and setters
}

@Repository
public interface DictionaryWordRepository extends JpaRepository<DictionaryWord, String> {
}

@Configuration
public class RedisConfig {

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory();
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate() {
        RedisTemplate<String, String> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory());
        return template;
    }
}

@Service
public class DictionaryService {

    @Autowired
    private DictionaryWordRepository repository;

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public String getMeaning(String word) {
        String cachedMeaning = redisTemplate.opsForValue().get(word);
        if (cachedMeaning != null) {
            return cachedMeaning;
        }

        DictionaryWord wordEntity = repository.findById(word)
                .orElseThrow(() -> new RuntimeException("Word not found"));

        redisTemplate.opsForValue().set(word, wordEntity.getMeaning());
        return wordEntity.getMeaning();
    }

    @Transactional
    public void applyChangelog(List<DictionaryWord> newWords) {
        for (DictionaryWord w : newWords) {
            repository.save(w);
            redisTemplate.delete(w.getWord()); // clear cache
        }
    }
}

@RestController
@RequestMapping("/api")
public class DictionaryController {

    @Autowired
    private DictionaryService service;

    @GetMapping("/word/{word}")
    public ResponseEntity<String> getWord(@PathVariable String word) {
        return ResponseEntity.ok(service.getMeaning(word));
    }

    @PostMapping("/changelog")
    public ResponseEntity<String> uploadChangelog(@RequestBody List<DictionaryWord> changelog) {
        service.applyChangelog(changelog);
        return ResponseEntity.ok("Changelog applied");
    }
}

spring.datasource.url=jdbc:postgresql://${POSTGRES_HOST:localhost}:5432/dictionarydb
spring.datasource.username=${POSTGRES_USER:postgres}
spring.datasource.password=${POSTGRES_PASSWORD:password}
spring.redis.host=${REDIS_HOST:localhost}
spring.redis.port=6379

version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - POSTGRES_HOST=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=example
      - REDIS_HOST=redis
    depends_on:
      - postgres
      - redis

  postgres:
    image: postgres:15
    restart: always
    environment:
      POSTGRES_DB: dictionarydb
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: example
    ports:
      - "5432:5432"

  redis:
    image: redis:alpine
    ports:
      - "6379:6379"

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dictionary-app
spec:
  replicas: 5
  selector:
    matchLabels:
      app: dictionary-app
  template:
    metadata:
      labels:
        app: dictionary-app
    spec:
      containers:
        - name: dictionary-container
          image: gcr.io/YOUR_PROJECT_ID/dictionary-app:latest
          ports:
            - containerPort: 8080
          env:
            - name: POSTGRES_HOST
              value: "YOUR_PG_HOST"
            - name: POSTGRES_USER
              value: "postgres"
            - name: POSTGRES_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: pg-secret
                  key: password
            - name: REDIS_HOST
              value: "YOUR_REDIS_HOST"
---
apiVersion: v1
kind: Service
metadata:
  name: dictionary-service
spec:
  type: LoadBalancer
  selector:
    app: dictionary-app
  ports:
    - port: 80
      targetPort: 8080

public class Word {
    private final String word;
    private final String meaning;

    private Word(Builder builder) {
        this.word = builder.word;
        this.meaning = builder.meaning;
    }

    public String getWord() { return word; }
    public String getMeaning() { return meaning; }

    public static class Builder {
        private String word;
        private String meaning;

        public Builder word(String word) {
            this.word = word;
            return this;
        }

        public Builder meaning(String meaning) {
            this.meaning = meaning;
            return this;
        }

        public Word build() {
            return new Word(this);
        }
    }
}

public interface IWordRepository {
    Optional<Word> findWord(String word);
    void saveWords(List<Word> words);
}

@Repository
public class WordRepository implements IWordRepository {
    // Spring Data JPA or JdbcTemplate
    public Optional<Word> findWord(String word) {
        // SELECT * FROM dictionary WHERE word = ?
        return Optional.empty(); // example
    }

    public void saveWords(List<Word> words) {
        // Transactional batch UPSERT
    }
}

public interface ICacheService {
    String get(String key);
    void set(String key, String value);
    void evict(String key);
}

@Service
public class RedisCacheService implements ICacheService {
    private final RedisTemplate<String, String> redis;

    public RedisCacheService(RedisTemplate<String, String> redis) {
        this.redis = redis;
    }

    public String get(String key) {
        return redis.opsForValue().get(key);
    }

    public void set(String key, String value) {
        redis.opsForValue().set(key, value);
    }

    public void evict(String key) {
        redis.delete(key);
    }
}

public interface IChangelogProcessor {
    List<Word> parseChangelog(File file);
}

public class JSONProcessor implements IChangelogProcessor {
    public List<Word> parseChangelog(File file) {
        // Parse JSON changelog
        return List.of();
    }
}

public class CSVProcessor implements IChangelogProcessor {
    public List<Word> parseChangelog(File file) {
        // Parse CSV changelog
        return List.of();
    }
}

public class ChangelogProcessorFactory {
    public static IChangelogProcessor getProcessor(String fileType) {
        switch(fileType) {
            case "json": return new JSONProcessor();
            case "csv": return new CSVProcessor();
            default: throw new IllegalArgumentException("Unsupported file type");
        }
    }
}

public interface CacheStrategy {
    String get(String key);
    void put(String key, String value);
}

public class ReadThroughCacheStrategy implements CacheStrategy {
    private final ICacheService cache;
    private final IWordRepository repository;

    public ReadThroughCacheStrategy(ICacheService cache, IWordRepository repository) {
        this.cache = cache;
        this.repository = repository;
    }

    public String get(String key) {
        String cached = cache.get(key);
        if (cached != null) return cached;

        Optional<Word> word = repository.findWord(key);
        word.ifPresent(w -> cache.set(key, w.getMeaning()));
        return word.map(Word::getMeaning).orElse(null);
    }

    public void put(String key, String value) {
        cache.set(key, value);
    }
}

public interface IDictionaryService {
    String getMeaning(String word);
    void applyChangelog(File file, String fileType);
}

@Service
public class DictionaryService implements IDictionaryService {
    private final IWordRepository repo;
    private final ICacheService cache;

    public DictionaryService(IWordRepository repo, ICacheService cache) {
        this.repo = repo;
        this.cache = cache;
    }

    public String getMeaning(String word) {
        String cached = cache.get(word);
        if (cached != null) return cached;

        Word w = repo.findWord(word)
                     .orElseThrow(() -> new RuntimeException("Word not found"));
        cache.set(word, w.getMeaning());
        return w.getMeaning();
    }

    public void applyChangelog(File file, String fileType) {
        IChangelogProcessor processor = ChangelogProcessorFactory.getProcessor(fileType);
        List<Word> words = processor.parseChangelog(file);
        repo.saveWords(words);
        words.forEach(w -> cache.evict(w.getWord()));
    }
}

public interface IDictionaryService {
    String getMeaning(String word);
    void applyChangelog(File file, String fileType);
}

@Service
public class DictionaryService implements IDictionaryService {
    private final IWordRepository repo;
    private final ICacheService cache;

    public DictionaryService(IWordRepository repo, ICacheService cache) {
        this.repo = repo;
        this.cache = cache;
    }

    public String getMeaning(String word) {
        String cached = cache.get(word);
        if (cached != null) return cached;

        Word w = repo.findWord(word)
                     .orElseThrow(() -> new RuntimeException("Word not found"));
        cache.set(word, w.getMeaning());
        return w.getMeaning();
    }

    public void applyChangelog(File file, String fileType) {
        IChangelogProcessor processor = ChangelogProcessorFactory.getProcessor(fileType);
        List<Word> words = processor.parseChangelog(file);
        repo.saveWords(words);
        words.forEach(w -> cache.evict(w.getWord()));
    }
}

@ExtendWith(MockitoExtension.class)
class DictionaryServiceTest {

    @Mock
    private IWordRepository repo;

    @Mock
    private ICacheService cache;

    @InjectMocks
    private DictionaryService service;

    @Test
    void testGetMeaning_CacheHit() {
        when(cache.get("apple")).thenReturn("A fruit");

        String result = service.getMeaning("apple");

        assertEquals("A fruit", result);
        verifyNoInteractions(repo);
    }

    @Test
    void testGetMeaning_CacheMiss_DBHit() {
        when(cache.get("banana")).thenReturn(null);
        when(repo.findWord("banana")).thenReturn(Optional.of(
            new Word.Builder().word("banana").meaning("Yellow fruit").build()
        ));

        String result = service.getMeaning("banana");

        assertEquals("Yellow fruit", result);
        verify(cache).set("banana", "Yellow fruit");
    }

    @Test
    void testGetMeaning_NotFound() {
        when(cache.get("kiwi")).thenReturn(null);
        when(repo.findWord("kiwi")).thenReturn(Optional.empty());

        assertThrows(RuntimeException.class, () -> service.getMeaning("kiwi"));
    }

    @Test
    void testApplyChangelog_ProcessorAndRepo() {
        // Mock changelog file and processor
        File dummyFile = new File("dummy.json");
        IChangelogProcessor mockProcessor = mock(IChangelogProcessor.class);
        List<Word> mockWords = List.of(
            new Word.Builder().word("pear").meaning("Juicy fruit").build()
        );
        when(mockProcessor.parseChangelog(dummyFile)).thenReturn(mockWords);

        // Replace factory for test
        try (MockedStatic<ChangelogProcessorFactory> mockedFactory = 
                mockStatic(ChangelogProcessorFactory.class)) {
            mockedFactory.when(() -> ChangelogProcessorFactory.getProcessor("json"))
                    .thenReturn(mockProcessor);

            service.applyChangelog(dummyFile, "json");

            verify(repo).saveWords(mockWords);
            verify(cache).evict("pear");
        }
    }
}

version: "3.8"

services:
  dictionary-app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - SPRING_DATASOURCE_URL=jdbc:postgresql://postgres:5432/dictionary
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
      - SPRING_REDIS_HOST=redis
    depends_on:
      - postgres
      - redis

  postgres:
    image: postgres:15
    restart: always
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: dictionary
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7
    restart: always
    ports:
      - "6379:6379"

volumes:
  pgdata:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dictionary-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: dictionary-service
  template:
    metadata:
      labels:
        app: dictionary-service
    spec:
      containers:
      - name: dictionary-app
        image: gcr.io/YOUR_PROJECT_ID/dictionary-app:latest
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_DATASOURCE_URL
          value: jdbc:postgresql://POSTGRES_HOST:5432/dictionary
        - name: SPRING_DATASOURCE_USERNAME
          value: postgres
        - name: SPRING_DATASOURCE_PASSWORD
          value: postgres
        - name: SPRING_REDIS_HOST
          value: REDIS_HOST
---
apiVersion: v1
kind: Service
metadata:
  name: dictionary-service
spec:
  selector:
    app: dictionary-service
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

# Use a minimal builder image
FROM eclipse-temurin:17-jdk as build

WORKDIR /app

# Copy Maven files and download dependencies first (layer caching)
COPY mvnw .
COPY .mvn .mvn
COPY pom.xml .
RUN ./mvnw dependency:go-offline

# Copy source and build
COPY src src
RUN ./mvnw package -DskipTests

# ===========================
# Use a slim base image
FROM eclipse-temurin:17-jre-alpine

WORKDIR /app

COPY --from=build /app/target/*.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

apiVersion: v2
name: dictionary
description: A Helm chart for the Dictionary Service
type: application
version: 0.1.0
appVersion: "1.0"

replicaCount: 3

image:
  repository: gcr.io/YOUR_PROJECT_ID/dictionary-app
  tag: latest
  pullPolicy: IfNotPresent

service:
  type: LoadBalancer
  port: 80

env:
  SPRING_DATASOURCE_URL: jdbc:postgresql://<POSTGRES_HOST>:5432/dictionary
  SPRING_DATASOURCE_USERNAME: postgres
  SPRING_DATASOURCE_PASSWORD: postgres
  SPRING_REDIS_HOST: <REDIS_HOST>

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-deployment
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ .Release.Name }}
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}
    spec:
      containers:
      - name: {{ .Release.Name }}
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
        imagePullPolicy: {{ .Values.image.pullPolicy }}
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_DATASOURCE_URL
          value: "{{ .Values.env.SPRING_DATASOURCE_URL }}"
        - name: SPRING_DATASOURCE_USERNAME
          value: "{{ .Values.env.SPRING_DATASOURCE_USERNAME }}"
        - name: SPRING_DATASOURCE_PASSWORD
          value: "{{ .Values.env.SPRING_DATASOURCE_PASSWORD }}"
        - name: SPRING_REDIS_HOST
          value: "{{ .Values.env.SPRING_REDIS_HOST }}"

apiVersion: v1
kind: Service
metadata:
  name: {{ .Release.Name }}-service
spec:
  type: {{ .Values.service.type }}
  selector:
    app: {{ .Release.Name }}
  ports:
    - protocol: TCP
      port: {{ .Values.service.port }}
      targetPort: 8080

name: CI/CD Pipeline

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Set up JDK
      uses: actions/setup-java@v3
      with:
        distribution: 'temurin'
        java-version: '17'

    - name: Build JAR
      run: ./mvnw package -DskipTests

    - name: Set up Docker
      uses: docker/setup-buildx-action@v3

    - name: Authenticate to GCP
      uses: google-github-actions/auth@v2
      with:
        credentials_json: ${{ secrets.GCP_SA_KEY }}

    - name: Configure Docker to use gcloud
      run: gcloud auth configure-docker

    - name: Build & push Docker image
      run: |
        docker build -t gcr.io/$GCP_PROJECT_ID/dictionary-app:latest .
        docker push gcr.io/$GCP_PROJECT_ID/dictionary-app:latest        
      env:
        GCP_PROJECT_ID: ${{ secrets.GCP_PROJECT_ID }}

    - name: Set up kubectl
      uses: azure/setup-kubectl@v3

    - name: Set up Helm
      uses: azure/setup-helm@v3

    - name: Deploy with Helm
      run: |
        helm upgrade --install dictionary ./helm/dictionary \
          --set image.repository=gcr.io/$GCP_PROJECT_ID/dictionary-app \
          --set image.tag=latest        
      env:
        GCP_PROJECT_ID: ${{ secrets.GCP_PROJECT_ID }}

infra/
 ├── main.tf
 ├── variables.tf
 ├── outputs.tf
 ├── versions.tf

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "~> 5.0"
    }
  }
  required_version = ">= 1.3"
}

provider "google" {
  project = var.project_id
  region  = var.region
}

# GKE Cluster
resource "google_container_cluster" "primary" {
  name     = var.gke_cluster_name
  location = var.region

  remove_default_node_pool = true

  initial_node_count = 1
}

resource "google_container_node_pool" "primary_nodes" {
  name       = "primary-node-pool"
  location   = var.region
  cluster    = google_container_cluster.primary.name

  node_config {
    machine_type = "e2-medium"
    oauth_scopes = [
      "https://www.googleapis.com/auth/cloud-platform",
    ]
  }

  initial_node_count = 3
}

# Cloud SQL (Postgres)
resource "google_sql_database_instance" "postgres" {
  name             = var.db_instance_name
  database_version = "POSTGRES_15"
  region           = var.region

  settings {
    tier = "db-f1-micro"
    backup_configuration {
      enabled = true
    }
  }
}

resource "google_sql_user" "postgres_user" {
  name     = "postgres"
  instance = google_sql_database_instance.postgres.name
  password = "change-me-strong"
}

# Memorystore (Redis)
resource "google_redis_instance" "redis" {
  name           = var.redis_instance_name
  tier           = "STANDARD_HA"
  memory_size_gb = 1
  region         = var.region
}

output "gke_endpoint" {
  value = google_container_cluster.primary.endpoint
}

output "db_instance_connection_name" {
  value = google_sql_database_instance.postgres.connection_name
}

output "redis_host" {
  value = google_redis_instance.redis.host
}

output "redis_port" {
  value = google_redis_instance.redis.port
}

apiVersion: v1
kind: Secret
metadata:
  name: dictionary-secrets
type: Opaque
data:
  POSTGRES_USER: cG9zdGdyZXM= # base64(postgres)
  POSTGRES_PASSWORD: Y2hhbmdlLW1lLXN0cm9uZw== # base64(change-me-strong)
  REDIS_HOST: cmVkaXMuaG9zdA== # base64(your Redis host)

env:
  - name: SPRING_DATASOURCE_USERNAME
    valueFrom:
      secretKeyRef:
        name: dictionary-secrets
        key: POSTGRES_USER

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo add grafana https://grafana.github.io/helm-charts
helm repo update

helm install prometheus prometheus-community/prometheus
helm install grafana grafana/grafana

management:
  endpoints:
    web:
      exposure:
        include: prometheus