omgkit 2.1.1 → 2.3.0

package/plugin/skills/frameworks/laravel/SKILL.md

@@ -1,65 +1,178 @@
 ---
-name: laravel
-description: Laravel PHP development. Use for Laravel projects, Eloquent, Blade.
+name: building-laravel-apis
+description: Builds enterprise Laravel applications with Eloquent, API Resources, Sanctum auth, and queue processing. Use when creating PHP backends, REST APIs, or full-stack Laravel applications.
 ---
 
-# Laravel Skill
+# Laravel
 
-## Patterns
+## Quick Start
 
-### Model
 ```php
-class User extends Model
+// routes/api.php
+Route::get('/health', fn () => ['status' => 'ok']);
+
+Route::middleware('auth:sanctum')->group(function () {
+    Route::apiResource('users', UserController::class);
+});
+```
+
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Models | Eloquent ORM, relationships, scopes | [MODELS.md](MODELS.md) |
+| Controllers | Resource controllers, form requests | [CONTROLLERS.md](CONTROLLERS.md) |
+| API Resources | Response transformation | [RESOURCES.md](RESOURCES.md) |
+| Auth | Sanctum, policies, gates | [AUTH.md](AUTH.md) |
+| Queues | Jobs, events, listeners | [QUEUES.md](QUEUES.md) |
+| Testing | Feature, unit tests | [TESTING.md](TESTING.md) |
+
+## Common Patterns
+
+### Model with Relationships
+
+```php
+class User extends Authenticatable
 {
-    protected $fillable = ['email', 'password'];
-    protected $hidden = ['password'];
+    use HasApiTokens, HasFactory, SoftDeletes;
+
+    protected $fillable = ['name', 'email', 'password', 'role'];
+    protected $hidden = ['password', 'remember_token'];
+    protected $casts = ['email_verified_at' => 'datetime', 'password' => 'hashed'];
+
+    public function organizations(): BelongsToMany
+    {
+        return $this->belongsToMany(Organization::class, 'memberships')
+            ->withPivot('role')
+            ->withTimestamps();
+    }
+
+    public function scopeActive($query)
+    {
+        return $query->where('is_active', true);
+    }
 
-    public function posts()
+    public function scopeSearch($query, ?string $search)
     {
-        return $this->hasMany(Post::class);
+        return $search
+            ? $query->where('name', 'like', "%{$search}%")
+                    ->orWhere('email', 'like', "%{$search}%")
+            : $query;
     }
 }
 ```
 
-### Controller
+### Controller with Service
+
 ```php
 class UserController extends Controller
 {
-    public function index()
+    public function __construct(private UserService $userService) {}
+
+    public function index(Request $request): PaginatedCollection
     {
-        return User::all();
+        $users = $this->userService->list(
+            search: $request->input('search'),
+            perPage: $request->input('per_page', 20)
+        );
+        return new PaginatedCollection($users, UserResource::class);
     }
 
-    public function store(Request $request)
+    public function store(CreateUserRequest $request): JsonResponse
     {
-        $validated = $request->validate([
-            'email' => 'required|email|unique:users',
-            'password' => 'required|min:8',
-        ]);
+        $user = $this->userService->create($request->validated());
+        return (new UserResource($user))
+            ->response()
+            ->setStatusCode(201);
+    }
 
-        $user = User::create($validated);
-        return response()->json($user, 201);
+    public function show(User $user): UserResource
+    {
+        return new UserResource($user->load('organizations'));
     }
 }
 ```
 
-### Routes
+### Form Request Validation
+
 ```php
-Route::apiResource('users', UserController::class);
+class CreateUserRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return $this->user()->isAdmin();
+    }
+
+    public function rules(): array
+    {
+        return [
+            'name' => ['required', 'string', 'min:2', 'max:100'],
+            'email' => ['required', 'email', 'unique:users,email'],
+            'password' => ['required', 'confirmed', Password::min(8)->mixedCase()->numbers()],
+            'role' => ['sometimes', 'in:admin,user,guest'],
+        ];
+    }
+}
 ```
 
-### Migration
+## Workflows
+
+### API Development
+
+1. Create model and migration
+2. Create controller with `php artisan make:controller --api`
+3. Add Form Request for validation
+4. Create API Resource for responses
+5. Write feature tests
+
+### Resource Response
+
 ```php
-Schema::create('users', function (Blueprint $table) {
-    $table->id();
-    $table->string('email')->unique();
-    $table->string('password');
-    $table->timestamps();
-});
+class UserResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'name' => $this->name,
+            'email' => $this->email,
+            'organizations' => OrganizationResource::collection($this->whenLoaded('organizations')),
+            'created_at' => $this->created_at->toIso8601String(),
+        ];
+    }
+}
 ```
 
 ## Best Practices
-- Use Eloquent relationships
-- Use Form Requests
-- Use Resources for API responses
-- Use Jobs for async
+
+| Do | Avoid |
+|----|-------|
+| Use Form Requests for validation | Validating in controllers |
+| Use API Resources for responses | Returning models directly |
+| Use service classes for logic | Fat controllers |
+| Use eager loading | N+1 queries |
+| Use soft deletes | Hard deletes for important data |
+
+## Project Structure
+
+```
+app/
+├── Http/
+│   ├── Controllers/Api/
+│   ├── Requests/
+│   ├── Resources/
+│   └── Middleware/
+├── Models/
+├── Services/
+├── Policies/
+├── Jobs/
+└── Events/
+routes/
+├── api.php
+└── web.php
+tests/
+├── Feature/
+└── Unit/
+```
+
+For detailed examples and patterns, see reference files above.

package/plugin/skills/frameworks/nestjs/SKILL.md

@@ -1,32 +1,63 @@
 ---
-name: nestjs
-description: NestJS development. Use for NestJS projects, modules, dependency injection.
+name: building-nestjs-apis
+description: Builds enterprise NestJS applications with TypeScript, dependency injection, TypeORM, and microservices patterns. Use when creating scalable Node.js backends, REST/GraphQL APIs, or microservices.
 ---
 
-# NestJS Skill
+# NestJS
 
-## Patterns
+## Quick Start
 
-### Module
 ```typescript
-@Module({
-  imports: [DatabaseModule],
-  controllers: [UsersController],
-  providers: [UsersService],
-  exports: [UsersService],
-})
-export class UsersModule {}
+import { Controller, Get, Module, NestFactory } from '@nestjs/common';
+
+@Controller('health')
+class HealthController {
+  @Get()
+  check() {
+    return { status: 'ok' };
+  }
+}
+
+@Module({ controllers: [HealthController] })
+class AppModule {}
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+}
+bootstrap();
 ```
 
-### Controller
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Modules | Dependency injection, providers | [MODULES.md](MODULES.md) |
+| Controllers | Routes, validation, guards | [CONTROLLERS.md](CONTROLLERS.md) |
+| Services | Business logic, repositories | [SERVICES.md](SERVICES.md) |
+| Database | TypeORM, Prisma integration | [DATABASE.md](DATABASE.md) |
+| Auth | Passport, JWT, guards | [AUTH.md](AUTH.md) |
+| Testing | Unit, e2e with Jest | [TESTING.md](TESTING.md) |
+
+## Common Patterns
+
+### Controller with Validation
+
 ```typescript
 @Controller('users')
+@UseGuards(JwtAuthGuard)
 export class UsersController {
-  constructor(private usersService: UsersService) {}
+  constructor(private readonly usersService: UsersService) {}
 
   @Get()
-  findAll() {
-    return this.usersService.findAll();
+  @Roles('admin')
+  findAll(@Query() query: PaginationDto) {
+    return this.usersService.findAll(query);
+  }
+
+  @Get(':id')
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.usersService.findOne(id);
   }
 
   @Post()
@@ -36,32 +67,113 @@ export class UsersController {
 }
 ```
 
-### Service
+### Service with Repository
+
 ```typescript
 @Injectable()
 export class UsersService {
-  constructor(private db: DatabaseService) {}
+  constructor(private readonly usersRepo: UsersRepository) {}
+
+  async findAll(query: PaginationDto) {
+    const [users, total] = await this.usersRepo.findAllWithCount({
+      skip: query.skip,
+      take: query.limit,
+    });
+    return { data: users, total, page: query.page };
+  }
+
+  async findOne(id: string) {
+    const user = await this.usersRepo.findOne({ where: { id } });
+    if (!user) throw new NotFoundException('User not found');
+    return user;
+  }
 
-  async findAll() {
-    return this.db.users.findMany();
+  async create(dto: CreateUserDto) {
+    const exists = await this.usersRepo.findByEmail(dto.email);
+    if (exists) throw new ConflictException('Email in use');
+    return this.usersRepo.save(this.usersRepo.create(dto));
   }
 }
 ```
 
-### DTO
+### DTO with Validation
+
 ```typescript
 export class CreateUserDto {
   @IsEmail()
   email: string;
 
+  @IsString()
+  @MinLength(2)
+  name: string;
+
   @IsString()
   @MinLength(8)
+  @Matches(/^(?=.*[A-Z])(?=.*\d)/, {
+    message: 'Password must contain uppercase and number',
+  })
   password: string;
+
+  @IsOptional()
+  @IsEnum(UserRole)
+  role?: UserRole;
 }
 ```
 
+## Workflows
+
+### API Development
+
+1. Create module with `nest g module [name]`
+2. Create controller and service
+3. Define DTOs with class-validator
+4. Add guards for auth/roles
+5. Write unit and e2e tests
+
+### Module Structure
+
+```typescript
+@Module({
+  imports: [TypeOrmModule.forFeature([User])],
+  controllers: [UsersController],
+  providers: [UsersService, UsersRepository],
+  exports: [UsersService],
+})
+export class UsersModule {}
+```
+
 ## Best Practices
-- Use modules for organization
-- Use DTOs for validation
-- Use dependency injection
-- Use guards for auth
+
+| Do | Avoid |
+|----|-------|
+| Use dependency injection | Direct instantiation |
+| Validate with DTOs | Trusting input |
+| Use guards for auth | Auth logic in controllers |
+| Use interceptors for cross-cutting | Duplicating logging/transform |
+| Write unit + e2e tests | Skipping test coverage |
+
+## Project Structure
+
+```
+src/
+├── main.ts
+├── app.module.ts
+├── common/
+│   ├── decorators/
+│   ├── guards/
+│   ├── interceptors/
+│   └── pipes/
+├── config/
+├── users/
+│   ├── users.module.ts
+│   ├── users.controller.ts
+│   ├── users.service.ts
+│   ├── dto/
+│   └── entities/
+└── auth/
+    ├── auth.module.ts
+    ├── strategies/
+    └── guards/
+```
+
+For detailed examples and patterns, see reference files above.