sprygen 1.0.0

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

@@ -0,0 +1,20 @@
+package <%= packageName %>.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class ProfileUpdateRequest {
+    private String firstName;
+    private String lastName;
+    private String bio;
+    private String avatarUrl;
+    /** Optional — only processed if both are supplied */
+    private String currentPassword;
+    private String newPassword;
+}

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

@@ -0,0 +1,30 @@
+package <%= packageName %>.dto;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class RegisterRequest {
+
+    @NotBlank(message = "First name is required")
+    private String firstName;
+
+    @NotBlank(message = "Last name is required")
+    private String lastName;
+
+    @Email(message = "Must be a valid email")
+    @NotBlank(message = "Email is required")
+    private String email;
+
+    @NotBlank(message = "Password is required")
+    @Size(min = 6, message = "Password must be at least 6 characters")
+    private String password;
+}

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

@@ -0,0 +1,17 @@
+package <%= packageName %>.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class UserDto {
+    private Long id;
+    private String firstName;
+    private String lastName;
+    private String email;
+}

package/templates/project/java/entity/Role.java.ejs

@@ -0,0 +1,6 @@
+package <%= packageName %>.entity;
+
+public enum Role {
+    ROLE_USER,
+    ROLE_ADMIN
+}

package/templates/project/java/entity/User.java.ejs

@@ -0,0 +1,97 @@
+package <%= packageName %>.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+
+import java.time.LocalDateTime;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "users")
+public class User implements UserDetails {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String firstName;
+
+    @Column(nullable = false)
+    private String lastName;
+
+    @Column(unique = true, nullable = false)
+    private String email;
+
+    @Column(nullable = false)
+    private String password;
+
+    private String bio;
+
+    private String avatarUrl;
+
+    @Builder.Default
+    @ElementCollection(fetch = FetchType.EAGER)
+    @CollectionTable(name = "user_roles", joinColumns = @JoinColumn(name = "user_id"))
+    @Enumerated(EnumType.STRING)
+    private Set<Role> roles = new HashSet<>(Set.of(Role.ROLE_USER));
+
+    @Column(updatable = false)
+    private LocalDateTime createdAt;
+
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = LocalDateTime.now();
+        updatedAt = LocalDateTime.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = LocalDateTime.now();
+    }
+
+    // --- UserDetails ---
+
+    @Override
+    public Collection<? extends GrantedAuthority> getAuthorities() {
+        return roles.stream()
+                .map(role -> new SimpleGrantedAuthority(role.name()))
+                .collect(Collectors.toSet());
+    }
+
+    @Override
+    public String getUsername() {
+        return email;
+    }
+
+    @Override
+    public boolean isAccountNonExpired() { return true; }
+
+    @Override
+    public boolean isAccountNonLocked() { return true; }
+
+    @Override
+    public boolean isCredentialsNonExpired() { return true; }
+
+    @Override
+    public boolean isEnabled() { return true; }
+
+    public boolean isAdmin() {
+        return roles != null && roles.contains(Role.ROLE_ADMIN);
+    }
+}

package/templates/project/java/repository/UserRepository.java.ejs

@@ -0,0 +1,11 @@
+package <%= packageName %>.repository;
+
+import <%= packageName %>.entity.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface UserRepository extends JpaRepository<User, Long> {
+    Optional<User> findByEmail(String email);
+    boolean existsByEmail(String email);
+}

package/templates/project/java/security/JwtAuthFilter.java.ejs

@@ -0,0 +1,62 @@
+package <%= packageName %>.security;
+
+import <%= packageName %>.service.JwtService;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.lang.NonNull;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+@Component
+@RequiredArgsConstructor
+public class JwtAuthFilter extends OncePerRequestFilter {
+
+    private final JwtService jwtService;
+    private final UserDetailsService userDetailsService;
+
+    @Override
+    protected void doFilterInternal(
+            @NonNull HttpServletRequest request,
+            @NonNull HttpServletResponse response,
+            @NonNull FilterChain filterChain
+    ) throws ServletException, IOException {
+        final String authHeader = request.getHeader("Authorization");
+        final String jwt;
+        final String userEmail;
+
+        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
+            filterChain.doFilter(request, response);
+            return;
+        }
+
+        jwt = authHeader.substring(7);
+        userEmail = jwtService.extractUsername(jwt);
+
+        if (userEmail != null && SecurityContextHolder.getContext().getAuthentication() == null) {
+            UserDetails userDetails = this.userDetailsService.loadUserByUsername(userEmail);
+
+            if (jwtService.isTokenValid(jwt, userDetails)) {
+                UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(
+                        userDetails,
+                        null,
+                        userDetails.getAuthorities()
+                );
+                authToken.setDetails(
+                        new WebAuthenticationDetailsSource().buildDetails(request)
+                );
+                SecurityContextHolder.getContext().setAuthentication(authToken);
+            }
+        }
+        filterChain.doFilter(request, response);
+    }
+}

package/templates/project/java/security/UserDetailsServiceImpl.java.ejs

@@ -0,0 +1,21 @@
+package <%= packageName %>.security;
+
+import <%= packageName %>.repository.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class UserDetailsServiceImpl implements UserDetailsService {
+
+    private final UserRepository userRepository;
+
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+        return userRepository.findByEmail(username)
+                .orElseThrow(() -> new UsernameNotFoundException("User not found with email: " + username));
+    }
+}

package/templates/project/java/service/JwtService.java.ejs

@@ -0,0 +1,81 @@
+package <%= packageName %>.service;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.io.Decoders;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Service;
+
+import java.security.Key;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+@Service
+public class JwtService {
+
+    @Value("${jwt.secret}")
+    private String secretKey;
+
+    @Value("${jwt.expiration}")
+    private long jwtExpiration;
+
+    public String extractUsername(String token) {
+        return extractClaim(token, Claims::getSubject);
+    }
+
+    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
+        final Claims claims = extractAllClaims(token);
+        return claimsResolver.apply(claims);
+    }
+
+    public String generateToken(UserDetails userDetails) {
+        return generateToken(new HashMap<>(), userDetails);
+    }
+
+    public String generateToken(Map<String, Object> extraClaims, UserDetails userDetails) {
+        return buildToken(extraClaims, userDetails, jwtExpiration);
+    }
+
+    private String buildToken(Map<String, Object> extraClaims, UserDetails userDetails, long expiration) {
+        return Jwts
+                .builder()
+                .setClaims(extraClaims)
+                .setSubject(userDetails.getUsername())
+                .setIssuedAt(new Date(System.currentTimeMillis()))
+                .setExpiration(new Date(System.currentTimeMillis() + expiration))
+                .signWith(getSignInKey(), SignatureAlgorithm.HS256)
+                .compact();
+    }
+
+    public boolean isTokenValid(String token, UserDetails userDetails) {
+        final String username = extractUsername(token);
+        return (username.equals(userDetails.getUsername())) && !isTokenExpired(token);
+    }
+
+    private boolean isTokenExpired(String token) {
+        return extractExpiration(token).before(new Date());
+    }
+
+    private Date extractExpiration(String token) {
+        return extractClaim(token, Claims::getExpiration);
+    }
+
+    private Claims extractAllClaims(String token) {
+        return Jwts
+                .parserBuilder()
+                .setSigningKey(getSignInKey())
+                .build()
+                .parseClaimsJws(token)
+                .getBody();
+    }
+
+    private Key getSignInKey() {
+        byte[] keyBytes = Decoders.BASE64.decode(secretKey);
+        return Keys.hmacShaKeyFor(keyBytes);
+    }
+}

package/templates/project/java/service/UserService.java.ejs

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

package/templates/project/resources/application.yml.ejs

@@ -0,0 +1,50 @@
+spring:
+  application:
+    name: <%= projectName %>
+  
+  datasource:
+    url: ${DB_URL:<%= dbConfig.url %>}
+    username: ${DB_USER:<%= dbConfig.username %>}
+    password: ${DB_PASS:<%= dbConfig.password %>}
+    driver-class-name: <%= dbDriverClass %>
+
+  jpa:
+<%_ if (dbConfig.dialect) { _%>
+    database-platform: <%= dbConfig.dialect %>
+<%_ } _%>
+    hibernate:
+      ddl-auto: update
+    show-sql: false
+    properties:
+      hibernate:
+        format_sql: true
+<%_ if (database === 'h2') { _%>
+
+  h2:
+    console:
+      enabled: true
+      path: /h2-console
+<%_ } _%>
+
+<%_ if (hasMail) { _%>
+  mail:
+    host: ${MAIL_HOST:smtp.mailtrap.io}
+    port: ${MAIL_PORT:2525}
+    username: ${MAIL_USER:your_username}
+    password: ${MAIL_PASS:your_password}
+    properties:
+      mail:
+        smtp:
+          auth: true
+          starttls:
+            enable: true
+<%_ } _%>
+
+jwt:
+  secret: ${JWT_SECRET:404E635266556A586E3272357538782F413F4428472B4B6250645367566B5970}
+  expiration: ${JWT_EXPIRATION:86400000} # 24h
+
+server:
+  port: 8080
+  error:
+    include-message: always

package/templates/project/resources/logback-spring.xml.ejs

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <property name="LOGS" value="./logs" />
+
+    <appender name="Console" class="ch.qos.logback.core.ConsoleAppender">
+        <layout class="ch.qos.logback.classic.PatternLayout">
+            <Pattern>
+                %black(%d{ISO8601}) %highlight(%-5level) [%blue(%t)] %yellow(%C{1.}): %msg%n%throwable
+            </Pattern>
+        </layout>
+    </appender>
+
+    <appender name="RollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${LOGS}/spring-boot-logger.log</file>
+        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+            <Pattern>%d %p %C{1.} [%t] %m%n</Pattern>
+        </encoder>
+
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <!-- rollover daily and when the file reaches 10 MegaBytes -->
+            <fileNamePattern>${LOGS}/archived/spring-boot-logger-%d{yyyy-MM-dd}.%i.log
+            </fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>10MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+        </rollingPolicy>
+    </appender>
+
+    <!-- LOG everything at INFO level -->
+    <root level="info">
+        <appender-ref ref="RollingFile" />
+        <appender-ref ref="Console" />
+    </root>
+
+    <!-- LOG "<%= packageName %>*" at TRACE level -->
+    <logger name="<%= packageName %>" level="trace" additivity="false">
+        <appender-ref ref="RollingFile" />
+        <appender-ref ref="Console" />
+    </logger>
+
+</configuration>

package/templates/project/static/admin.html.ejs

@@ -0,0 +1,163 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <title><%= projectName %> — Admin Panel</title>
+  <link rel="stylesheet" href="/css/style.css"/>
+</head>
+<body>
+<div class="app-shell">
+  <aside id="sidebar" class="sidebar"></aside>
+  <div class="main">
+    <header class="topbar">
+      <span class="topbar-title">User Management</span>
+      <span id="user-count" class="topbar-meta"></span>
+    </header>
+    <div class="page">
+      <div class="page-header">
+        <h1>Users</h1>
+        <p class="text-muted">Manage roles and access for all registered users.</p>
+      </div>
+
+      <!-- Quick stats -->
+      <div class="stats-row" id="admin-stats">
+        <div class="stat-card">
+          <div class="stat-label">Total Users</div>
+          <div class="stat-value text-green" id="a-stat-total">—</div>
+        </div>
+        <div class="stat-card">
+          <div class="stat-label">Administrators</div>
+          <div class="stat-value" id="a-stat-admins">—</div>
+        </div>
+        <div class="stat-card">
+          <div class="stat-label">Members</div>
+          <div class="stat-value" id="a-stat-members">—</div>
+        </div>
+      </div>
+
+      <div class="card">
+        <div class="card-header">
+          <span class="card-title">All users</span>
+          <button class="btn btn-ghost btn-sm" onclick="loadUsers()">Refresh</button>
+        </div>
+        <div class="table-wrap">
+          <table>
+            <thead>
+              <tr><th>#</th><th>Name</th><th>Email</th><th>Role</th><th>Joined</th><th>Actions</th></tr>
+            </thead>
+            <tbody id="users-table">
+              <tr><td colspan="6" class="table-empty">Loading…</td></tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>
+<div id="toast" class="toast"></div>
+<script src="/js/auth.js"></script>
+<script src="/js/ui.js"></script>
+<script src="/js/nav.js"></script>
+<script>
+  if (!guardAdmin()) throw new Error('redirect');
+  renderNav('admin');
+
+  async function loadStats() {
+    try {
+      const r = await fetch('/api/v1/admin/stats', {
+        headers: { Authorization: 'Bearer ' + Auth.token() }
+      });
+      if (!r.ok) throw new Error();
+      const s = await r.json();
+      animateCount(document.getElementById('a-stat-total'),   s.totalUsers   || 0);
+      animateCount(document.getElementById('a-stat-admins'),  s.admins       || 0);
+      animateCount(document.getElementById('a-stat-members'), s.regularUsers || 0);
+    } catch { /* silent, stats are bonus */ }
+  }
+
+  async function loadUsers() {
+    const tbody = document.getElementById('users-table');
+    tbody.innerHTML = '<tr><td colspan="6" class="table-empty">Loading…</td></tr>';
+    try {
+      const r = await fetch('/api/v1/admin/users', {
+        headers: { Authorization: 'Bearer ' + Auth.token() }
+      });
+      if (!r.ok) throw new Error('Access denied (' + r.status + ')');
+      const users = await r.json();
+
+      document.getElementById('user-count').textContent = users.length + ' users';
+
+      if (!users.length) {
+        tbody.innerHTML = '<tr><td colspan="6" class="table-empty">No users found.</td></tr>';
+        return;
+      }
+
+      const meId = Auth.user()?.id;
+
+      tbody.innerHTML = users.map(u => {
+        const isAdmin  = u.roles?.includes('ROLE_ADMIN') || u.admin;
+        const joined   = u.createdAt
+          ? new Date(u.createdAt).toLocaleDateString('en-US', { month:'short', day:'numeric', year:'numeric' })
+          : '—';
+        const isSelf   = u.id === meId;
+        const newRole  = isAdmin ? 'ROLE_USER' : 'ROLE_ADMIN';
+        const roleLabel = isAdmin ? 'Make Member' : 'Make Admin';
+        const roleBadge = isAdmin
+          ? '<span class="badge badge-admin">Admin</span>'
+          : '<span class="badge badge-auth">Member</span>';
+
+        const actions = isSelf
+          ? '<span class="text-muted" style="font-size:0.78rem;">— you —</span>'
+          : `<div class="actions">
+               <button class="btn btn-ghost btn-xs" onclick="changeRole(${u.id},'${newRole}')">${roleLabel}</button>
+               <button class="btn btn-danger-ghost btn-xs" onclick="deleteUser(${u.id},'${u.firstName}')">Delete</button>
+             </div>`;
+
+        return `<tr>
+          <td class="text-dim">${u.id}</td>
+          <td><strong>${u.firstName} ${u.lastName}</strong></td>
+          <td class="text-muted">${u.email}</td>
+          <td>${roleBadge}</td>
+          <td class="text-muted">${joined}</td>
+          <td>${actions}</td>
+        </tr>`;
+      }).join('');
+    } catch (err) {
+      tbody.innerHTML = `<tr><td colspan="6" class="table-empty text-danger">${err.message}</td></tr>`;
+    }
+  }
+
+  async function changeRole(id, role) {
+    try {
+      const r = await fetch('/api/v1/admin/users/' + id + '/role', {
+        method: 'PUT',
+        headers: { 'Content-Type':'application/json', Authorization: 'Bearer ' + Auth.token() },
+        body: JSON.stringify({ role })
+      });
+      if (!r.ok) throw new Error('Failed to update role');
+      showToast('Role updated');
+      loadUsers();
+      loadStats();
+    } catch (err) { showToast(err.message, 'error'); }
+  }
+
+  async function deleteUser(id, name) {
+    if (!confirm('Delete "' + name + '"? This cannot be undone.')) return;
+    try {
+      const r = await fetch('/api/v1/admin/users/' + id, {
+        method: 'DELETE',
+        headers: { Authorization: 'Bearer ' + Auth.token() }
+      });
+      if (!r.ok) throw new Error('Delete failed');
+      showToast(name + ' deleted');
+      loadUsers();
+      loadStats();
+    } catch (err) { showToast(err.message, 'error'); }
+  }
+
+  loadStats();
+  loadUsers();
+</script>
+</body>
+</html>