@yosr-ai/template-spring 0.0.0-stage → 0.2.6

package/features/data-jpa/files/pom.xml

@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-parent</artifactId>
+    <version>4.1.2</version>
+    <relativePath />
+  </parent>
+
+  <groupId>com.yosr</groupId>
+  <artifactId>app</artifactId>
+  <version>0.0.1-SNAPSHOT</version>
+  <name>__seed_projectName__</name>
+  <description>Yosr Seed Spring Boot API (__seed_projectName__)</description>
+
+  <properties>
+    <java.version>25</java.version>
+    <dependency-lock-maven-plugin.version>1.4.0</dependency-lock-maven-plugin.version>
+    <spotless-maven-plugin.version>3.11.0</spotless-maven-plugin.version>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-data-jpa</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.postgresql</groupId>
+      <artifactId>postgresql</artifactId>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-test</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <finalName>app</finalName>
+    <plugins>
+      <plugin>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <compilerArgs>
+            <arg>-Werror</arg>
+          </compilerArgs>
+          <showWarnings>true</showWarnings>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>com.diffplug.spotless</groupId>
+        <artifactId>spotless-maven-plugin</artifactId>
+        <version>${spotless-maven-plugin.version}</version>
+        <configuration>
+          <java>
+            <googleJavaFormat>
+              <version>1.36.1</version>
+            </googleJavaFormat>
+          </java>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>se.vandmo</groupId>
+        <artifactId>dependency-lock-maven-plugin</artifactId>
+        <version>${dependency-lock-maven-plugin.version}</version>
+        <configuration>
+          <lockFile>dependencies-lock.json</lockFile>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>

package/features/data-jpa/files/src/main/java/com/yosr/app/core/AppConfig.java

@@ -0,0 +1,34 @@
+package com.yosr.app.core;
+
+import com.yosr.app.features.notes.JpaNoteStore;
+import com.yosr.app.features.notes.NoteRepository;
+import com.yosr.app.features.notes.NoteStore;
+import com.yosr.app.features.notes.NotesService;
+import com.zaxxer.hikari.HikariDataSource;
+import javax.sql.DataSource;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class AppConfig {
+  // @seed:anchor bean-registration
+  @Bean
+  DataSource dataSource(AppSettings settings) {
+    DataSourceUrl parsed = DataSourceUrl.fromDatabaseUrl(settings.databaseUrl());
+    HikariDataSource dataSource = new HikariDataSource();
+    dataSource.setJdbcUrl(parsed.jdbcUrl());
+    dataSource.setUsername(parsed.username());
+    dataSource.setPassword(parsed.password());
+    return dataSource;
+  }
+
+  @Bean
+  NoteStore noteStore(NoteRepository repository) {
+    return new JpaNoteStore(repository);
+  }
+
+  @Bean
+  NotesService notesService(NoteStore store) {
+    return new NotesService(store);
+  }
+}

package/features/data-jpa/files/src/main/java/com/yosr/app/core/AppSettings.java

@@ -0,0 +1,40 @@
+package com.yosr.app.core;
+
+import java.util.Arrays;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+@Component
+public class AppSettings {
+  private final String appName;
+  private final List<String> corsOrigins;
+  private final String databaseUrl;
+
+  // @seed:anchor settings-fields
+  public AppSettings(
+      @Value("${app.name}") String appName,
+      @Value("${app.cors-origins}") String corsOriginsRaw,
+      @Value("${app.database-url}") String databaseUrl) {
+    this.appName = appName;
+    this.corsOrigins =
+        Arrays.stream(corsOriginsRaw.split(","))
+            .map(String::trim)
+            .filter(part -> !part.isEmpty())
+            .toList();
+    this.databaseUrl = databaseUrl;
+    // @seed:anchor settings-values
+  }
+
+  public String appName() {
+    return appName;
+  }
+
+  public List<String> corsOrigins() {
+    return corsOrigins;
+  }
+
+  public String databaseUrl() {
+    return databaseUrl;
+  }
+}

package/features/data-jpa/files/src/main/java/com/yosr/app/core/DataSourceUrl.java

@@ -0,0 +1,33 @@
+package com.yosr.app.core;
+
+import java.net.URI;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+
+public record DataSourceUrl(String jdbcUrl, String username, String password) {
+
+  public static DataSourceUrl fromDatabaseUrl(String databaseUrl) {
+    if (databaseUrl.startsWith("postgresql://") || databaseUrl.startsWith("postgres://")) {
+      URI uri = URI.create(databaseUrl);
+      String username = "";
+      String password = "";
+      String userInfo = uri.getUserInfo();
+      if (userInfo != null && userInfo.contains(":")) {
+        String[] parts = userInfo.split(":", 2);
+        username = decode(parts[0]);
+        password = decode(parts[1]);
+      } else if (userInfo != null) {
+        username = decode(userInfo);
+      }
+      String db = uri.getPath() == null ? "" : uri.getPath().replaceFirst("^/", "");
+      int port = uri.getPort() > 0 ? uri.getPort() : 5432;
+      String jdbc = "jdbc:postgresql://" + uri.getHost() + ":" + port + "/" + db;
+      return new DataSourceUrl(jdbc, username, password);
+    }
+    return new DataSourceUrl(databaseUrl, "", "");
+  }
+
+  private static String decode(String value) {
+    return URLDecoder.decode(value, StandardCharsets.UTF_8);
+  }
+}

package/features/data-jpa/files/src/main/java/com/yosr/app/features/notes/JpaNoteStore.java

@@ -0,0 +1,59 @@
+package com.yosr.app.features.notes;
+
+import java.time.OffsetDateTime;
+import java.util.List;
+import java.util.Optional;
+import org.springframework.transaction.annotation.Transactional;
+
+public class JpaNoteStore implements NoteStore {
+
+  private final NoteRepository repository;
+
+  public JpaNoteStore(NoteRepository repository) {
+    this.repository = repository;
+  }
+
+  @Override
+  @Transactional(readOnly = true)
+  public List<Note> list() {
+    return repository.findAll().stream()
+        .sorted((a, b) -> Integer.compare(b.getId(), a.getId()))
+        .map(NoteEntity::toNote)
+        .toList();
+  }
+
+  @Override
+  @Transactional(readOnly = true)
+  public Optional<Note> get(int id) {
+    return repository.findById(id).map(NoteEntity::toNote);
+  }
+
+  @Override
+  @Transactional
+  public Note add(String title, String body) {
+    NoteEntity row = new NoteEntity();
+    row.setTitle(title);
+    row.setBody(body);
+    row.setCreatedAt(OffsetDateTime.now());
+    NoteEntity saved = repository.save(row);
+    return saved.toNote();
+  }
+
+  @Override
+  @Transactional
+  public Optional<Note> update(int id, String title, String body) {
+    return repository
+        .findById(id)
+        .map(
+            row -> {
+              if (title != null) {
+                row.setTitle(title);
+              }
+              if (body != null) {
+                row.setBody(body);
+              }
+              row.setUpdatedAt(OffsetDateTime.now());
+              return repository.save(row).toNote();
+            });
+  }
+}

package/features/data-jpa/files/src/main/java/com/yosr/app/features/notes/NoteEntity.java

@@ -0,0 +1,68 @@
+package com.yosr.app.features.notes;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import java.time.OffsetDateTime;
+
+@Entity
+@Table(name = "notes")
+public class NoteEntity {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private int id;
+
+  @Column(nullable = false, length = 200)
+  private String title;
+
+  private String body;
+
+  @Column(nullable = false)
+  private OffsetDateTime createdAt;
+
+  private OffsetDateTime updatedAt;
+
+  public int getId() {
+    return id;
+  }
+
+  public String getTitle() {
+    return title;
+  }
+
+  public void setTitle(String title) {
+    this.title = title;
+  }
+
+  public String getBody() {
+    return body;
+  }
+
+  public void setBody(String body) {
+    this.body = body;
+  }
+
+  public OffsetDateTime getCreatedAt() {
+    return createdAt;
+  }
+
+  public void setCreatedAt(OffsetDateTime createdAt) {
+    this.createdAt = createdAt;
+  }
+
+  public OffsetDateTime getUpdatedAt() {
+    return updatedAt;
+  }
+
+  public void setUpdatedAt(OffsetDateTime updatedAt) {
+    this.updatedAt = updatedAt;
+  }
+
+  Note toNote() {
+    return new Note(id, title, body, createdAt, updatedAt);
+  }
+}

package/features/data-jpa/files/src/main/java/com/yosr/app/features/notes/NoteRepository.java

@@ -0,0 +1,5 @@
+package com.yosr.app.features.notes;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface NoteRepository extends JpaRepository<NoteEntity, Integer> {}

package/features/data-jpa/files/src/main/resources/application.yml

@@ -0,0 +1,14 @@
+server:
+  port: 8080
+
+app:
+  name: ${APP_NAME:__seed_projectName__}
+  cors-origins: ${CORS_ORIGINS:http://localhost:5173}
+  database-url: ${DATABASE_URL:__seed_databaseUrl__}
+
+spring:
+  jpa:
+    hibernate:
+      ddl-auto: validate
+    open-in-view: false
+# @seed:anchor application-config

package/features/data-jpa/files/src/test/java/com/yosr/app/JpaTestConfig.java

@@ -0,0 +1,7 @@
+package com.yosr.app;
+
+import org.springframework.boot.test.context.TestConfiguration;
+
+/** Marker import for JPA integration tests (properties come from NotesApiTest). */
+@TestConfiguration
+public class JpaTestConfig {}

package/features/data-jpa/files/src/test/java/com/yosr/app/NotesApiTest.java

@@ -0,0 +1,119 @@
+package com.yosr.app;
+
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.MvcResult;
+import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import org.springframework.web.context.WebApplicationContext;
+import tools.jackson.databind.JsonNode;
+import tools.jackson.databind.ObjectMapper;
+
+// @seed:anchor test-class-annotations
+@SpringBootTest
+@Import(JpaTestConfig.class)
+class NotesApiTest {
+
+  @DynamicPropertySource
+  static void datasource(DynamicPropertyRegistry registry) {
+    String databaseUrl = System.getenv("DATABASE_URL");
+    if (databaseUrl != null && !databaseUrl.isBlank()) {
+      registry.add("app.database-url", () -> databaseUrl);
+    } else {
+      registry.add(
+          "app.database-url",
+          () -> "jdbc:h2:mem:yosr-tests-" + System.nanoTime() + ";DB_CLOSE_DELAY=-1");
+    }
+    registry.add("spring.jpa.hibernate.ddl-auto", () -> "create-drop");
+  }
+
+  @Autowired private WebApplicationContext context;
+
+  @Autowired private ObjectMapper objectMapper;
+
+  private MockMvc mockMvc;
+
+  // @seed:anchor test-client-headers
+  @BeforeEach
+  void resetHeaders() {
+    mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
+    // @seed:anchor test-setup
+  }
+
+  private MockHttpServletRequestBuilder forNotes(MockHttpServletRequestBuilder builder) {
+    // @seed:anchor notes-request-wrap
+    return builder;
+  }
+
+  @Test
+  void healthIsOk() throws Exception {
+    mockMvc
+        .perform(get("/health"))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.status", is("ok")));
+  }
+
+  @Test
+  void createListGetAndUpdateANote() throws Exception {
+    MvcResult created =
+        mockMvc
+            .perform(
+                forNotes(post("/notes"))
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content("{\"title\":\"Hello\",\"body\":\"World\"}"))
+            .andExpect(status().isCreated())
+            .andReturn();
+
+    JsonNode note = objectMapper.readTree(created.getResponse().getContentAsByteArray());
+    int id = note.get("id").asInt();
+
+    mockMvc
+        .perform(forNotes(get("/notes")))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$", hasSize(1)));
+
+    mockMvc
+        .perform(forNotes(get("/notes/" + id)))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.title", is("Hello")));
+
+    mockMvc
+        .perform(
+            forNotes(patch("/notes/" + id))
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("{\"title\":\"Hi\"}"))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.title", is("Hi")))
+        .andExpect(jsonPath("$.body", is("World")));
+  }
+
+  @Test
+  void missingNoteIs404() throws Exception {
+    mockMvc.perform(forNotes(get("/notes/999"))).andExpect(status().isNotFound());
+  }
+
+  @Test
+  void blankTitleIsRejected() throws Exception {
+    mockMvc
+        .perform(
+            forNotes(post("/notes"))
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("{\"title\":\"  \",\"body\":\"x\"}"))
+        .andExpect(status().isBadRequest());
+  }
+}

package/features/data-jpa/snippets/readme-db.md

@@ -0,0 +1,3 @@
+## Database
+
+Postgres through Spring Data JPA. Set `DATABASE_URL` (see `.env.example`). Tests use `ddl-auto=create-drop` against a throwaway database; apply real migrations yourself when you add them — the Yosr Seed gate does not run Flyway or Liquibase.

package/features/deploy-docker/files/.dockerignore

@@ -0,0 +1,5 @@
+target/
+.idea/
+.git/
+.env
+*.iml

package/features/deploy-docker/files/Dockerfile

@@ -0,0 +1,20 @@
+# Build
+FROM eclipse-temurin:25-jdk AS build
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends maven \
+  && rm -rf /var/lib/apt/lists/*
+WORKDIR /src
+COPY pom.xml dependencies-lock.json ./
+RUN mvn -B -q dependency:resolve dependency-lock:check
+COPY src ./src
+RUN mvn -B -q package -DskipTests
+
+# Runtime
+FROM eclipse-temurin:25-jre AS final
+WORKDIR /app
+RUN groupadd --system app && useradd --system --gid app --create-home app
+COPY --from=build /src/target/app.jar ./app.jar
+USER app
+ENV JAVA_TOOL_OPTIONS=
+EXPOSE 8080
+ENTRYPOINT ["java", "-jar", "app.jar"]

package/features/deploy-docker/files/compose.yaml

@@ -0,0 +1,12 @@
+# @seed:anchor compose-header
+services:
+  app:
+    build: .
+    ports:
+      - "8080:8080"
+    environment:
+      APP_NAME: __seed_projectName__
+      # @seed:anchor app-env
+    # @seed:anchor app-config
+  # @seed:anchor services
+# @seed:anchor compose-volumes

package/features/deploy-docker/snippets/readme-docker.md

@@ -0,0 +1,3 @@
+## Docker
+
+Multi-stage image: `eclipse-temurin:25-jdk` build → `eclipse-temurin:25-jre`, non-root user. `docker compose up --build` starts the API on port 8080.

package/features/deploy-docker-postgres/snippets/app-config.yaml

@@ -0,0 +1,3 @@
+    depends_on:
+      db:
+        condition: service_healthy

package/features/deploy-docker-postgres/snippets/app-env.yaml

@@ -0,0 +1 @@
+      DATABASE_URL: postgresql://postgres:postgres@db:5432/postgres

package/features/deploy-docker-postgres/snippets/compose-header.yaml

@@ -0,0 +1 @@
+name: __seed_projectName__

package/features/deploy-docker-postgres/snippets/compose-volumes.yaml

@@ -0,0 +1,3 @@
+
+volumes:
+  pgdata:

package/features/deploy-docker-postgres/snippets/postgres-service.yaml

@@ -0,0 +1,13 @@
+db:
+    image: postgres:18.6-alpine
+    environment:
+      POSTGRES_PASSWORD: postgres
+    ports:
+      - "5432:5432"
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 10

package/features/deploy-docker-postgres/snippets/readme-docker.md

@@ -0,0 +1,3 @@
+## Compose + Postgres
+
+When `database=postgres`, Compose starts Postgres 18 and sets `DATABASE_URL` for the app service.

package/features/errors-result/files/src/main/java/com/yosr/app/features/notes/NotesController.java

@@ -0,0 +1,64 @@
+package com.yosr.app.features.notes;
+
+import com.yosr.app.features.notes.NoteDtos.NoteCreate;
+import com.yosr.app.features.notes.NoteDtos.NoteResponse;
+import com.yosr.app.features.notes.NoteDtos.NoteUpdate;
+import com.yosr.app.shared.Result;
+import java.net.URI;
+import java.util.List;
+import java.util.Map;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PatchMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/notes")
+public class NotesController {
+  private final NotesService notes;
+
+  public NotesController(NotesService notes) {
+    this.notes = notes;
+  }
+
+  // @seed:anchor notes-group
+  @GetMapping
+  public List<NoteResponse> list() {
+    return notes.list().stream().map(NoteResponse::from).toList();
+  }
+
+  @GetMapping("/{id}")
+  public ResponseEntity<?> get(@PathVariable int id) {
+    return switch (notes.get(id)) {
+      case Result.Ok(Note note) -> ResponseEntity.ok(NoteResponse.from(note));
+      case Result.Err(String message) -> ResponseEntity.status(404).body(errorBody(message));
+    };
+  }
+
+  @PostMapping
+  public ResponseEntity<?> create(@RequestBody NoteCreate body) {
+    return switch (notes.create(body)) {
+      case Result.Ok(Note note) ->
+          ResponseEntity.created(URI.create("/notes/" + note.id())).body(NoteResponse.from(note));
+      case Result.Err(String message) -> ResponseEntity.badRequest().body(errorBody(message));
+    };
+  }
+
+  @PatchMapping("/{id}")
+  public ResponseEntity<?> update(@PathVariable int id, @RequestBody NoteUpdate body) {
+    return switch (notes.update(id, body)) {
+      case Result.Ok(Note note) -> ResponseEntity.ok(NoteResponse.from(note));
+      case Result.Err(String message) when message.toLowerCase().contains("not found") ->
+          ResponseEntity.status(404).body(errorBody(message));
+      case Result.Err(String message) -> ResponseEntity.badRequest().body(errorBody(message));
+    };
+  }
+
+  private static Map<String, String> errorBody(String detail) {
+    return Map.of("detail", detail);
+  }
+}