aigroup-workflow 2.1.2 → 2.2.1

package/skills/nestjs-expert/references/services-di.md

@@ -1,140 +0,0 @@
-# Services & Dependency Injection
-
-## Service Pattern
-
-```typescript
-import { Injectable, Logger, NotFoundException, ConflictException } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-
-@Injectable()
-export class UsersService {
-  private readonly logger = new Logger(UsersService.name);
-
-  constructor(
-    @InjectRepository(User)
-    private readonly repo: Repository<User>,
-    private readonly emailService: EmailService,
-  ) {}
-
-  async create(dto: CreateUserDto): Promise<User> {
-    try {
-      const user = this.repo.create(dto);
-      const saved = await this.repo.save(user);
-      await this.emailService.sendWelcome(saved.email);
-      return saved;
-    } catch (error) {
-      if (error.code === '23505') {
-        throw new ConflictException('Email already exists');
-      }
-      this.logger.error(`Failed to create user: ${error.message}`);
-      throw error;
-    }
-  }
-
-  async findOne(id: string): Promise<User> {
-    const user = await this.repo.findOne({ where: { id } });
-    if (!user) {
-      throw new NotFoundException(`User ${id} not found`);
-    }
-    return user;
-  }
-
-  async update(id: string, dto: UpdateUserDto): Promise<User> {
-    const user = await this.findOne(id);
-    Object.assign(user, dto);
-    return this.repo.save(user);
-  }
-
-  async remove(id: string): Promise<void> {
-    const result = await this.repo.delete(id);
-    if (result.affected === 0) {
-      throw new NotFoundException(`User ${id} not found`);
-    }
-  }
-}
-```
-
-## Module with Providers
-
-```typescript
-@Module({
-  imports: [TypeOrmModule.forFeature([User])],
-  controllers: [UsersController],
-  providers: [UsersService],
-  exports: [UsersService],  // Make available to other modules
-})
-export class UsersModule {}
-```
-
-## Custom Providers
-
-```typescript
-// Value provider
-{ provide: 'API_KEY', useValue: process.env.API_KEY }
-
-// Factory provider
-{
-  provide: 'CONFIG',
-  useFactory: (configService: ConfigService) => ({
-    apiUrl: configService.get('API_URL'),
-  }),
-  inject: [ConfigService],
-}
-
-// Class provider
-{ provide: LoggerService, useClass: CustomLoggerService }
-
-// Async factory
-{
-  provide: 'DATABASE_CONNECTION',
-  useFactory: async () => {
-    const connection = await createConnection();
-    return connection;
-  },
-}
-```
-
-## Injection Patterns
-
-```typescript
-// Constructor injection (preferred)
-constructor(private readonly usersService: UsersService) {}
-
-// Token injection
-constructor(@Inject('API_KEY') private apiKey: string) {}
-
-// Optional injection
-constructor(@Optional() private readonly cache?: CacheService) {}
-
-// Property injection (use sparingly)
-@Inject() private readonly logger: Logger;
-```
-
-## Scope
-
-```typescript
-// Default: Singleton (shared across app)
-@Injectable()
-export class SharedService {}
-
-// Request-scoped: New instance per request
-@Injectable({ scope: Scope.REQUEST })
-export class RequestService {
-  constructor(@Inject(REQUEST) private request: Request) {}
-}
-
-// Transient: New instance every injection
-@Injectable({ scope: Scope.TRANSIENT })
-export class HelperService {}
-```
-
-## Quick Reference
-
-| Pattern | Use When |
-|---------|----------|
-| Constructor DI | Most cases (recommended) |
-| `@Inject(token)` | Non-class tokens |
-| `@Optional()` | Optional dependency |
-| Factory provider | Dynamic configuration |
-| Scope.REQUEST | Per-request state |

package/skills/nestjs-expert/references/testing-patterns.md

@@ -1,186 +0,0 @@
-# Testing Patterns
-
-## Unit Test Setup
-
-```typescript
-import { Test, TestingModule } from '@nestjs/testing';
-import { getRepositoryToken } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import { NotFoundException } from '@nestjs/common';
-
-describe('UsersService', () => {
-  let service: UsersService;
-  let repo: jest.Mocked<Repository<User>>;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        UsersService,
-        {
-          provide: getRepositoryToken(User),
-          useValue: {
-            create: jest.fn(),
-            save: jest.fn(),
-            findOne: jest.fn(),
-            delete: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    service = module.get(UsersService);
-    repo = module.get(getRepositoryToken(User));
-  });
-
-  afterEach(() => jest.clearAllMocks());
-});
-```
-
-## Service Tests
-
-```typescript
-describe('create', () => {
-  it('should create user', async () => {
-    const dto = { email: 'test@test.com', password: 'pass', name: 'Test' };
-    const user = { id: '1', ...dto };
-
-    repo.create.mockReturnValue(user as User);
-    repo.save.mockResolvedValue(user as User);
-
-    const result = await service.create(dto);
-
-    expect(repo.create).toHaveBeenCalledWith(dto);
-    expect(repo.save).toHaveBeenCalledWith(user);
-    expect(result).toEqual(user);
-  });
-});
-
-describe('findOne', () => {
-  it('should return user', async () => {
-    const user = { id: '1', email: 'test@test.com' };
-    repo.findOne.mockResolvedValue(user as User);
-
-    const result = await service.findOne('1');
-    expect(result).toEqual(user);
-  });
-
-  it('should throw NotFoundException', async () => {
-    repo.findOne.mockResolvedValue(null);
-    await expect(service.findOne('1')).rejects.toThrow(NotFoundException);
-  });
-});
-```
-
-## Controller Tests
-
-```typescript
-describe('UsersController', () => {
-  let controller: UsersController;
-  let service: jest.Mocked<UsersService>;
-
-  beforeEach(async () => {
-    const module = await Test.createTestingModule({
-      controllers: [UsersController],
-      providers: [
-        {
-          provide: UsersService,
-          useValue: {
-            create: jest.fn(),
-            findOne: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    controller = module.get(UsersController);
-    service = module.get(UsersService);
-  });
-
-  it('should create user', async () => {
-    const dto = { email: 'test@test.com', password: 'pass', name: 'Test' };
-    const user = { id: '1', ...dto };
-    service.create.mockResolvedValue(user as User);
-
-    const result = await controller.create(dto);
-    expect(result).toEqual(user);
-  });
-});
-```
-
-## E2E Tests
-
-```typescript
-import { INestApplication } from '@nestjs/common';
-import * as request from 'supertest';
-
-describe('UsersController (e2e)', () => {
-  let app: INestApplication;
-  let authToken: string;
-
-  beforeAll(async () => {
-    const moduleFixture = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
-
-    app = moduleFixture.createNestApplication();
-    app.useGlobalPipes(new ValidationPipe({ whitelist: true }));
-    await app.init();
-
-    // Get auth token
-    const response = await request(app.getHttpServer())
-      .post('/auth/login')
-      .send({ email: 'test@test.com', password: 'password' });
-    authToken = response.body.access_token;
-  });
-
-  afterAll(() => app.close());
-
-  it('/users (POST)', () => {
-    return request(app.getHttpServer())
-      .post('/users')
-      .set('Authorization', `Bearer ${authToken}`)
-      .send({ email: 'new@test.com', password: 'Test1234', name: 'New' })
-      .expect(201)
-      .expect((res) => {
-        expect(res.body.email).toBe('new@test.com');
-      });
-  });
-
-  it('/users/:id (GET) - 404', () => {
-    return request(app.getHttpServer())
-      .get('/users/nonexistent-id')
-      .set('Authorization', `Bearer ${authToken}`)
-      .expect(404);
-  });
-});
-```
-
-## Mock Factory
-
-```typescript
-export const createMockRepository = <T>() => ({
-  create: jest.fn(),
-  save: jest.fn(),
-  find: jest.fn(),
-  findOne: jest.fn(),
-  update: jest.fn(),
-  delete: jest.fn(),
-  createQueryBuilder: jest.fn(() => ({
-    where: jest.fn().mockReturnThis(),
-    andWhere: jest.fn().mockReturnThis(),
-    getOne: jest.fn(),
-    getMany: jest.fn(),
-  })),
-});
-```
-
-## Quick Reference
-
-| Pattern | Use Case |
-|---------|----------|
-| `Test.createTestingModule()` | Create test module |
-| `jest.fn()` | Mock function |
-| `mockResolvedValue()` | Mock async return |
-| `mockReturnValue()` | Mock sync return |
-| `supertest` | E2E HTTP testing |
-| `beforeAll` / `afterAll` | Setup/teardown |

package/skills/nextjs-developer/SKILL.md

@@ -1,143 +0,0 @@
----
-name: nextjs-developer
-description: "Use when building Next.js 14+ applications with App Router, server components, or server actions. Invoke to configure route handlers, implement middleware, set up API routes, add streaming SSR, write generateMetadata for SEO, scaffold loading.tsx/error.tsx boundaries, or deploy to Vercel. Triggers on: Next.js, Next.js 14, App Router, RSC, use server, Server Components, Server Actions, React Server Components, generateMetadata, loading.tsx, Next.js deployment, Vercel, Next.js performance."
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: frontend
-  triggers: Next.js, Next.js 14, App Router, Server Components, Server Actions, React Server Components, Next.js deployment, Vercel, Next.js performance
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: typescript-pro
----
-
-# Next.js Developer
-
-Senior Next.js developer with expertise in Next.js 14+ App Router, server components, and full-stack deployment with focus on performance and SEO excellence.
-
-## Core Workflow
-
-1. **Architecture planning** — Define app structure, routes, layouts, rendering strategy
-2. **Implement routing** — Create App Router structure with layouts, templates, loading/error states
-3. **Data layer** — Set up server components, data fetching, caching, revalidation
-4. **Optimize** — Images, fonts, bundles, streaming, edge runtime
-5. **Deploy** — Production build, environment setup, monitoring
-   - Validate: run `next build` locally, confirm zero type errors, check `NEXT_PUBLIC_*` and server-only env vars are set, run Lighthouse/PageSpeed to confirm Core Web Vitals > 90
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| App Router | `references/app-router.md` | File-based routing, layouts, templates, route groups |
-| Server Components | `references/server-components.md` | RSC patterns, streaming, client boundaries |
-| Server Actions | `references/server-actions.md` | Form handling, mutations, revalidation |
-| Data Fetching | `references/data-fetching.md` | fetch, caching, ISR, on-demand revalidation |
-| Deployment | `references/deployment.md` | Vercel, self-hosting, Docker, optimization |
-
-## Constraints
-
-### MUST DO (Next.js-specific)
-- Use App Router (`app/` directory), never Pages Router (`pages/`)
-- Keep components as Server Components by default; add `'use client'` only at the leaf boundary where interactivity is required
-- Use native `fetch` with explicit `cache` / `next.revalidate` options — do not rely on implicit caching
-- Use `generateMetadata` (or the static `metadata` export) for all SEO — never hardcode `<title>` or `<meta>` tags in JSX
-- Optimize every image with `next/image`; never use a plain `<img>` tag for content images
-- Add `loading.tsx` and `error.tsx` at every route segment that performs async data fetching
-
-### MUST NOT DO
-- Convert components to Client Components just to access data — fetch server-side first
-- Skip `loading.tsx`/`error.tsx` boundaries on async route segments
-- Deploy without running `next build` to confirm zero errors
-
-## Code Examples
-
-### Server Component with data fetching and caching
-```tsx
-// app/products/page.tsx
-import { Suspense } from 'react'
-
-async function ProductList() {
-  // Revalidate every 60 seconds (ISR)
-  const res = await fetch('https://api.example.com/products', {
-    next: { revalidate: 60 },
-  })
-  if (!res.ok) throw new Error('Failed to fetch products')
-  const products: Product[] = await res.json()
-
-  return (
-    <ul>
-      {products.map((p) => (
-        <li key={p.id}>{p.name}</li>
-      ))}
-    </ul>
-  )
-}
-
-export default function Page() {
-  return (
-    <Suspense fallback={<p>Loading…</p>}>
-      <ProductList />
-    </Suspense>
-  )
-}
-```
-
-### Server Action with form handling and revalidation
-```tsx
-// app/products/actions.ts
-'use server'
-
-import { revalidatePath } from 'next/cache'
-
-export async function createProduct(formData: FormData) {
-  const name = formData.get('name') as string
-  await db.product.create({ data: { name } })
-  revalidatePath('/products')
-}
-
-// app/products/new/page.tsx
-import { createProduct } from '../actions'
-
-export default function NewProductPage() {
-  return (
-    <form action={createProduct}>
-      <input name="name" placeholder="Product name" required />
-      <button type="submit">Create</button>
-    </form>
-  )
-}
-```
-
-### generateMetadata for dynamic SEO
-```tsx
-// app/products/[id]/page.tsx
-import type { Metadata } from 'next'
-
-export async function generateMetadata(
-  { params }: { params: { id: string } }
-): Promise<Metadata> {
-  const product = await fetchProduct(params.id)
-  return {
-    title: product.name,
-    description: product.description,
-    openGraph: { title: product.name, images: [product.imageUrl] },
-  }
-}
-```
-
-## Output Templates
-
-When implementing Next.js features, provide:
-1. App structure (route organization)
-2. Layout/page components with proper data fetching
-3. Server actions if mutations needed
-4. Configuration (`next.config.js`, TypeScript)
-5. Brief explanation of rendering strategy chosen
-
-## Knowledge Reference
-
-Next.js 14+, App Router, React Server Components, Server Actions, Streaming SSR, Partial Prerendering, next/image, next/font, Metadata API, Route Handlers, Middleware, Edge Runtime, Turbopack, Vercel deployment