aigroup-workflow 2.1.2 → 2.2.0

package/skills/dotnet/dotnet-core-expert/references/minimal-apis.md

@@ -0,0 +1,319 @@
+# Minimal APIs
+
+## Basic Endpoint Patterns
+
+```csharp
+using Microsoft.AspNetCore.Mvc;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+
+var app = builder.Build();
+
+// Configure middleware
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+
+// Simple GET endpoint
+app.MapGet("/api/products", async (IProductService service) =>
+{
+    var products = await service.GetAllAsync();
+    return Results.Ok(products);
+});
+
+// GET with route parameter
+app.MapGet("/api/products/{id:int}", async (int id, IProductService service) =>
+{
+    var product = await service.GetByIdAsync(id);
+    return product is not null
+        ? Results.Ok(product)
+        : Results.NotFound();
+});
+
+// POST with validation
+app.MapPost("/api/products", async (
+    [FromBody] CreateProductRequest request,
+    IProductService service) =>
+{
+    var product = await service.CreateAsync(request);
+    return Results.Created($"/api/products/{product.Id}", product);
+})
+.WithName("CreateProduct")
+.Produces<ProductResponse>(StatusCodes.Status201Created)
+.ProducesValidationProblem();
+
+// PUT endpoint
+app.MapPut("/api/products/{id:int}", async (
+    int id,
+    [FromBody] UpdateProductRequest request,
+    IProductService service) =>
+{
+    var success = await service.UpdateAsync(id, request);
+    return success ? Results.NoContent() : Results.NotFound();
+});
+
+// DELETE endpoint
+app.MapDelete("/api/products/{id:int}", async (int id, IProductService service) =>
+{
+    await service.DeleteAsync(id);
+    return Results.NoContent();
+});
+
+app.Run();
+```
+
+## Route Groups
+
+```csharp
+var app = builder.Build();
+
+var api = app.MapGroup("/api")
+    .WithOpenApi()
+    .RequireAuthorization();
+
+var products = api.MapGroup("/products")
+    .WithTags("Products");
+
+products.MapGet("/", GetAllProducts);
+products.MapGet("/{id:int}", GetProductById);
+products.MapPost("/", CreateProduct);
+products.MapPut("/{id:int}", UpdateProduct);
+products.MapDelete("/{id:int}", DeleteProduct);
+
+static async Task<IResult> GetAllProducts(IProductService service)
+{
+    var products = await service.GetAllAsync();
+    return Results.Ok(products);
+}
+
+static async Task<IResult> GetProductById(int id, IProductService service)
+{
+    var product = await service.GetByIdAsync(id);
+    return product is not null ? Results.Ok(product) : Results.NotFound();
+}
+```
+
+## Filters and Validation
+
+```csharp
+using FluentValidation;
+
+// Request DTO with validation
+public record CreateProductRequest(
+    string Name,
+    string Description,
+    decimal Price,
+    int CategoryId
+);
+
+public class CreateProductValidator : AbstractValidator<CreateProductRequest>
+{
+    public CreateProductValidator()
+    {
+        RuleFor(x => x.Name)
+            .NotEmpty()
+            .MaximumLength(100);
+
+        RuleFor(x => x.Price)
+            .GreaterThan(0)
+            .LessThan(1000000);
+
+        RuleFor(x => x.CategoryId)
+            .GreaterThan(0);
+    }
+}
+
+// Endpoint filter for validation
+public class ValidationFilter<T> : IEndpointFilter where T : class
+{
+    private readonly IValidator<T> _validator;
+
+    public ValidationFilter(IValidator<T> validator)
+    {
+        _validator = validator;
+    }
+
+    public async ValueTask<object?> InvokeAsync(
+        EndpointFilterInvocationContext context,
+        EndpointFilterDelegate next)
+    {
+        var request = context.Arguments.OfType<T>().FirstOrDefault();
+        if (request is null)
+        {
+            return Results.BadRequest("Invalid request");
+        }
+
+        var validationResult = await _validator.ValidateAsync(request);
+        if (!validationResult.IsValid)
+        {
+            return Results.ValidationProblem(
+                validationResult.ToDictionary());
+        }
+
+        return await next(context);
+    }
+}
+
+// Register and use
+builder.Services.AddValidatorsFromAssemblyContaining<Program>();
+
+app.MapPost("/api/products", CreateProduct)
+    .AddEndpointFilter<ValidationFilter<CreateProductRequest>>();
+```
+
+## Dependency Injection
+
+```csharp
+// Service registration
+builder.Services.AddScoped<IProductService, ProductService>();
+builder.Services.AddScoped<IProductRepository, ProductRepository>();
+
+// Multiple parameter binding
+app.MapPost("/api/orders", async (
+    CreateOrderRequest request,
+    IOrderService orderService,
+    IEmailService emailService,
+    ILogger<Program> logger,
+    CancellationToken ct) =>
+{
+    logger.LogInformation("Creating order for {CustomerId}", request.CustomerId);
+
+    var order = await orderService.CreateAsync(request, ct);
+    await emailService.SendOrderConfirmationAsync(order.Id, ct);
+
+    return Results.Created($"/api/orders/{order.Id}", order);
+});
+```
+
+## Response Patterns
+
+```csharp
+// Typed responses
+public record ProductResponse(
+    int Id,
+    string Name,
+    string Description,
+    decimal Price,
+    string CategoryName
+);
+
+// Results.Ok with typed response
+app.MapGet("/api/products/{id:int}", async (int id, IProductService service) =>
+{
+    var product = await service.GetByIdAsync(id);
+    return product is not null
+        ? Results.Ok(product)
+        : Results.NotFound(new { Message = "Product not found" });
+})
+.Produces<ProductResponse>(StatusCodes.Status200OK)
+.Produces(StatusCodes.Status404NotFound);
+
+// Custom result type
+public class PagedResult<T>
+{
+    public required List<T> Items { get; init; }
+    public required int TotalCount { get; init; }
+    public required int Page { get; init; }
+    public required int PageSize { get; init; }
+}
+
+app.MapGet("/api/products", async (
+    [AsParameters] PaginationParams pagination,
+    IProductService service) =>
+{
+    var result = await service.GetPagedAsync(
+        pagination.Page,
+        pagination.PageSize);
+    return Results.Ok(result);
+})
+.Produces<PagedResult<ProductResponse>>();
+
+public record PaginationParams(int Page = 1, int PageSize = 10);
+```
+
+## Error Handling
+
+```csharp
+// Global exception handler
+app.UseExceptionHandler(exceptionHandlerApp =>
+{
+    exceptionHandlerApp.Run(async context =>
+    {
+        var exceptionHandlerFeature =
+            context.Features.Get<IExceptionHandlerFeature>();
+        var exception = exceptionHandlerFeature?.Error;
+
+        var problemDetails = new ProblemDetails
+        {
+            Status = StatusCodes.Status500InternalServerError,
+            Title = "An error occurred",
+            Detail = exception?.Message
+        };
+
+        context.Response.StatusCode = StatusCodes.Status500InternalServerError;
+        await context.Response.WriteAsJsonAsync(problemDetails);
+    });
+});
+
+// Custom endpoint filter for error handling
+public class ErrorHandlingFilter : IEndpointFilter
+{
+    private readonly ILogger<ErrorHandlingFilter> _logger;
+
+    public ErrorHandlingFilter(ILogger<ErrorHandlingFilter> logger)
+    {
+        _logger = logger;
+    }
+
+    public async ValueTask<object?> InvokeAsync(
+        EndpointFilterInvocationContext context,
+        EndpointFilterDelegate next)
+    {
+        try
+        {
+            return await next(context);
+        }
+        catch (ValidationException ex)
+        {
+            _logger.LogWarning(ex, "Validation failed");
+            return Results.ValidationProblem(ex.Errors.ToDictionary(
+                e => e.PropertyName,
+                e => new[] { e.ErrorMessage }
+            ));
+        }
+        catch (NotFoundException ex)
+        {
+            _logger.LogWarning(ex, "Resource not found");
+            return Results.NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Unhandled exception");
+            return Results.Problem("An unexpected error occurred");
+        }
+    }
+}
+```
+
+## Quick Reference
+
+| Pattern | Usage |
+|---------|-------|
+| `Results.Ok(data)` | 200 with response body |
+| `Results.Created(uri, data)` | 201 with location header |
+| `Results.NoContent()` | 204 no response body |
+| `Results.BadRequest()` | 400 validation error |
+| `Results.NotFound()` | 404 resource not found |
+| `Results.Unauthorized()` | 401 authentication required |
+| `Results.Forbid()` | 403 authorization failed |
+| `app.MapGroup()` | Group related endpoints |
+| `.WithTags()` | OpenAPI tag grouping |
+| `.Produces<T>()` | Document response type |

package/skills/frontend/angular-architect/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: angular-architect
+description: Generates Angular 17+ standalone components, configures advanced routing with lazy loading and guards, implements NgRx state management, applies RxJS patterns, and optimizes bundle performance. Use when building Angular 17+ applications with standalone components or signals, setting up NgRx stores, establishing RxJS reactive patterns, performance tuning, or writing Angular tests for enterprise apps.
+license: MIT
+metadata:
+  author: https://github.com/Jeffallan
+  version: "1.1.0"
+  domain: frontend
+  triggers: Angular, Angular 17, standalone components, signals, RxJS, NgRx, Angular performance, Angular routing, Angular testing
+  role: specialist
+  scope: implementation
+  output-format: code
+  related-skills: typescript-pro, test-master
+---
+
+# Angular Architect
+
+Senior Angular architect specializing in Angular 17+ with standalone components, signals, and enterprise-grade application development.
+
+## Core Workflow
+
+1. **Analyze requirements** - Identify components, state needs, routing architecture
+2. **Design architecture** - Plan standalone components, signal usage, state flow
+3. **Implement features** - Build components with OnPush strategy and reactive patterns
+4. **Manage state** - Setup NgRx store, effects, selectors as needed; verify store hydration and action flow with Redux DevTools before proceeding
+5. **Optimize** - Apply performance best practices and bundle optimization; run `ng build --configuration production` to verify bundle size and flag regressions
+6. **Test** - Write unit and integration tests with TestBed; verify >85% coverage threshold is met
+
+## Reference Guide
+
+Load detailed guidance based on context:
+
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Components | `references/components.md` | Standalone components, signals, input/output |
+| RxJS | `references/rxjs.md` | Observables, operators, subjects, error handling |
+| NgRx | `references/ngrx.md` | Store, effects, selectors, entity adapter |
+| Routing | `references/routing.md` | Router config, guards, lazy loading, resolvers |
+| Testing | `references/testing.md` | TestBed, component tests, service tests |
+
+## Key Patterns
+
+### Standalone Component with OnPush and Signals
+
+```typescript
+import { ChangeDetectionStrategy, Component, computed, input, output, signal } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+@Component({
+  selector: 'app-user-card',
+  standalone: true,
+  imports: [CommonModule],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `
+    <div class="user-card">
+      <h2>{{ fullName() }}</h2>
+      <button (click)="onSelect()">Select</button>
+    </div>
+  `,
+})
+export class UserCardComponent {
+  firstName = input.required<string>();
+  lastName = input.required<string>();
+  selected = output<string>();
+
+  fullName = computed(() => `${this.firstName()} ${this.lastName()}`);
+
+  onSelect(): void {
+    this.selected.emit(this.fullName());
+  }
+}
+```
+
+### RxJS Subscription Management with `takeUntilDestroyed`
+
+```typescript
+import { Component, OnInit, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { UserService } from './user.service';
+
+@Component({ selector: 'app-users', standalone: true, template: `...` })
+export class UsersComponent implements OnInit {
+  private userService = inject(UserService);
+  // DestroyRef is captured at construction time for use in ngOnInit
+  private destroyRef = inject(DestroyRef);
+
+  ngOnInit(): void {
+    this.userService.getUsers()
+      .pipe(takeUntilDestroyed(this.destroyRef))
+      .subscribe({
+        next: (users) => { /* handle */ },
+        error: (err) => console.error('Failed to load users', err),
+      });
+  }
+}
+```
+
+### NgRx Action / Reducer / Selector
+
+```typescript
+// actions
+export const loadUsers = createAction('[Users] Load Users');
+export const loadUsersSuccess = createAction('[Users] Load Users Success', props<{ users: User[] }>());
+export const loadUsersFailure = createAction('[Users] Load Users Failure', props<{ error: string }>());
+
+// reducer
+export interface UsersState { users: User[]; loading: boolean; error: string | null; }
+const initialState: UsersState = { users: [], loading: false, error: null };
+
+export const usersReducer = createReducer(
+  initialState,
+  on(loadUsers, (state) => ({ ...state, loading: true, error: null })),
+  on(loadUsersSuccess, (state, { users }) => ({ ...state, users, loading: false })),
+  on(loadUsersFailure, (state, { error }) => ({ ...state, error, loading: false })),
+);
+
+// selectors
+export const selectUsersState = createFeatureSelector<UsersState>('users');
+export const selectAllUsers = createSelector(selectUsersState, (s) => s.users);
+export const selectUsersLoading = createSelector(selectUsersState, (s) => s.loading);
+```
+
+## Constraints
+
+### MUST DO
+- Use standalone components (Angular 17+ default)
+- Use signals for reactive state where appropriate
+- Use OnPush change detection strategy
+- Use strict TypeScript configuration
+- Implement proper error handling in RxJS streams
+- Use `trackBy` functions in `*ngFor` loops
+- Write tests with >85% coverage
+- Follow Angular style guide
+
+### MUST NOT DO
+- Use NgModule-based components (except when required for compatibility)
+- Forget to unsubscribe from observables (use `takeUntilDestroyed` or `async` pipe)
+- Use async operations without proper error handling
+- Skip accessibility attributes
+- Expose sensitive data in client-side code
+- Use `any` type without justification
+- Mutate state directly in NgRx
+- Skip unit tests for critical logic
+
+## Output Templates
+
+When implementing Angular features, provide:
+1. Component file with standalone configuration
+2. Service file if business logic is involved
+3. State management files if using NgRx
+4. Test file with comprehensive test cases
+5. Brief explanation of architectural decisions