sprygen 1.0.0

package/templates/entity/EntityControllerTest.java.ejs

@@ -0,0 +1,24 @@
+package <%= packageName %>.controller;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.web.servlet.MockMvc;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class <%= entityName %>ControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @Test
+    void testGetAll() throws Exception {
+        mockMvc.perform(get("/api/v1/<%= entityNameLower %>s"))
+                .andExpect(status().isOk());
+    }
+}

package/templates/entity/EntityDto.java.ejs

@@ -0,0 +1,32 @@
+package <%= packageName %>.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+<%_ 
+  const hasLocalDate = fields.some(f => f.type === 'LocalDate');
+  const hasLocalDateTime = fields.some(f => f.type === 'LocalDateTime');
+
+  if (hasLocalDate) { _%>
+import java.time.LocalDate;
+<%_ }
+  if (hasLocalDateTime) { _%>
+import java.time.LocalDateTime;
+<%_ } _%>
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class <%= entityName %>Dto {
+
+    private Long id;
+
+<%_ for (let i = 0; i < fields.length; i++) { 
+        let field = fields[i]; _%>
+    private <%= field.type %> <%= field.name %>;
+
+<%_ } _%>
+}

package/templates/entity/EntityRepository.java.ejs

@@ -0,0 +1,9 @@
+package <%= packageName %>.repository;
+
+import <%= packageName %>.entity.<%= entityName %>;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface <%= entityName %>Repository extends JpaRepository<<%= entityName %>, Long> {
+}

package/templates/entity/EntityService.java.ejs

@@ -0,0 +1,32 @@
+package <%= packageName %>.service;
+
+import <%= packageName %>.entity.<%= entityName %>;
+import <%= packageName %>.repository.<%= entityName %>Repository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class <%= entityName %>Service {
+
+    private final <%= entityName %>Repository repository;
+
+    public List<<%= entityName %>> findAll() {
+        return repository.findAll();
+    }
+
+    public Optional<<%= entityName %>> findById(Long id) {
+        return repository.findById(id);
+    }
+
+    public <%= entityName %> save(<%= entityName %> entity) {
+        return repository.save(entity);
+    }
+
+    public void deleteById(Long id) {
+        repository.deleteById(id);
+    }
+}

package/templates/project/java/config/CorsConfig.java.ejs

@@ -0,0 +1,24 @@
+package <%= packageName %>.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class CorsConfig {
+
+    @Bean
+    public WebMvcConfigurer corsConfigurer() {
+        return new WebMvcConfigurer() {
+            @Override
+            public void addCorsMappings(CorsRegistry registry) {
+                registry.addMapping("/**")
+                        .allowedOrigins("*") // In production, restrict this to specific domains
+                        .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH")
+                        .allowedHeaders("*")
+                        .maxAge(3600);
+            }
+        };
+    }
+}

package/templates/project/java/config/SecurityConfig.java.ejs

@@ -0,0 +1,76 @@
+package <%= packageName %>.config;
+
+import <%= packageName %>.security.JwtAuthFilter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.AuthenticationProvider;
+import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
+import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+@Configuration
+@EnableWebSecurity
+@EnableMethodSecurity
+@RequiredArgsConstructor
+public class SecurityConfig {
+
+    private final JwtAuthFilter jwtAuthFilter;
+    private final UserDetailsService userDetailsService;
+
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        http
+            .csrf(AbstractHttpConfigurer::disable)
+            .authorizeHttpRequests(authorize -> authorize
+                // Public auth endpoints
+                .requestMatchers("/api/v1/auth/**").permitAll()
+                // Public home / static assets (individual pages + assets)
+                .requestMatchers("/", "/index.html", "/login.html", "/register.html").permitAll()
+                .requestMatchers("/dashboard.html", "/profile.html", "/admin.html").permitAll()
+                .requestMatchers("/assets/**", "/css/**", "/js/**", "/favicon.ico").permitAll()
+                <%_ if (hasSwagger) { _%>
+                .requestMatchers("/v3/api-docs/**", "/swagger-ui/**", "/swagger-ui.html").permitAll()
+                <%_ } _%>
+                .requestMatchers("/actuator/**").permitAll()
+                // Admin endpoints — ROLE_ADMIN enforced via @PreAuthorize too
+                .requestMatchers("/api/v1/admin/**").hasAuthority("ROLE_ADMIN")
+                .anyRequest().authenticated()
+            )
+            .sessionManagement(session -> session
+                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
+            )
+            .authenticationProvider(authenticationProvider())
+            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);
+
+        return http.build();
+    }
+
+    @Bean
+    public AuthenticationProvider authenticationProvider() {
+        // Spring Security 6.x: UserDetailsService must be passed to the constructor
+        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider(userDetailsService);
+        authProvider.setPasswordEncoder(passwordEncoder());
+        return authProvider;
+    }
+
+    @Bean
+    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
+        return config.getAuthenticationManager();
+    }
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+}

package/templates/project/java/config/SecurityConfigSession.java.ejs

@@ -0,0 +1,73 @@
+package <%= packageName %>.config;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.AuthenticationProvider;
+import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
+import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.SecurityFilterChain;
+
+@Configuration
+@EnableWebSecurity
+@EnableMethodSecurity
+@RequiredArgsConstructor
+public class SecurityConfig {
+
+    private final UserDetailsService userDetailsService;
+
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .requestMatchers("/", "/login", "/register", "/css/**", "/js/**", "/assets/**", "/favicon.ico").permitAll()
+                <%_ if (hasSwagger) { _%>
+                .requestMatchers("/v3/api-docs/**", "/swagger-ui/**", "/swagger-ui.html").permitAll()
+                <%_ } _%>
+                .requestMatchers("/actuator/**").permitAll()
+                .requestMatchers("/admin/**").hasAuthority("ROLE_ADMIN")
+                .anyRequest().authenticated()
+            )
+            .formLogin(form -> form
+                .loginPage("/login")
+                .loginProcessingUrl("/login")
+                .defaultSuccessUrl("/dashboard", true)
+                .failureUrl("/login?error=true")
+                .permitAll()
+            )
+            .logout(logout -> logout
+                .logoutUrl("/logout")
+                .logoutSuccessUrl("/")
+                .invalidateHttpSession(true)
+                .deleteCookies("JSESSIONID")
+                .permitAll()
+            )
+            .authenticationProvider(authenticationProvider());
+
+        return http.build();
+    }
+
+    @Bean
+    public AuthenticationProvider authenticationProvider() {
+        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider(userDetailsService);
+        authProvider.setPasswordEncoder(passwordEncoder());
+        return authProvider;
+    }
+
+    @Bean
+    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
+        return config.getAuthenticationManager();
+    }
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+}

package/templates/project/java/config/SwaggerConfig.java.ejs

@@ -0,0 +1,31 @@
+package <%= packageName %>.config;
+
+import io.swagger.v3.oas.models.Components;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Info;
+import io.swagger.v3.oas.models.security.SecurityRequirement;
+import io.swagger.v3.oas.models.security.SecurityScheme;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class SwaggerConfig {
+
+    @Bean
+    public OpenAPI customOpenAPI() {
+        final String securitySchemeName = "bearerAuth";
+        return new OpenAPI()
+                .info(new Info().title("<%= projectName %> API").version("1.0.0").description("<%= description %>"))
+                .addSecurityItem(new SecurityRequirement().addList(securitySchemeName))
+                .components(
+                    new Components()
+                        .addSecuritySchemes(securitySchemeName,
+                            new SecurityScheme()
+                                .name(securitySchemeName)
+                                .type(SecurityScheme.Type.HTTP)
+                                .scheme("bearer")
+                                .bearerFormat("JWT")
+                        )
+                );
+    }
+}

package/templates/project/java/controller/AdminController.java.ejs

@@ -0,0 +1,82 @@
+package <%= packageName %>.controller;
+
+import <%= packageName %>.entity.Role;
+import <%= packageName %>.entity.User;
+import <%= packageName %>.repository.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RestController
+@RequestMapping("/api/v1/admin")
+@RequiredArgsConstructor
+@PreAuthorize("hasAuthority('ROLE_ADMIN')")
+public class AdminController {
+
+    private final UserRepository userRepository;
+
+    /** GET /api/v1/admin/users — list all users */
+    @GetMapping("/users")
+    public ResponseEntity<List<User>> listUsers() {
+        return ResponseEntity.ok(userRepository.findAll());
+    }
+
+    /** GET /api/v1/admin/users/{id} — get single user */
+    @GetMapping("/users/{id}")
+    public ResponseEntity<User> getUser(@PathVariable Long id) {
+        return userRepository.findById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    /** PUT /api/v1/admin/users/{id}/role — assign role */
+    @PutMapping("/users/{id}/role")
+    public ResponseEntity<Map<String, String>> assignRole(
+            @PathVariable Long id,
+            @RequestBody Map<String, String> body) {
+
+        String roleName = body.get("role");
+        Role role;
+        try {
+            role = Role.valueOf(roleName);
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.badRequest()
+                    .body(Map.of("error", "Invalid role: " + roleName + ". Use ROLE_USER or ROLE_ADMIN"));
+        }
+
+        return userRepository.findById(id).map(user -> {
+            user.setRoles(Set.of(role));
+            userRepository.save(user);
+            return ResponseEntity.ok(Map.of("message", "Role updated to " + roleName));
+        }).orElse(ResponseEntity.notFound().build());
+    }
+
+    /** DELETE /api/v1/admin/users/{id} — delete user */
+    @DeleteMapping("/users/{id}")
+    public ResponseEntity<Map<String, String>> deleteUser(@PathVariable Long id) {
+        if (!userRepository.existsById(id)) {
+            return ResponseEntity.notFound().build();
+        }
+        userRepository.deleteById(id);
+        return ResponseEntity.ok(Map.of("message", "User deleted"));
+    }
+
+    /** GET /api/v1/admin/stats — quick dashboard stats */
+    @GetMapping("/stats")
+    public ResponseEntity<Map<String, Long>> stats() {
+        long total = userRepository.count();
+        long admins = userRepository.findAll().stream()
+                .filter(User::isAdmin)
+                .count();
+        return ResponseEntity.ok(Map.of(
+                "totalUsers", total,
+                "admins", admins,
+                "regularUsers", total - admins
+        ));
+    }
+}

package/templates/project/java/controller/AuthController.java.ejs

@@ -0,0 +1,86 @@
+package <%= packageName %>.controller;
+
+import <%= packageName %>.dto.AuthRequest;
+import <%= packageName %>.dto.AuthResponse;
+import <%= packageName %>.dto.RegisterRequest;
+import <%= packageName %>.entity.Role;
+import <%= packageName %>.entity.User;
+import <%= packageName %>.repository.UserRepository;
+import <%= packageName %>.service.JwtService;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashSet;
+import java.util.Set;
+
+@RestController
+@RequestMapping("/api/v1/auth")
+@RequiredArgsConstructor
+public class AuthController {
+
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+    private final JwtService jwtService;
+    private final AuthenticationManager authenticationManager;
+
+    @PostMapping("/register")
+    public ResponseEntity<AuthResponse> register(@Valid @RequestBody RegisterRequest request) {
+        if (userRepository.existsByEmail(request.getEmail())) {
+            return ResponseEntity.badRequest().build();
+        }
+
+        // First registered user becomes ADMIN, everyone else is USER
+        boolean isFirstUser = userRepository.count() == 0;
+        Set<Role> roles = isFirstUser
+                ? new HashSet<>(Set.of(Role.ROLE_ADMIN, Role.ROLE_USER))
+                : new HashSet<>(Set.of(Role.ROLE_USER));
+
+        var user = User.builder()
+                .firstName(request.getFirstName())
+                .lastName(request.getLastName())
+                .email(request.getEmail())
+                .password(passwordEncoder.encode(request.getPassword()))
+                .roles(roles)
+                .build();
+
+        userRepository.save(user);
+        var jwtToken = jwtService.generateToken(user);
+
+        return ResponseEntity.ok(AuthResponse.builder()
+                .token(jwtToken)
+                .email(user.getEmail())
+                .firstName(user.getFirstName())
+                .lastName(user.getLastName())
+                .role(isFirstUser ? "ROLE_ADMIN" : "ROLE_USER")
+                .build());
+    }
+
+    @PostMapping("/login")
+    public ResponseEntity<AuthResponse> login(@Valid @RequestBody AuthRequest request) {
+        authenticationManager.authenticate(
+                new UsernamePasswordAuthenticationToken(
+                        request.getEmail(),
+                        request.getPassword()
+                )
+        );
+
+        var user = userRepository.findByEmail(request.getEmail())
+                .orElseThrow();
+
+        var jwtToken = jwtService.generateToken(user);
+        String primaryRole = user.isAdmin() ? "ROLE_ADMIN" : "ROLE_USER";
+
+        return ResponseEntity.ok(AuthResponse.builder()
+                .token(jwtToken)
+                .email(user.getEmail())
+                .firstName(user.getFirstName())
+                .lastName(user.getLastName())
+                .role(primaryRole)
+                .build());
+    }
+}

package/templates/project/java/controller/HomeController.java.ejs

@@ -0,0 +1,63 @@
+package <%= packageName %>.controller;
+
+import lombok.RequiredArgsConstructor;
+<%_ if (isFullstack && isJwtAuth) { _%>
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+
+@Controller
+@RequiredArgsConstructor
+public class HomeController {
+
+    /** Serve the landing page */
+    @GetMapping("/")
+    public String home() {
+        return "forward:/index.html";
+    }
+
+    /** Each page is standalone — just permit static file serving */
+    @GetMapping({"/login", "/register"})
+    public String authPages() {
+        return "forward:/index.html";
+    }
+}
+<%_ } else if (isFullstack && isSessionAuth) { _%>
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+
+@Controller
+@RequiredArgsConstructor
+public class HomeController {
+
+    @GetMapping("/")
+    public String home() {
+        return "redirect:/dashboard";
+    }
+}
+<%_ } else { _%>
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.time.LocalDateTime;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+@RestController
+@RequiredArgsConstructor
+public class HomeController {
+
+    @GetMapping("/")
+    public ResponseEntity<Map<String, Object>> home() {
+        Map<String, Object> info = new LinkedHashMap<>();
+        info.put("status",  "UP");
+        info.put("app",     "<%= projectName %>");
+        info.put("version", "1.0.0");
+        info.put("auth",    "JWT");
+        info.put("docs",    "/swagger-ui/index.html");
+        info.put("health",  "/actuator/health");
+        info.put("time",    LocalDateTime.now().toString());
+        return ResponseEntity.ok(info);
+    }
+}
+<%_ } _%>

package/templates/project/java/controller/ProfileController.java.ejs

@@ -0,0 +1,65 @@
+package <%= packageName %>.controller;
+
+import <%= packageName %>.dto.ProfileUpdateRequest;
+import <%= packageName %>.entity.User;
+import <%= packageName %>.repository.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/v1/profile")
+@RequiredArgsConstructor
+@PreAuthorize("isAuthenticated()")
+public class ProfileController {
+
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    /** GET /api/v1/profile — get own profile */
+    @GetMapping
+    public ResponseEntity<User> getProfile(@AuthenticationPrincipal User user) {
+        return ResponseEntity.ok(user);
+    }
+
+    /** PUT /api/v1/profile — update name, bio, avatarUrl */
+    @PutMapping
+    public ResponseEntity<User> updateProfile(
+            @AuthenticationPrincipal User user,
+            @RequestBody ProfileUpdateRequest request) {
+
+        if (request.getFirstName() != null) user.setFirstName(request.getFirstName());
+        if (request.getLastName()  != null) user.setLastName(request.getLastName());
+        if (request.getBio()       != null) user.setBio(request.getBio());
+        if (request.getAvatarUrl() != null) user.setAvatarUrl(request.getAvatarUrl());
+
+        userRepository.save(user);
+        return ResponseEntity.ok(user);
+    }
+
+    /** PUT /api/v1/profile/password — change own password */
+    @PutMapping("/password")
+    public ResponseEntity<Map<String, String>> changePassword(
+            @AuthenticationPrincipal User user,
+            @RequestBody ProfileUpdateRequest request) {
+
+        if (request.getCurrentPassword() == null || request.getNewPassword() == null) {
+            return ResponseEntity.badRequest()
+                    .body(Map.of("error", "currentPassword and newPassword are required"));
+        }
+
+        if (!passwordEncoder.matches(request.getCurrentPassword(), user.getPassword())) {
+            return ResponseEntity.status(403)
+                    .body(Map.of("error", "Current password is incorrect"));
+        }
+
+        user.setPassword(passwordEncoder.encode(request.getNewPassword()));
+        userRepository.save(user);
+        return ResponseEntity.ok(Map.of("message", "Password updated successfully"));
+    }
+}

package/templates/project/java/controller/UserController.java.ejs

@@ -0,0 +1,35 @@
+package <%= packageName %>.controller;
+
+import <%= packageName %>.entity.User;
+import <%= packageName %>.service.UserService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/v1/users")
+@RequiredArgsConstructor
+public class UserController {
+
+    private final UserService userService;
+
+    @GetMapping
+    public ResponseEntity<List<User>> getAllUsers() {
+        return ResponseEntity.ok(userService.getAllUsers());
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<User> getUserById(@PathVariable Long id) {
+        return userService.getUserById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
+        userService.deleteUser(id);
+        return ResponseEntity.noContent().build();
+    }
+}

package/templates/project/java/dto/AuthRequest.java.ejs

@@ -0,0 +1,15 @@
+package <%= packageName %>.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class AuthRequest {
+    private String email;
+    private String password;
+}

package/templates/project/java/dto/AuthResponse.java.ejs

@@ -0,0 +1,18 @@
+package <%= packageName %>.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class AuthResponse {
+    private String token;
+    private String email;
+    private String firstName;
+    private String lastName;
+    private String role;
+}