autoworkflow 3.1.5 → 3.6.0

package/.claude/skills/hibernate.md

@@ -0,0 +1,379 @@
+# Hibernate Skill
+
+## Entity Definition
+\`\`\`java
+@Entity
+@Table(name = "users", indexes = {
+    @Index(name = "idx_users_email", columnList = "email")
+})
+public class User {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private String id;
+
+    @Column(unique = true, nullable = false, length = 255)
+    private String email;
+
+    @Column(nullable = false, length = 100)
+    private String name;
+
+    @Column(name = "password_hash", nullable = false)
+    private String passwordHash;
+
+    @Column(name = "is_active")
+    private boolean isActive = true;
+
+    @CreationTimestamp
+    @Column(name = "created_at", updatable = false)
+    private Instant createdAt;
+
+    @UpdateTimestamp
+    @Column(name = "updated_at")
+    private Instant updatedAt;
+
+    // Relationships
+    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
+    private Profile profile;
+
+    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL, orphanRemoval = true)
+    @OrderBy("createdAt DESC")
+    private List<Post> posts = new ArrayList<>();
+
+    @ManyToMany
+    @JoinTable(
+        name = "user_roles",
+        joinColumns = @JoinColumn(name = "user_id"),
+        inverseJoinColumns = @JoinColumn(name = "role_id")
+    )
+    private Set<Role> roles = new HashSet<>();
+
+    // Helper methods for bidirectional relationships
+    public void addPost(Post post) {
+        posts.add(post);
+        post.setAuthor(this);
+    }
+
+    public void removePost(Post post) {
+        posts.remove(post);
+        post.setAuthor(null);
+    }
+
+    public void addRole(Role role) {
+        roles.add(role);
+        role.getUsers().add(this);
+    }
+
+    // Getters and setters...
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof User user)) return false;
+        return id != null && id.equals(user.id);
+    }
+
+    @Override
+    public int hashCode() {
+        return getClass().hashCode();
+    }
+}
+
+@Entity
+@Table(name = "posts")
+public class Post {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private String id;
+
+    @Column(nullable = false)
+    private String title;
+
+    @Column(columnDefinition = "TEXT")
+    private String content;
+
+    private boolean published = false;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "author_id")
+    private User author;
+
+    @ManyToMany
+    @JoinTable(
+        name = "post_tags",
+        joinColumns = @JoinColumn(name = "post_id"),
+        inverseJoinColumns = @JoinColumn(name = "tag_id")
+    )
+    private Set<Tag> tags = new HashSet<>();
+
+    @CreationTimestamp
+    @Column(name = "created_at", updatable = false)
+    private Instant createdAt;
+}
+\`\`\`
+
+## JPQL Queries
+\`\`\`java
+@Repository
+public interface UserRepository extends JpaRepository<User, String> {
+
+    // Derived query methods
+    Optional<User> findByEmail(String email);
+
+    List<User> findByIsActiveTrue();
+
+    boolean existsByEmail(String email);
+
+    // JPQL queries
+    @Query("SELECT u FROM User u WHERE u.isActive = true ORDER BY u.createdAt DESC")
+    List<User> findActiveUsers();
+
+    @Query("SELECT u FROM User u JOIN FETCH u.roles WHERE u.id = :id")
+    Optional<User> findByIdWithRoles(@Param("id") String id);
+
+    @Query("SELECT u FROM User u LEFT JOIN FETCH u.posts WHERE u.id = :id")
+    Optional<User> findByIdWithPosts(@Param("id") String id);
+
+    // Pagination
+    @Query("SELECT u FROM User u WHERE u.isActive = true")
+    Page<User> findActiveUsersPaged(Pageable pageable);
+
+    // Modifying queries
+    @Modifying
+    @Query("UPDATE User u SET u.isActive = false WHERE u.id = :id")
+    int deactivateUser(@Param("id") String id);
+
+    @Modifying
+    @Query("DELETE FROM User u WHERE u.isActive = false AND u.createdAt < :date")
+    int deleteInactiveOlderThan(@Param("date") Instant date);
+}
+\`\`\`
+
+## Criteria API (Dynamic Queries)
+\`\`\`java
+@Repository
+public class UserSearchRepository {
+
+    @PersistenceContext
+    private EntityManager em;
+
+    public List<User> search(UserSearchCriteria criteria) {
+        CriteriaBuilder cb = em.getCriteriaBuilder();
+        CriteriaQuery<User> cq = cb.createQuery(User.class);
+        Root<User> user = cq.from(User.class);
+
+        List<Predicate> predicates = new ArrayList<>();
+
+        if (criteria.getEmail() != null) {
+            predicates.add(cb.like(
+                cb.lower(user.get("email")),
+                "%" + criteria.getEmail().toLowerCase() + "%"
+            ));
+        }
+
+        if (criteria.getName() != null) {
+            predicates.add(cb.like(
+                cb.lower(user.get("name")),
+                "%" + criteria.getName().toLowerCase() + "%"
+            ));
+        }
+
+        if (criteria.getIsActive() != null) {
+            predicates.add(cb.equal(user.get("isActive"), criteria.getIsActive()));
+        }
+
+        if (criteria.getCreatedAfter() != null) {
+            predicates.add(cb.greaterThan(user.get("createdAt"), criteria.getCreatedAfter()));
+        }
+
+        cq.where(predicates.toArray(new Predicate[0]));
+        cq.orderBy(cb.desc(user.get("createdAt")));
+
+        return em.createQuery(cq)
+            .setFirstResult(criteria.getOffset())
+            .setMaxResults(criteria.getLimit())
+            .getResultList();
+    }
+}
+
+// With Specification (Spring Data JPA)
+public class UserSpecifications {
+
+    public static Specification<User> emailContains(String email) {
+        return (root, query, cb) -> email == null ? null :
+            cb.like(cb.lower(root.get("email")), "%" + email.toLowerCase() + "%");
+    }
+
+    public static Specification<User> isActive(Boolean active) {
+        return (root, query, cb) -> active == null ? null :
+            cb.equal(root.get("isActive"), active);
+    }
+
+    public static Specification<User> createdAfter(Instant date) {
+        return (root, query, cb) -> date == null ? null :
+            cb.greaterThan(root.get("createdAt"), date);
+    }
+}
+
+// Usage
+List<User> users = userRepository.findAll(
+    Specification.where(emailContains(email))
+        .and(isActive(true))
+        .and(createdAfter(lastWeek))
+);
+\`\`\`
+
+## Entity Graphs (Solving N+1)
+\`\`\`java
+@Entity
+@NamedEntityGraph(
+    name = "User.withPostsAndRoles",
+    attributeNodes = {
+        @NamedAttributeNode("posts"),
+        @NamedAttributeNode("roles")
+    }
+)
+public class User { ... }
+
+// Using in repository
+@EntityGraph(attributePaths = {"posts", "roles"})
+Optional<User> findWithDetailsById(String id);
+
+// Or with JPQL
+@Query("SELECT u FROM User u")
+@EntityGraph(attributePaths = {"posts"})
+List<User> findAllWithPosts();
+
+// Programmatic entity graph
+public User findWithGraph(String id) {
+    EntityGraph<User> graph = em.createEntityGraph(User.class);
+    graph.addAttributeNodes("posts", "roles");
+
+    Map<String, Object> hints = new HashMap<>();
+    hints.put("jakarta.persistence.fetchgraph", graph);
+
+    return em.find(User.class, id, hints);
+}
+\`\`\`
+
+## Transactions and Session Management
+\`\`\`java
+@Service
+@Transactional(readOnly = true)
+public class UserService {
+
+    private final UserRepository userRepository;
+    private final EntityManager em;
+
+    @Transactional
+    public User create(CreateUserRequest request) {
+        User user = new User();
+        user.setEmail(request.email());
+        user.setName(request.name());
+        return userRepository.save(user);
+    }
+
+    @Transactional
+    public void updateWithManualFlush(String id, String name) {
+        User user = userRepository.findById(id).orElseThrow();
+        user.setName(name);
+        // Explicit flush if needed before external call
+        em.flush();
+        // Call external service...
+    }
+
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public void auditAction(String action) {
+        // Runs in separate transaction
+        // Commits even if parent transaction rolls back
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void complexOperation() {
+        // Rolls back on any exception, not just RuntimeException
+    }
+}
+\`\`\`
+
+## Caching
+\`\`\`java
+// Entity with second-level cache
+@Entity
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class User {
+    // ...
+
+    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+    @OneToMany(mappedBy = "author")
+    private List<Post> posts;
+}
+
+// Query cache
+@QueryHints(@QueryHint(name = "org.hibernate.cacheable", value = "true"))
+List<User> findByIsActiveTrue();
+
+// Configuration (application.properties)
+spring.jpa.properties.hibernate.cache.use_second_level_cache=true
+spring.jpa.properties.hibernate.cache.use_query_cache=true
+spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.jcache.JCacheRegionFactory
+spring.jpa.properties.hibernate.javax.cache.provider=org.ehcache.jsr107.EhcacheCachingProvider
+
+// Cache eviction
+@CacheEvict(value = "users", key = "#id")
+public void delete(String id) {
+    userRepository.deleteById(id);
+}
+\`\`\`
+
+## Batch Operations
+\`\`\`java
+// Batch inserts - configure in properties
+spring.jpa.properties.hibernate.jdbc.batch_size=50
+spring.jpa.properties.hibernate.order_inserts=true
+spring.jpa.properties.hibernate.order_updates=true
+
+// Bulk update
+@Modifying
+@Query("UPDATE User u SET u.isActive = false WHERE u.createdAt < :date")
+int bulkDeactivate(@Param("date") Instant date);
+
+// Batch processing large datasets
+@Transactional
+public void processAllUsers() {
+    int batchSize = 100;
+    int offset = 0;
+    List<User> batch;
+
+    do {
+        batch = em.createQuery("SELECT u FROM User u", User.class)
+            .setFirstResult(offset)
+            .setMaxResults(batchSize)
+            .getResultList();
+
+        for (User user : batch) {
+            processUser(user);
+        }
+
+        em.flush();
+        em.clear();  // Clear persistence context to avoid memory issues
+        offset += batchSize;
+    } while (!batch.isEmpty());
+}
+\`\`\`
+
+## ✅ DO
+- Use \`FetchType.LAZY\` for all relationships (default for @OneToMany/@ManyToMany)
+- Use \`@EntityGraph\` or \`JOIN FETCH\` to solve N+1 problems
+- Override \`equals()\` and \`hashCode()\` using business key or ID
+- Use helper methods for bidirectional relationships
+- Use \`@Transactional(readOnly = true)\` for read operations
+- Clear persistence context (\`em.clear()\`) when processing large batches
+
+## ❌ DON'T
+- Don't use \`FetchType.EAGER\` - causes performance issues
+- Don't use \`@Data\` from Lombok on entities (breaks equals/hashCode)
+- Don't call getters on lazy relationships outside transaction
+- Don't forget \`orphanRemoval = true\` when needed
+- Don't use \`CascadeType.ALL\` without understanding implications
+- Don't compare entities with \`==\` (use \`equals()\`)

package/.claude/skills/hono.md

@@ -0,0 +1,306 @@
+# Hono Skill
+
+## Project Structure
+\`\`\`
+src/
+├── index.ts              # Entry point
+├── app.ts                # Hono app factory
+├── middleware/
+│   ├── auth.ts           # JWT auth
+│   └── logger.ts         # Request logging
+├── routes/
+│   ├── index.ts          # Route aggregator
+│   └── users.ts          # User routes
+└── lib/
+    ├── db.ts             # Database client
+    └── validators.ts     # Zod schemas
+\`\`\`
+
+## App Setup
+\`\`\`typescript
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { logger } from 'hono/logger';
+import { secureHeaders } from 'hono/secure-headers';
+import { prettyJSON } from 'hono/pretty-json';
+
+import { usersApp } from './routes/users';
+import { authMiddleware } from './middleware/auth';
+import { errorHandler } from './middleware/error';
+
+// Type-safe environment variables
+type Bindings = {
+  DATABASE_URL: string;
+  JWT_SECRET: string;
+};
+
+const app = new Hono<{ Bindings: Bindings }>();
+
+// Global middleware
+app.use('*', logger());
+app.use('*', secureHeaders());
+app.use('*', cors({ origin: '*' }));
+app.use('*', prettyJSON());
+
+// Error handler
+app.onError(errorHandler);
+
+// Routes
+app.route('/api/users', usersApp);
+
+// Health check
+app.get('/health', (c) => c.json({ status: 'ok' }));
+
+export default app;
+\`\`\`
+
+## Routes with Validation
+\`\`\`typescript
+// routes/users.ts
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+
+// Schemas
+const createUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1),
+  password: z.string().min(8),
+});
+
+const updateUserSchema = createUserSchema.partial();
+
+const paramsSchema = z.object({
+  id: z.string().uuid(),
+});
+
+const querySchema = z.object({
+  page: z.coerce.number().min(1).default(1),
+  limit: z.coerce.number().min(1).max(100).default(10),
+});
+
+// Type inference
+type CreateUser = z.infer<typeof createUserSchema>;
+
+export const usersApp = new Hono()
+  // GET /users
+  .get('/', zValidator('query', querySchema), async (c) => {
+    const { page, limit } = c.req.valid('query');
+    const users = await db.user.findMany({
+      skip: (page - 1) * limit,
+      take: limit,
+    });
+    return c.json({ users, page, limit });
+  })
+
+  // GET /users/:id
+  .get('/:id', zValidator('param', paramsSchema), async (c) => {
+    const { id } = c.req.valid('param');
+    const user = await db.user.findUnique({ where: { id } });
+
+    if (!user) {
+      return c.json({ error: 'User not found' }, 404);
+    }
+
+    return c.json(user);
+  })
+
+  // POST /users
+  .post('/', zValidator('json', createUserSchema), async (c) => {
+    const data = c.req.valid('json');
+    const user = await db.user.create({ data });
+    return c.json(user, 201);
+  })
+
+  // PATCH /users/:id
+  .patch(
+    '/:id',
+    zValidator('param', paramsSchema),
+    zValidator('json', updateUserSchema),
+    async (c) => {
+      const { id } = c.req.valid('param');
+      const data = c.req.valid('json');
+      const user = await db.user.update({ where: { id }, data });
+      return c.json(user);
+    }
+  )
+
+  // DELETE /users/:id
+  .delete('/:id', zValidator('param', paramsSchema), async (c) => {
+    const { id } = c.req.valid('param');
+    await db.user.delete({ where: { id } });
+    return c.body(null, 204);
+  });
+\`\`\`
+
+## JWT Authentication
+\`\`\`typescript
+// middleware/auth.ts
+import { jwt } from 'hono/jwt';
+import { createMiddleware } from 'hono/factory';
+import type { Context, Next } from 'hono';
+
+// Type-safe user in context
+type Variables = {
+  user: { id: string; email: string };
+};
+
+// JWT middleware
+export const authMiddleware = jwt({
+  secret: (c) => c.env.JWT_SECRET,
+});
+
+// Custom auth with user loading
+export const requireAuth = createMiddleware<{ Variables: Variables }>(
+  async (c, next) => {
+    const authHeader = c.req.header('Authorization');
+
+    if (!authHeader?.startsWith('Bearer ')) {
+      return c.json({ error: 'Unauthorized' }, 401);
+    }
+
+    const token = authHeader.split(' ')[1];
+
+    try {
+      const payload = await verifyToken(token, c.env.JWT_SECRET);
+      c.set('user', payload);
+      await next();
+    } catch {
+      return c.json({ error: 'Invalid token' }, 401);
+    }
+  }
+);
+
+// Usage
+app.get('/me', requireAuth, (c) => {
+  const user = c.get('user');
+  return c.json(user);
+});
+
+// Protected route group
+const protectedRoutes = new Hono()
+  .use('*', requireAuth)
+  .get('/profile', (c) => c.json(c.get('user')))
+  .get('/settings', (c) => c.json({ theme: 'dark' }));
+
+app.route('/api', protectedRoutes);
+\`\`\`
+
+## Error Handling
+\`\`\`typescript
+// middleware/error.ts
+import { HTTPException } from 'hono/http-exception';
+import type { ErrorHandler } from 'hono';
+
+export const errorHandler: ErrorHandler = (err, c) => {
+  console.error(err);
+
+  if (err instanceof HTTPException) {
+    return c.json({ error: err.message }, err.status);
+  }
+
+  // Zod validation errors
+  if (err.name === 'ZodError') {
+    return c.json({
+      error: 'Validation failed',
+      details: err.errors,
+    }, 400);
+  }
+
+  return c.json({ error: 'Internal server error' }, 500);
+};
+
+// Throwing HTTP errors
+import { HTTPException } from 'hono/http-exception';
+
+app.get('/users/:id', async (c) => {
+  const user = await db.user.findUnique({ where: { id } });
+
+  if (!user) {
+    throw new HTTPException(404, { message: 'User not found' });
+  }
+
+  return c.json(user);
+});
+\`\`\`
+
+## Middleware Patterns
+\`\`\`typescript
+// Rate limiting
+import { rateLimiter } from 'hono-rate-limiter';
+
+app.use(
+  '/api/*',
+  rateLimiter({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    limit: 100,
+    keyGenerator: (c) => c.req.header('CF-Connecting-IP') ?? 'anonymous',
+  })
+);
+
+// Request timing
+app.use('*', async (c, next) => {
+  const start = Date.now();
+  await next();
+  const duration = Date.now() - start;
+  c.header('X-Response-Time', \`\${duration}ms\`);
+});
+
+// CORS with options
+import { cors } from 'hono/cors';
+
+app.use('/api/*', cors({
+  origin: ['https://example.com'],
+  allowMethods: ['GET', 'POST', 'PUT', 'DELETE'],
+  allowHeaders: ['Content-Type', 'Authorization'],
+  exposeHeaders: ['X-Request-Id'],
+  credentials: true,
+}));
+\`\`\`
+
+## Edge Runtime (Cloudflare Workers)
+\`\`\`typescript
+// wrangler.toml
+// name = "my-api"
+// main = "src/index.ts"
+// compatibility_date = "2024-01-01"
+
+// [vars]
+// ENVIRONMENT = "production"
+
+// [[d1_databases]]
+// binding = "DB"
+// database_name = "my-db"
+
+import { Hono } from 'hono';
+
+type Bindings = {
+  DB: D1Database;
+  ENVIRONMENT: string;
+};
+
+const app = new Hono<{ Bindings: Bindings }>();
+
+app.get('/users', async (c) => {
+  const { results } = await c.env.DB
+    .prepare('SELECT * FROM users')
+    .all();
+  return c.json(results);
+});
+
+export default app;
+\`\`\`
+
+## ❌ DON'T
+- Skip input validation
+- Expose stack traces in production
+- Forget error handling middleware
+- Block the event loop with sync operations
+
+## ✅ DO
+- Use Zod for validation (@hono/zod-validator)
+- Use middleware for cross-cutting concerns
+- Use typed context (Bindings, Variables)
+- Deploy to edge (Cloudflare, Vercel, Deno)
+- Handle errors with HTTPException
+- Use route groups for organization