spoonfeeder 0.1.0

package/templates/recipes/websockets/src/shared/gateways/events.gateway.ts

@@ -0,0 +1,55 @@
+import {
+  ConnectedSocket,
+  MessageBody,
+  OnGatewayConnection,
+  OnGatewayDisconnect,
+  OnGatewayInit,
+  SubscribeMessage,
+  WebSocketGateway,
+  WebSocketServer,
+} from '@nestjs/websockets';
+import { Logger } from '@nestjs/common';
+import { Server, Socket } from 'socket.io';
+
+@WebSocketGateway({
+  cors: { origin: process.env.CORS_ORIGIN?.split(',') ?? false },
+  namespace: '/events',
+})
+export class EventsGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
+  private readonly logger = new Logger(EventsGateway.name);
+
+  @WebSocketServer()
+  server: Server;
+
+  afterInit(): void {
+    this.logger.log('WebSocket gateway initialised');
+  }
+
+  handleConnection(client: Socket): void {
+    this.logger.log(`Client connected: ${client.id}`);
+  }
+
+  handleDisconnect(client: Socket): void {
+    this.logger.log(`Client disconnected: ${client.id}`);
+  }
+
+  @SubscribeMessage('ping')
+  handlePing(
+    @MessageBody() data: { timestamp: number },
+    @ConnectedSocket() client: Socket,
+  ): { event: string; data: { timestamp: number; serverTime: number } } {
+    this.logger.debug(`Ping from ${client.id}: ${JSON.stringify(data)}`);
+
+    return {
+      event: 'pong',
+      data: {
+        timestamp: data.timestamp,
+        serverTime: Date.now(),
+      },
+    };
+  }
+
+  broadcastEvent(event: string, payload: unknown): void {
+    this.server.emit(event, payload);
+  }
+}

package/templates/recipes/websockets/tests/unit/shared/gateways/events.gateway.spec.ts

@@ -0,0 +1,23 @@
+import { EventsGateway } from '../../../../src/shared/gateways/events.gateway';
+
+describe('EventsGateway', () => {
+  let gateway: EventsGateway;
+
+  beforeEach(() => {
+    gateway = new EventsGateway();
+  });
+
+  it('should be defined', () => {
+    expect(gateway).toBeDefined();
+  });
+
+  it('should have lifecycle hook methods', () => {
+    expect(typeof gateway.afterInit).toBe('function');
+    expect(typeof gateway.handleConnection).toBe('function');
+    expect(typeof gateway.handleDisconnect).toBe('function');
+  });
+
+  it('should have a handlePing method', () => {
+    expect(typeof gateway.handlePing).toBe('function');
+  });
+});

package/templates/recipes/winston/README.md

@@ -0,0 +1,45 @@
+# Winston Logger
+
+Flexible logging using Winston for NestJS applications.
+
+## Links
+
+- [nest-winston on npm](https://www.npmjs.com/package/nest-winston)
+- [nest-winston on GitHub](https://github.com/gremo/nest-winston)
+- [Winston on GitHub](https://github.com/winstonjs/winston)
+- [winston on npm](https://www.npmjs.com/package/winston)
+
+## Dependencies
+
+| Package        | Version  | Purpose                           |
+| -------------- | -------- | --------------------------------- |
+| `nest-winston` | `1.10.2` | NestJS Winston integration module |
+| `winston`      | `3.17.0` | Versatile logging library         |
+
+## Environment Variables
+
+| Variable    | Default       | Description                                                                      |
+| ----------- | ------------- | -------------------------------------------------------------------------------- |
+| `LOG_LEVEL` | `info`        | Minimum log level (`error`, `warn`, `info`, `http`, `verbose`, `debug`, `silly`) |
+| `NODE_ENV`  | `development` | Environment (controls log format)                                                |
+
+## Usage
+
+```typescript
+import { LoggerModule } from '@/infrastructure/logging/logger.module';
+
+@Module({
+  imports: [LoggerModule],
+})
+export class AppModule {}
+
+// In main.ts
+import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
+app.useLogger(app.get(WINSTON_MODULE_NEST_PROVIDER));
+```
+
+## Generated Files
+
+| File                                          | Description                                                                      |
+| --------------------------------------------- | -------------------------------------------------------------------------------- |
+| `src/infrastructure/logging/logger.module.ts` | WinstonModule configured with console transport and environment-aware formatting |

package/templates/recipes/winston/src/infrastructure/logging/logger.module.ts

@@ -0,0 +1,34 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { WinstonModule } from 'nest-winston';
+import * as winston from 'winston';
+
+@Module({
+  imports: [
+    WinstonModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (configService: ConfigService) => ({
+        level: configService.get<string>('LOG_LEVEL', 'info'),
+        transports: [
+          new winston.transports.Console({
+            format:
+              configService.get<string>('NODE_ENV') !== 'production'
+                ? winston.format.combine(
+                    winston.format.timestamp(),
+                    winston.format.colorize(),
+                    winston.format.printf(({ timestamp, level, message, context, ...meta }) => {
+                      const ctx = context ? `[${context}] ` : '';
+                      const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
+                      return `${timestamp} ${level} ${ctx}${message}${metaStr}`;
+                    }),
+                  )
+                : winston.format.combine(winston.format.timestamp(), winston.format.json()),
+          }),
+        ],
+      }),
+    }),
+  ],
+  exports: [WinstonModule],
+})
+export class LoggerModule {}

package/templates/recipes/winston/tests/unit/infrastructure/logging/logger.module.spec.ts

@@ -0,0 +1,12 @@
+import { LoggerModule } from '../../../../src/infrastructure/logging/logger.module';
+
+describe('LoggerModule', () => {
+  it('should be defined', () => {
+    expect(LoggerModule).toBeDefined();
+  });
+
+  it('should be a class that can be referenced as a module', () => {
+    expect(typeof LoggerModule).toBe('function');
+    expect(LoggerModule.name).toBe('LoggerModule');
+  });
+});

package/templates/recipes/worker-threads/README.md

@@ -0,0 +1,71 @@
+# Worker Threads
+
+Offload CPU-intensive tasks to worker threads using the Node.js built-in `worker_threads` module.
+
+## When to Use
+
+Worker threads are appropriate for **CPU-intensive** operations that would block the event loop:
+
+- Image processing and resizing
+- PDF generation
+- Cryptographic operations (hashing, encryption)
+- Data compression
+- Heavy mathematical computations
+- Parsing large files (CSV, XML)
+
+## When NOT to Use
+
+Do **not** use worker threads for I/O-bound work. Node.js already handles these asynchronously:
+
+- Database queries
+- HTTP requests
+- File system reads/writes
+- Message queue operations
+
+## Usage
+
+Inject `WorkerPool` and call `run<T>(script, data)`:
+
+```typescript
+import { WorkerPool } from '@/shared/utils/worker-pool';
+
+@Injectable()
+export class ImageProcessor {
+  constructor(private readonly workerPool: WorkerPool) {}
+
+  async resize(imagePath: string, width: number): Promise<Buffer> {
+    return this.workerPool.run<Buffer>(path.join(__dirname, 'workers/resize.worker.js'), {
+      imagePath,
+      width,
+    });
+  }
+}
+```
+
+### Worker Script
+
+Worker scripts receive data via `workerData` and return results via `parentPort.postMessage()`:
+
+```typescript
+import { parentPort, workerData } from 'node:worker_threads';
+
+const { imagePath, width } = workerData;
+
+// ... perform CPU-intensive work ...
+
+parentPort?.postMessage(result);
+```
+
+## Pool Configuration
+
+The pool automatically sizes itself to `os.cpus().length - 1`, reserving one core for the main event loop. Tasks that exceed the pool size are queued and processed as workers become available.
+
+## Dependencies
+
+None. Uses the Node.js built-in `worker_threads` module.
+
+## Generated Files
+
+| File                              | Description                                  |
+| --------------------------------- | -------------------------------------------- |
+| `src/shared/utils/worker-pool.ts` | Injectable worker pool with automatic sizing |

package/templates/recipes/worker-threads/src/shared/utils/worker-pool.ts

@@ -0,0 +1,59 @@
+import { Worker } from 'node:worker_threads';
+import { Injectable, Logger } from '@nestjs/common';
+import * as os from 'node:os';
+
+interface WorkerTask<T> {
+  resolve: (value: T) => void;
+  reject: (error: Error) => void;
+}
+
+@Injectable()
+export class WorkerPool {
+  private readonly logger = new Logger(WorkerPool.name);
+  private readonly workers: Worker[] = [];
+  private readonly queue: Array<{ script: string; data: unknown; task: WorkerTask<unknown> }> = [];
+  private readonly maxWorkers: number;
+
+  constructor() {
+    this.maxWorkers = Math.max(1, os.cpus().length - 1);
+  }
+
+  async run<T>(script: string, data: unknown): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      if (this.workers.length < this.maxWorkers) {
+        this.spawn(script, data, { resolve: resolve as (v: unknown) => void, reject });
+      } else {
+        this.queue.push({
+          script,
+          data,
+          task: { resolve: resolve as (v: unknown) => void, reject },
+        });
+      }
+    });
+  }
+
+  private spawn(script: string, data: unknown, task: WorkerTask<unknown>): void {
+    const worker = new Worker(script, { workerData: data });
+    this.workers.push(worker);
+
+    worker.on('message', (result) => {
+      task.resolve(result);
+      this.cleanup(worker);
+    });
+
+    worker.on('error', (error) => {
+      task.reject(error);
+      this.cleanup(worker);
+    });
+  }
+
+  private cleanup(worker: Worker): void {
+    const index = this.workers.indexOf(worker);
+    if (index !== -1) this.workers.splice(index, 1);
+
+    if (this.queue.length > 0) {
+      const next = this.queue.shift()!;
+      this.spawn(next.script, next.data, next.task);
+    }
+  }
+}

package/templates/recipes/worker-threads/tests/unit/shared/utils/worker-pool.spec.ts

@@ -0,0 +1,36 @@
+import { WorkerPool } from '../../../../src/shared/utils/worker-pool';
+
+jest.mock('node:worker_threads', () => {
+  const EventEmitter = require('node:events');
+
+  class MockWorker extends EventEmitter {
+    constructor(_script: string, _opts: any) {
+      super();
+      // Simulate async message delivery
+      process.nextTick(() => this.emit('message', { result: 'ok' }));
+    }
+    terminate() {
+      return Promise.resolve(0);
+    }
+  }
+
+  return { Worker: MockWorker };
+});
+
+describe('WorkerPool', () => {
+  let pool: WorkerPool;
+
+  beforeEach(() => {
+    pool = new WorkerPool();
+  });
+
+  it('should initialise with maxWorkers based on CPU count', () => {
+    const maxWorkers = (pool as any).maxWorkers;
+    expect(maxWorkers).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should run a task and return the result', async () => {
+    const result = await pool.run<{ result: string }>('worker.js', { input: 1 });
+    expect(result).toEqual({ result: 'ok' });
+  });
+});