spoonfeeder 0.1.0

package/templates/recipes/auth-flows/README.md

@@ -0,0 +1,91 @@
+# Auth Flows
+
+Complete signup, email verification, and password reset flows for NestJS applications.
+
+## Links
+
+- [NestJS Authentication Documentation](https://docs.nestjs.com/security/authentication)
+- [bcrypt on npm](https://www.npmjs.com/package/bcrypt)
+- [bcrypt on GitHub](https://github.com/kelektiv/node.bcrypt.js)
+- [uuid on npm](https://www.npmjs.com/package/uuid)
+
+## Dependencies
+
+| Package         | Version  | Purpose                           |
+| --------------- | -------- | --------------------------------- |
+| `bcrypt`        | `6.0.0`  | Password hashing                  |
+| `uuid`          | `11.1.0` | Unique token generation           |
+| `@types/bcrypt` | `5.0.2`  | TypeScript definitions for bcrypt |
+
+## Environment Variables
+
+| Variable                      | Default                                | Description                           |
+| ----------------------------- | -------------------------------------- | ------------------------------------- |
+| `AUTH_JWT_SECRET`             | `change-me-in-production`              | JWT secret for auth flow tokens       |
+| `AUTH_EMAIL_VERIFICATION_URL` | `http://localhost:3000/verify-email`   | Base URL for email verification links |
+| `AUTH_PASSWORD_RESET_URL`     | `http://localhost:3000/reset-password` | Base URL for password reset links     |
+
+## Requires
+
+- **jwt-auth** -- this recipe depends on `@nestjs/jwt` being available.
+
+## Usage Flow
+
+```
+1. Signup
+   POST /auth/signup  { email, password, name }
+       |
+       v
+   User created (emailVerified = false)
+   Verification email sent with token
+       |
+       v
+2. Verify Email
+   POST /auth/verify-email?token=<token>
+       |
+       v
+   emailVerified = true
+
+3. Login
+   POST /auth/login  { email, password }
+       |
+       v
+   Returns { accessToken }
+
+4. Forgot Password
+   POST /auth/forgot-password  { email }
+       |
+       v
+   Reset email sent with token (if user exists)
+       |
+       v
+5. Reset Password
+   POST /auth/reset-password  { token, newPassword }
+       |
+       v
+   Password updated, reset token cleared
+```
+
+## Wiring Into Production
+
+The generated `AuthFlowService` uses an in-memory user store and logs emails
+to the console. Before deploying you must:
+
+1. **Replace the in-memory store** -- inject your `UserRepository` (TypeORM,
+   Prisma, Mongoose, etc.) and persist users to a real database.
+2. **Inject an email service** -- replace `sendVerificationEmail` and
+   `sendPasswordResetEmail` with calls to Nodemailer, SendGrid, SES, or
+   whichever transport your project uses.
+3. **Register `AuthFlowModule`** in your root `AppModule` imports.
+
+## Generated Files
+
+| File                                              | Description                                     |
+| ------------------------------------------------- | ----------------------------------------------- |
+| `src/app/modules/auth/auth.module.ts`             | Auth flow module                                |
+| `src/app/modules/auth/auth.service.ts`            | Service with signup, login, verify, reset logic |
+| `src/app/modules/auth/auth.controller.ts`         | REST endpoints for all auth flows               |
+| `src/app/modules/auth/dto/signup.dto.ts`          | Signup request validation                       |
+| `src/app/modules/auth/dto/login.dto.ts`           | Login request validation                        |
+| `src/app/modules/auth/dto/forgot-password.dto.ts` | Forgot-password request validation              |
+| `src/app/modules/auth/dto/reset-password.dto.ts`  | Reset-password request validation               |

package/templates/recipes/auth-flows/src/app/modules/auth/auth.controller.ts

@@ -0,0 +1,44 @@
+import { Controller, Post, Body, Query, HttpCode, HttpStatus } from '@nestjs/common';
+
+import { AuthFlowService } from './auth.service';
+import { SignupDto } from './dto/signup.dto';
+import { LoginDto } from './dto/login.dto';
+import { ForgotPasswordDto } from './dto/forgot-password.dto';
+import { ResetPasswordDto } from './dto/reset-password.dto';
+
+@Controller('auth')
+export class AuthFlowController {
+  constructor(private readonly authFlowService: AuthFlowService) {}
+
+  @Post('signup')
+  async signup(@Body() dto: SignupDto) {
+    return this.authFlowService.signup(dto);
+  }
+
+  @Post('login')
+  @HttpCode(HttpStatus.OK)
+  async login(@Body() dto: LoginDto) {
+    return this.authFlowService.login(dto);
+  }
+
+  @Post('verify-email')
+  @HttpCode(HttpStatus.OK)
+  async verifyEmail(@Query('token') token: string) {
+    await this.authFlowService.verifyEmail(token);
+    return { message: 'Email verified successfully' };
+  }
+
+  @Post('forgot-password')
+  @HttpCode(HttpStatus.OK)
+  async forgotPassword(@Body() dto: ForgotPasswordDto) {
+    await this.authFlowService.forgotPassword(dto.email);
+    return { message: 'If the email exists, a reset link has been sent' };
+  }
+
+  @Post('reset-password')
+  @HttpCode(HttpStatus.OK)
+  async resetPassword(@Body() dto: ResetPasswordDto) {
+    await this.authFlowService.resetPassword(dto.token, dto.newPassword);
+    return { message: 'Password reset successfully' };
+  }
+}

package/templates/recipes/auth-flows/src/app/modules/auth/auth.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+
+import { AuthFlowService } from './auth.service';
+import { AuthFlowController } from './auth.controller';
+
+@Module({
+  controllers: [AuthFlowController],
+  providers: [AuthFlowService],
+  exports: [AuthFlowService],
+})
+export class AuthFlowModule {}

package/templates/recipes/auth-flows/src/app/modules/auth/auth.service.ts

@@ -0,0 +1,194 @@
+import {
+  Injectable,
+  ConflictException,
+  UnauthorizedException,
+  BadRequestException,
+  Logger,
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import * as bcrypt from 'bcrypt';
+import { v4 as uuidv4 } from 'uuid';
+
+import { SignupDto } from './dto/signup.dto';
+import { LoginDto } from './dto/login.dto';
+
+/**
+ * Scaffold user record. Replace with your own User entity / repository.
+ */
+interface UserRecord {
+  id: string;
+  email: string;
+  name: string;
+  passwordHash: string;
+  emailVerified: boolean;
+  emailVerificationToken: string | null;
+  passwordResetToken: string | null;
+  passwordResetExpires: Date | null;
+}
+
+const BCRYPT_SALT_ROUNDS = 12;
+
+/**
+ * AuthFlowService provides complete signup, login, email-verification,
+ * and password-reset flows.
+ *
+ * **Before going to production** you must:
+ * 1. Replace the in-memory `users` map with a real UserRepository.
+ * 2. Inject a mail / notification service and send real emails in
+ *    `sendVerificationEmail` and `sendPasswordResetEmail`.
+ */
+@Injectable()
+export class AuthFlowService {
+  private readonly logger = new Logger(AuthFlowService.name);
+
+  /**
+   * In-memory store -- replace with your database repository.
+   */
+  private readonly users = new Map<string, UserRecord>();
+
+  constructor(private readonly jwtService: JwtService) {}
+
+  /* ------------------------------------------------------------------ */
+  /*  Signup                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async signup(dto: SignupDto): Promise<{ id: string; email: string }> {
+    const existing = this.findByEmail(dto.email);
+    if (existing) {
+      throw new ConflictException('Email already registered');
+    }
+
+    const passwordHash = await bcrypt.hash(dto.password, BCRYPT_SALT_ROUNDS);
+    const verificationToken = uuidv4();
+
+    const user: UserRecord = {
+      id: uuidv4(),
+      email: dto.email.toLowerCase().trim(),
+      name: dto.name,
+      passwordHash,
+      emailVerified: false,
+      emailVerificationToken: verificationToken,
+      passwordResetToken: null,
+      passwordResetExpires: null,
+    };
+
+    this.users.set(user.id, user);
+
+    await this.sendVerificationEmail(user.email, verificationToken);
+
+    return { id: user.id, email: user.email };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Login                                                              */
+  /* ------------------------------------------------------------------ */
+
+  async login(dto: LoginDto): Promise<{ accessToken: string }> {
+    const user = this.findByEmail(dto.email);
+    if (!user) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    const passwordValid = await bcrypt.compare(dto.password, user.passwordHash);
+    if (!passwordValid) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    const payload = { sub: user.id, email: user.email };
+    const accessToken = await this.jwtService.signAsync(payload);
+
+    return { accessToken };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Email Verification                                                 */
+  /* ------------------------------------------------------------------ */
+
+  async verifyEmail(token: string): Promise<void> {
+    const user = this.findByVerificationToken(token);
+    if (!user) {
+      throw new BadRequestException('Invalid or expired verification token');
+    }
+
+    user.emailVerified = true;
+    user.emailVerificationToken = null;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Forgot Password                                                    */
+  /* ------------------------------------------------------------------ */
+
+  async forgotPassword(email: string): Promise<void> {
+    const user = this.findByEmail(email);
+
+    // Always return success to prevent email enumeration
+    if (!user) {
+      return;
+    }
+
+    const resetToken = uuidv4();
+    const resetExpires = new Date(Date.now() + 60 * 60 * 1000); // 1 hour
+
+    user.passwordResetToken = resetToken;
+    user.passwordResetExpires = resetExpires;
+
+    await this.sendPasswordResetEmail(user.email, resetToken);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Reset Password                                                     */
+  /* ------------------------------------------------------------------ */
+
+  async resetPassword(token: string, newPassword: string): Promise<void> {
+    const user = this.findByResetToken(token);
+    if (!user || !user.passwordResetExpires || user.passwordResetExpires < new Date()) {
+      throw new BadRequestException('Invalid or expired reset token');
+    }
+
+    user.passwordHash = await bcrypt.hash(newPassword, BCRYPT_SALT_ROUNDS);
+    user.passwordResetToken = null;
+    user.passwordResetExpires = null;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Private helpers                                                    */
+  /* ------------------------------------------------------------------ */
+
+  private findByEmail(email: string): UserRecord | undefined {
+    const normalised = email.toLowerCase().trim();
+    for (const user of this.users.values()) {
+      if (user.email === normalised) return user;
+    }
+    return undefined;
+  }
+
+  private findByVerificationToken(token: string): UserRecord | undefined {
+    for (const user of this.users.values()) {
+      if (user.emailVerificationToken === token) return user;
+    }
+    return undefined;
+  }
+
+  private findByResetToken(token: string): UserRecord | undefined {
+    for (const user of this.users.values()) {
+      if (user.passwordResetToken === token) return user;
+    }
+    return undefined;
+  }
+
+  /**
+   * Replace with your email / notification service.
+   */
+  private async sendVerificationEmail(email: string, token: string): Promise<void> {
+    const url = `${process.env.AUTH_EMAIL_VERIFICATION_URL}?token=${token}`;
+    this.logger.log(`[SCAFFOLD] Verification email for ${email}: ${url}`);
+  }
+
+  /**
+   * Replace with your email / notification service.
+   */
+  private async sendPasswordResetEmail(email: string, token: string): Promise<void> {
+    const url = `${process.env.AUTH_PASSWORD_RESET_URL}?token=${token}`;
+    this.logger.log(`[SCAFFOLD] Password reset email for ${email}: ${url}`);
+  }
+}

package/templates/recipes/auth-flows/src/app/modules/auth/dto/forgot-password.dto.ts

@@ -0,0 +1,6 @@
+import { IsEmail } from 'class-validator';
+
+export class ForgotPasswordDto {
+  @IsEmail()
+  email: string;
+}

package/templates/recipes/auth-flows/src/app/modules/auth/dto/login.dto.ts

@@ -0,0 +1,9 @@
+import { IsEmail, IsString } from 'class-validator';
+
+export class LoginDto {
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  password: string;
+}

package/templates/recipes/auth-flows/src/app/modules/auth/dto/reset-password.dto.ts

@@ -0,0 +1,11 @@
+import { IsString, MinLength, MaxLength } from 'class-validator';
+
+export class ResetPasswordDto {
+  @IsString()
+  token: string;
+
+  @IsString()
+  @MinLength(8)
+  @MaxLength(128)
+  newPassword: string;
+}

package/templates/recipes/auth-flows/src/app/modules/auth/dto/signup.dto.ts

@@ -0,0 +1,16 @@
+import { IsEmail, IsString, MinLength, MaxLength } from 'class-validator';
+
+export class SignupDto {
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  @MinLength(8)
+  @MaxLength(128)
+  password: string;
+
+  @IsString()
+  @MinLength(1)
+  @MaxLength(255)
+  name: string;
+}

package/templates/recipes/auth-flows/tests/unit/app/modules/auth/auth.service.spec.ts

@@ -0,0 +1,13 @@
+describe('AuthFlowService', () => {
+  it('should hash passwords during signup', () => {
+    expect(true).toBe(true);
+  });
+
+  it('should validate credentials during login', () => {
+    expect(true).toBe(true);
+  });
+
+  it('should generate verification tokens', () => {
+    expect(true).toBe(true);
+  });
+});

package/templates/recipes/bullmq/README.md

@@ -0,0 +1,54 @@
+# BullMQ
+
+Background job processing using BullMQ with Redis for NestJS applications.
+
+## Links
+
+- [NestJS Queues Documentation](https://docs.nestjs.com/techniques/queues)
+- [BullMQ Documentation](https://docs.bullmq.io)
+- [@nestjs/bullmq on npm](https://www.npmjs.com/package/@nestjs/bullmq)
+- [bullmq on npm](https://www.npmjs.com/package/bullmq)
+- [BullMQ on GitHub](https://github.com/taskforcesh/bullmq)
+
+## Dependencies
+
+| Package          | Version  | Purpose                              |
+| ---------------- | -------- | ------------------------------------ |
+| `@nestjs/bullmq` | `10.2.3` | NestJS BullMQ integration module     |
+| `bullmq`         | `5.34.8` | Modern Redis-based queue for Node.js |
+
+## Environment Variables
+
+| Variable         | Default     | Description               |
+| ---------------- | ----------- | ------------------------- |
+| `REDIS_HOST`     | `localhost` | Redis server hostname     |
+| `REDIS_PORT`     | `6379`      | Redis server port         |
+| `REDIS_PASSWORD` | —           | Redis password (optional) |
+
+## Usage
+
+```typescript
+import { QueueModule } from '@/infrastructure/queue/queue.module';
+
+@Module({
+  imports: [QueueModule],
+})
+export class AppModule {}
+
+// Add a job to the queue
+@Injectable()
+export class EmailSender {
+  constructor(@InjectQueue('example') private exampleQueue: Queue) {}
+
+  async sendWelcomeEmail(userId: string) {
+    await this.exampleQueue.add('send-welcome', { userId });
+  }
+}
+```
+
+## Generated Files
+
+| File                                            | Description                                                |
+| ----------------------------------------------- | ---------------------------------------------------------- |
+| `src/infrastructure/queue/queue.module.ts`      | BullMQ module with Redis connection configuration          |
+| `src/infrastructure/queue/example.processor.ts` | Example job processor demonstrating the @Processor pattern |

package/templates/recipes/bullmq/src/infrastructure/queue/example.processor.ts

@@ -0,0 +1,25 @@
+import { Processor, WorkerHost } from '@nestjs/bullmq';
+import { Logger } from '@nestjs/common';
+import { Job } from 'bullmq';
+
+@Processor('example')
+export class ExampleProcessor extends WorkerHost {
+  private readonly logger = new Logger(ExampleProcessor.name);
+
+  async process(job: Job<unknown, unknown, string>): Promise<void> {
+    this.logger.log(`Processing job ${job.id} of type ${job.name}`);
+    this.logger.debug(`Job data: ${JSON.stringify(job.data)}`);
+
+    switch (job.name) {
+      case 'send-welcome':
+        await this.handleSendWelcome(job);
+        break;
+      default:
+        this.logger.warn(`Unknown job name: ${job.name}`);
+    }
+  }
+
+  private async handleSendWelcome(job: Job): Promise<void> {
+    this.logger.log(`Sending welcome for job ${job.id}`);
+  }
+}

package/templates/recipes/bullmq/src/infrastructure/queue/queue.module.ts

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { BullModule } from '@nestjs/bullmq';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { ExampleProcessor } from './example.processor';
+
+@Module({
+  imports: [
+    BullModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (configService: ConfigService) => ({
+        connection: {
+          host: configService.get<string>('REDIS_HOST', 'localhost'),
+          port: configService.get<number>('REDIS_PORT', 6379),
+          password: configService.get<string>('REDIS_PASSWORD'),
+        },
+      }),
+    }),
+    BullModule.registerQueue({
+      name: 'example',
+    }),
+  ],
+  providers: [ExampleProcessor],
+  exports: [BullModule],
+})
+export class QueueModule {}

package/templates/recipes/bullmq/tests/unit/infrastructure/queue/example.processor.spec.ts

@@ -0,0 +1,17 @@
+import { ExampleProcessor } from '../../../../src/infrastructure/queue/example.processor';
+
+describe('ExampleProcessor', () => {
+  let processor: ExampleProcessor;
+
+  beforeEach(() => {
+    processor = new ExampleProcessor();
+  });
+
+  it('should be defined', () => {
+    expect(processor).toBeDefined();
+  });
+
+  it('should have a process method', () => {
+    expect(typeof processor.process).toBe('function');
+  });
+});

package/templates/recipes/changelog/.changelogrc.json

@@ -0,0 +1,18 @@
+{
+  "preset": "angular",
+  "tagPrefix": "v",
+  "releaseCount": 1,
+  "outputUnreleased": true,
+  "types": [
+    { "type": "feat", "section": "Features" },
+    { "type": "fix", "section": "Bug Fixes" },
+    { "type": "perf", "section": "Performance" },
+    { "type": "refactor", "section": "Refactoring" },
+    { "type": "docs", "section": "Documentation", "hidden": true },
+    { "type": "style", "section": "Styles", "hidden": true },
+    { "type": "test", "section": "Tests", "hidden": true },
+    { "type": "build", "section": "Build", "hidden": true },
+    { "type": "ci", "section": "CI", "hidden": true },
+    { "type": "chore", "section": "Chores", "hidden": true }
+  ]
+}

package/templates/recipes/changelog/README.md

@@ -0,0 +1,44 @@
+# Changelog
+
+Automated changelog generation from Conventional Commits.
+
+## Links
+
+- [conventional-changelog-cli on npm](https://www.npmjs.com/package/conventional-changelog-cli)
+- [conventional-changelog on GitHub](https://github.com/conventional-changelog/conventional-changelog)
+- [Conventional Commits](https://www.conventionalcommits.org/)
+
+## Dependencies
+
+| Package                      | Version | Purpose                         |
+| ---------------------------- | ------- | ------------------------------- |
+| `conventional-changelog-cli` | `5.0.0` | CLI for generating CHANGELOG.md |
+
+## Usage
+
+Add scripts to `package.json`:
+
+```json
+{
+  "scripts": {
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
+    "changelog:first": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0"
+  }
+}
+```
+
+Generate the changelog:
+
+```bash
+# Append new changes
+pnpm changelog
+
+# Generate from scratch (first time)
+pnpm changelog:first
+```
+
+## Generated Files
+
+| File                | Description                        |
+| ------------------- | ---------------------------------- |
+| `.changelogrc.json` | Changelog generation configuration |

package/templates/recipes/ci-cd/README.md

@@ -0,0 +1,14 @@
+# CI/CD
+
+Continuous integration and deployment pipeline templates for NestJS projects.
+
+## Providers
+
+| Provider                                | Description                                        |
+| --------------------------------------- | -------------------------------------------------- |
+| [GitHub Actions](./github-actions/)     | Workflow files for GitHub-hosted CI/CD             |
+| [Azure DevOps](./azure-devops/)         | Stage-based pipeline for Azure DevOps              |
+| [AWS CodePipeline](./aws-codepipeline/) | Build specification for AWS CodeBuild/CodePipeline |
+| [GCP Cloud Build](./gcp-cloudbuild/)    | Pipeline configuration for Google Cloud Build      |
+
+Each provider includes preconfigured pipelines with install, lint, type-check, test, build, and security audit steps.

package/templates/recipes/ci-cd/aws-codepipeline/README.md

@@ -0,0 +1,30 @@
+# AWS CodePipeline
+
+Build specification for AWS CodeBuild, typically used with AWS CodePipeline.
+
+## Documentation
+
+- [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/)
+- [AWS CodeBuild](https://docs.aws.amazon.com/codebuild/)
+- [Build spec reference](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html)
+
+## Generated Files
+
+| File            | Description                       |
+| --------------- | --------------------------------- |
+| `buildspec.yml` | AWS CodeBuild build specification |
+
+## Build Phases
+
+1. **install** -- set up Node.js runtime, install pnpm, install frozen lockfile
+2. **pre_build** -- lint, type-check, unit tests, integration tests
+3. **build** -- compile to `dist/`
+4. **post_build** -- security audit (non-blocking)
+
+## Artifacts
+
+The build produces `dist/`, `package.json`, `pnpm-lock.yaml`, and `node_modules/` as artifacts for downstream deploy actions.
+
+## Caching
+
+`node_modules/` and `.pnpm-store/` are cached between builds to speed up installs.

package/templates/recipes/ci-cd/aws-codepipeline/buildspec.yml

@@ -0,0 +1,41 @@
+version: 0.2
+
+env:
+  variables:
+    NODE_VERSION: '22'
+
+phases:
+  install:
+    runtime-versions:
+      nodejs: $NODE_VERSION
+    commands:
+      - npm install -g pnpm@10
+      - pnpm install --frozen-lockfile
+
+  pre_build:
+    commands:
+      - pnpm lint
+      - pnpm exec tsc --noEmit
+      - pnpm test:unit
+      - pnpm test:integration
+
+  build:
+    commands:
+      - pnpm build
+
+  post_build:
+    commands:
+      - pnpm audit --audit-level=high || true
+
+artifacts:
+  files:
+    - dist/**/*
+    - package.json
+    - pnpm-lock.yaml
+    - node_modules/**/*
+  discard-paths: no
+
+cache:
+  paths:
+    - node_modules/**/*
+    - .pnpm-store/**/*