autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/dotnet.md

@@ -0,0 +1,409 @@
+# .NET Skill
+
+## Clean Architecture Structure
+\`\`\`
+src/
+├── MyApp.Api/                    # Presentation layer (Controllers, Middleware)
+│   ├── Controllers/
+│   ├── Middleware/
+│   └── Program.cs
+├── MyApp.Application/            # Application layer (Use cases, DTOs)
+│   ├── Users/
+│   │   ├── Commands/
+│   │   ├── Queries/
+│   │   └── DTOs/
+│   └── Common/
+│       ├── Interfaces/
+│       └── Behaviors/
+├── MyApp.Domain/                 # Domain layer (Entities, Value Objects)
+│   ├── Entities/
+│   ├── ValueObjects/
+│   ├── Enums/
+│   └── Events/
+├── MyApp.Infrastructure/         # Infrastructure (EF, External Services)
+│   ├── Persistence/
+│   ├── Services/
+│   └── DependencyInjection.cs
+tests/
+├── MyApp.UnitTests/
+├── MyApp.IntegrationTests/
+└── MyApp.ArchitectureTests/
+\`\`\`
+
+## Dependency Injection
+\`\`\`csharp
+// Register services by convention
+public static class DependencyInjection
+{
+    public static IServiceCollection AddApplication(this IServiceCollection services)
+    {
+        // Register all services implementing interface
+        services.Scan(scan => scan
+            .FromAssemblyOf<IUserService>()
+            .AddClasses(classes => classes.AssignableTo(typeof(IRequestHandler<,>)))
+            .AsImplementedInterfaces()
+            .WithScopedLifetime());
+
+        // MediatR
+        services.AddMediatR(cfg =>
+            cfg.RegisterServicesFromAssembly(typeof(DependencyInjection).Assembly));
+
+        // FluentValidation
+        services.AddValidatorsFromAssembly(typeof(DependencyInjection).Assembly);
+
+        return services;
+    }
+
+    public static IServiceCollection AddInfrastructure(
+        this IServiceCollection services,
+        IConfiguration configuration)
+    {
+        // Database
+        services.AddDbContext<AppDbContext>(options =>
+            options.UseNpgsql(configuration.GetConnectionString("Default")));
+
+        // Repositories
+        services.AddScoped<IUserRepository, UserRepository>();
+
+        // External services
+        services.AddHttpClient<IEmailService, EmailService>(client =>
+        {
+            client.BaseAddress = new Uri(configuration["Email:BaseUrl"]!);
+        });
+
+        return services;
+    }
+}
+
+// Program.cs
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services
+    .AddApplication()
+    .AddInfrastructure(builder.Configuration);
+\`\`\`
+
+## Configuration with Options Pattern
+\`\`\`csharp
+// Settings classes
+public class DatabaseSettings
+{
+    public const string SectionName = "Database";
+
+    public required string ConnectionString { get; init; }
+    public int MaxRetryCount { get; init; } = 3;
+    public int CommandTimeout { get; init; } = 30;
+}
+
+public class JwtSettings
+{
+    public const string SectionName = "Jwt";
+
+    public required string Secret { get; init; }
+    public required string Issuer { get; init; }
+    public required string Audience { get; init; }
+    public int ExpirationMinutes { get; init; } = 60;
+}
+
+// Registration with validation
+services.AddOptions<JwtSettings>()
+    .Bind(configuration.GetSection(JwtSettings.SectionName))
+    .ValidateDataAnnotations()
+    .ValidateOnStart();
+
+// Usage
+public class TokenService
+{
+    private readonly JwtSettings _settings;
+
+    public TokenService(IOptions<JwtSettings> options)
+    {
+        _settings = options.Value;
+    }
+
+    // Or for settings that can change at runtime
+    public TokenService(IOptionsMonitor<JwtSettings> options)
+    {
+        options.OnChange(settings => _settings = settings);
+    }
+}
+\`\`\`
+
+## Result Pattern (No Exceptions for Expected Failures)
+\`\`\`csharp
+// Result type
+public class Result<T>
+{
+    public bool IsSuccess { get; }
+    public T? Value { get; }
+    public Error? Error { get; }
+
+    private Result(T value)
+    {
+        IsSuccess = true;
+        Value = value;
+    }
+
+    private Result(Error error)
+    {
+        IsSuccess = false;
+        Error = error;
+    }
+
+    public static Result<T> Success(T value) => new(value);
+    public static Result<T> Failure(Error error) => new(error);
+
+    public TResult Match<TResult>(
+        Func<T, TResult> onSuccess,
+        Func<Error, TResult> onFailure) =>
+        IsSuccess ? onSuccess(Value!) : onFailure(Error!);
+}
+
+public record Error(string Code, string Message);
+
+public static class Errors
+{
+    public static class User
+    {
+        public static Error NotFound(string id) =>
+            new("User.NotFound", $"User with id '{id}' not found");
+
+        public static Error EmailTaken(string email) =>
+            new("User.EmailTaken", $"Email '{email}' is already in use");
+    }
+}
+
+// Usage in service
+public async Task<Result<UserResponse>> GetUserAsync(string id, CancellationToken ct)
+{
+    var user = await _repository.GetByIdAsync(id, ct);
+
+    if (user is null)
+        return Result<UserResponse>.Failure(Errors.User.NotFound(id));
+
+    return Result<UserResponse>.Success(UserResponse.From(user));
+}
+
+// Usage in controller
+[HttpGet("{id}")]
+public async Task<IActionResult> GetUser(string id, CancellationToken ct)
+{
+    var result = await _userService.GetUserAsync(id, ct);
+
+    return result.Match<IActionResult>(
+        onSuccess: user => Ok(user),
+        onFailure: error => error.Code switch
+        {
+            "User.NotFound" => NotFound(error),
+            _ => BadRequest(error)
+        });
+}
+\`\`\`
+
+## MediatR with CQRS
+\`\`\`csharp
+// Query
+public record GetUserQuery(string Id) : IRequest<Result<UserResponse>>;
+
+public class GetUserQueryHandler : IRequestHandler<GetUserQuery, Result<UserResponse>>
+{
+    private readonly IUserRepository _repository;
+
+    public GetUserQueryHandler(IUserRepository repository)
+    {
+        _repository = repository;
+    }
+
+    public async Task<Result<UserResponse>> Handle(
+        GetUserQuery request,
+        CancellationToken ct)
+    {
+        var user = await _repository.GetByIdAsync(request.Id, ct);
+
+        if (user is null)
+            return Result<UserResponse>.Failure(Errors.User.NotFound(request.Id));
+
+        return Result<UserResponse>.Success(UserResponse.From(user));
+    }
+}
+
+// Command
+public record CreateUserCommand(string Email, string Name, string Password)
+    : IRequest<Result<UserResponse>>;
+
+public class CreateUserCommandHandler : IRequestHandler<CreateUserCommand, Result<UserResponse>>
+{
+    private readonly IUserRepository _repository;
+    private readonly IPasswordHasher _hasher;
+
+    public CreateUserCommandHandler(IUserRepository repository, IPasswordHasher hasher)
+    {
+        _repository = repository;
+        _hasher = hasher;
+    }
+
+    public async Task<Result<UserResponse>> Handle(
+        CreateUserCommand request,
+        CancellationToken ct)
+    {
+        if (await _repository.ExistsByEmailAsync(request.Email, ct))
+            return Result<UserResponse>.Failure(Errors.User.EmailTaken(request.Email));
+
+        var user = new User
+        {
+            Email = request.Email,
+            Name = request.Name,
+            PasswordHash = _hasher.Hash(request.Password)
+        };
+
+        await _repository.AddAsync(user, ct);
+
+        return Result<UserResponse>.Success(UserResponse.From(user));
+    }
+}
+
+// Controller usage
+[HttpPost]
+public async Task<IActionResult> CreateUser(
+    CreateUserRequest request,
+    CancellationToken ct)
+{
+    var command = new CreateUserCommand(request.Email, request.Name, request.Password);
+    var result = await _mediator.Send(command, ct);
+
+    return result.Match<IActionResult>(
+        onSuccess: user => CreatedAtAction(nameof(GetUser), new { id = user.Id }, user),
+        onFailure: error => BadRequest(error));
+}
+\`\`\`
+
+## Pipeline Behaviors (Cross-Cutting Concerns)
+\`\`\`csharp
+// Validation behavior
+public class ValidationBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly IEnumerable<IValidator<TRequest>> _validators;
+
+    public ValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
+    {
+        _validators = validators;
+    }
+
+    public async Task<TResponse> Handle(
+        TRequest request,
+        RequestHandlerDelegate<TResponse> next,
+        CancellationToken ct)
+    {
+        if (!_validators.Any())
+            return await next();
+
+        var context = new ValidationContext<TRequest>(request);
+        var failures = _validators
+            .Select(v => v.Validate(context))
+            .SelectMany(r => r.Errors)
+            .Where(f => f is not null)
+            .ToList();
+
+        if (failures.Any())
+            throw new ValidationException(failures);
+
+        return await next();
+    }
+}
+
+// Logging behavior
+public class LoggingBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly ILogger<LoggingBehavior<TRequest, TResponse>> _logger;
+
+    public LoggingBehavior(ILogger<LoggingBehavior<TRequest, TResponse>> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<TResponse> Handle(
+        TRequest request,
+        RequestHandlerDelegate<TResponse> next,
+        CancellationToken ct)
+    {
+        var requestName = typeof(TRequest).Name;
+        _logger.LogInformation("Handling {RequestName}", requestName);
+
+        var stopwatch = Stopwatch.StartNew();
+        var response = await next();
+        stopwatch.Stop();
+
+        _logger.LogInformation("Handled {RequestName} in {ElapsedMs}ms",
+            requestName, stopwatch.ElapsedMilliseconds);
+
+        return response;
+    }
+}
+
+// Registration
+services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
+services.AddTransient(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));
+\`\`\`
+
+## Testing
+\`\`\`csharp
+public class GetUserQueryHandlerTests
+{
+    private readonly Mock<IUserRepository> _repositoryMock;
+    private readonly GetUserQueryHandler _handler;
+
+    public GetUserQueryHandlerTests()
+    {
+        _repositoryMock = new Mock<IUserRepository>();
+        _handler = new GetUserQueryHandler(_repositoryMock.Object);
+    }
+
+    [Fact]
+    public async Task Handle_WhenUserExists_ReturnsSuccess()
+    {
+        // Arrange
+        var user = new User { Id = "1", Email = "test@example.com", Name = "Test" };
+        _repositoryMock.Setup(r => r.GetByIdAsync("1", It.IsAny<CancellationToken>()))
+            .ReturnsAsync(user);
+
+        // Act
+        var result = await _handler.Handle(new GetUserQuery("1"), CancellationToken.None);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.Value!.Email.Should().Be("test@example.com");
+    }
+
+    [Fact]
+    public async Task Handle_WhenUserNotExists_ReturnsFailure()
+    {
+        // Arrange
+        _repositoryMock.Setup(r => r.GetByIdAsync("999", It.IsAny<CancellationToken>()))
+            .ReturnsAsync((User?)null);
+
+        // Act
+        var result = await _handler.Handle(new GetUserQuery("999"), CancellationToken.None);
+
+        // Assert
+        result.IsSuccess.Should().BeFalse();
+        result.Error!.Code.Should().Be("User.NotFound");
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use Clean Architecture / Vertical Slice Architecture
+- Use dependency injection for all dependencies
+- Use IOptions<T> for configuration
+- Use Result pattern instead of exceptions for expected failures
+- Use MediatR for CQRS (optional but recommended)
+- Use pipeline behaviors for cross-cutting concerns
+
+## ❌ DON'T
+- Don't inject IConfiguration directly
+- Don't use static classes for business logic
+- Don't throw exceptions for validation errors
+- Don't put business logic in controllers
+- Don't reference Infrastructure from Domain

package/.claude/skills/drizzle.md

@@ -0,0 +1,293 @@
+# Drizzle ORM Skill
+
+## Setup & Configuration
+\`\`\`typescript
+// drizzle.config.ts
+import type { Config } from 'drizzle-kit';
+
+export default {
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+  driver: 'pg',
+  dbCredentials: {
+    connectionString: process.env.DATABASE_URL!,
+  },
+} satisfies Config;
+
+// src/db/index.ts
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import * as schema from './schema';
+
+const client = postgres(process.env.DATABASE_URL!);
+export const db = drizzle(client, { schema });
+\`\`\`
+
+## Schema Definition
+\`\`\`typescript
+// src/db/schema.ts
+import {
+  pgTable, uuid, text, timestamp, boolean, integer,
+  pgEnum, primaryKey, index, uniqueIndex
+} from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+
+// Enums
+export const roleEnum = pgEnum('role', ['user', 'admin', 'moderator']);
+
+// Users table
+export const users = pgTable('users', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  email: text('email').notNull().unique(),
+  name: text('name'),
+  role: roleEnum('role').default('user').notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+  deletedAt: timestamp('deleted_at'),
+}, (table) => ({
+  emailIdx: uniqueIndex('email_idx').on(table.email),
+  roleIdx: index('role_idx').on(table.role),
+}));
+
+// Posts table
+export const posts = pgTable('posts', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  title: text('title').notNull(),
+  content: text('content'),
+  published: boolean('published').default(false).notNull(),
+  authorId: uuid('author_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+}, (table) => ({
+  authorIdx: index('author_idx').on(table.authorId),
+}));
+
+// Categories with many-to-many
+export const categories = pgTable('categories', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  name: text('name').notNull().unique(),
+});
+
+export const postsToCategories = pgTable('posts_to_categories', {
+  postId: uuid('post_id').notNull().references(() => posts.id, { onDelete: 'cascade' }),
+  categoryId: uuid('category_id').notNull().references(() => categories.id, { onDelete: 'cascade' }),
+}, (table) => ({
+  pk: primaryKey({ columns: [table.postId, table.categoryId] }),
+}));
+
+// Relations (for query builder)
+export const usersRelations = relations(users, ({ many }) => ({
+  posts: many(posts),
+}));
+
+export const postsRelations = relations(posts, ({ one, many }) => ({
+  author: one(users, {
+    fields: [posts.authorId],
+    references: [users.id],
+  }),
+  categories: many(postsToCategories),
+}));
+\`\`\`
+
+## Type Inference
+\`\`\`typescript
+import { InferSelectModel, InferInsertModel } from 'drizzle-orm';
+import { users, posts } from './schema';
+
+// Infer types from schema
+export type User = InferSelectModel<typeof users>;
+export type NewUser = InferInsertModel<typeof users>;
+export type Post = InferSelectModel<typeof posts>;
+export type NewPost = InferInsertModel<typeof posts>;
+
+// With relations
+export type UserWithPosts = User & { posts: Post[] };
+\`\`\`
+
+## Query Patterns
+\`\`\`typescript
+import { eq, and, or, gt, lt, like, isNull, sql, desc, asc } from 'drizzle-orm';
+
+// Basic CRUD
+// Create
+const [newUser] = await db.insert(users)
+  .values({ email: 'user@example.com', name: 'John' })
+  .returning();
+
+// Read
+const allUsers = await db.select().from(users);
+const user = await db.select().from(users).where(eq(users.id, userId)).limit(1);
+
+// Update
+const [updated] = await db.update(users)
+  .set({ name: 'Jane', updatedAt: new Date() })
+  .where(eq(users.id, userId))
+  .returning();
+
+// Delete
+await db.delete(users).where(eq(users.id, userId));
+
+// Complex filters
+const filteredUsers = await db.select()
+  .from(users)
+  .where(
+    and(
+      eq(users.role, 'user'),
+      isNull(users.deletedAt),
+      or(
+        like(users.name, '%John%'),
+        like(users.email, '%@company.com')
+      )
+    )
+  )
+  .orderBy(desc(users.createdAt))
+  .limit(20)
+  .offset(0);
+
+// Select specific columns
+const emails = await db.select({
+  id: users.id,
+  email: users.email,
+}).from(users);
+
+// Aggregations
+const [{ count }] = await db.select({
+  count: sql<number>\`count(*)\`::int,
+}).from(users);
+
+const stats = await db.select({
+  role: users.role,
+  count: sql<number>\`count(*)\`::int,
+}).from(users).groupBy(users.role);
+\`\`\`
+
+## Joins & Relations
+\`\`\`typescript
+// Manual joins
+const usersWithPosts = await db.select({
+  user: users,
+  post: posts,
+})
+.from(users)
+.leftJoin(posts, eq(users.id, posts.authorId))
+.where(eq(posts.published, true));
+
+// Inner join
+const authoredPosts = await db.select()
+  .from(posts)
+  .innerJoin(users, eq(posts.authorId, users.id));
+
+// Using relational queries (requires relations defined)
+const usersWithRelations = await db.query.users.findMany({
+  with: {
+    posts: {
+      where: eq(posts.published, true),
+      orderBy: desc(posts.createdAt),
+      limit: 5,
+    },
+  },
+  where: isNull(users.deletedAt),
+});
+
+// Find first with relations
+const user = await db.query.users.findFirst({
+  where: eq(users.id, userId),
+  with: { posts: true },
+});
+\`\`\`
+
+## Transactions
+\`\`\`typescript
+// Basic transaction
+const result = await db.transaction(async (tx) => {
+  const [user] = await tx.insert(users)
+    .values({ email: 'test@example.com', name: 'Test' })
+    .returning();
+
+  const [post] = await tx.insert(posts)
+    .values({ title: 'First Post', authorId: user.id })
+    .returning();
+
+  return { user, post };
+});
+
+// With rollback on error
+await db.transaction(async (tx) => {
+  await tx.update(users)
+    .set({ balance: sql\`balance - 100\` })
+    .where(eq(users.id, senderId));
+
+  const [sender] = await tx.select({ balance: users.balance })
+    .from(users)
+    .where(eq(users.id, senderId));
+
+  if (sender.balance < 0) {
+    tx.rollback(); // Abort transaction
+  }
+
+  await tx.update(users)
+    .set({ balance: sql\`balance + 100\` })
+    .where(eq(users.id, receiverId));
+});
+\`\`\`
+
+## Prepared Statements
+\`\`\`typescript
+// Prepare for better performance
+const getUserById = db.select()
+  .from(users)
+  .where(eq(users.id, sql.placeholder('id')))
+  .prepare('get_user_by_id');
+
+// Execute with params
+const user = await getUserById.execute({ id: userId });
+
+// Prepared insert
+const insertUser = db.insert(users)
+  .values({
+    email: sql.placeholder('email'),
+    name: sql.placeholder('name'),
+  })
+  .returning()
+  .prepare('insert_user');
+
+const [newUser] = await insertUser.execute({
+  email: 'user@example.com',
+  name: 'John',
+});
+\`\`\`
+
+## Migrations
+\`\`\`bash
+# Generate migration from schema changes
+npx drizzle-kit generate:pg
+
+# Push schema directly (dev only)
+npx drizzle-kit push:pg
+
+# View in Drizzle Studio
+npx drizzle-kit studio
+\`\`\`
+
+\`\`\`typescript
+// Run migrations programmatically
+import { migrate } from 'drizzle-orm/postgres-js/migrator';
+import { db } from './db';
+
+await migrate(db, { migrationsFolder: './drizzle' });
+\`\`\`
+
+## ❌ DON'T
+- Forget to define relations for relational queries
+- Use raw SQL when Drizzle operators exist
+- Skip type inference (use InferSelectModel/InferInsertModel)
+- Ignore indexes on frequently queried columns
+- Use \`db.select().from()\` without limits on large tables
+
+## ✅ DO
+- Define relations for the query builder
+- Use type inference for type safety
+- Use prepared statements for repeated queries
+- Use transactions for multi-step operations
+- Add indexes in schema definition
+- Use \`returning()\` after insert/update when you need the result
+- Use relational queries (\`db.query\`) for nested data