spoonfeeder 0.1.0

package/templates/recipes/cloud-aws/cloudwatch/src/infrastructure/aws/cloudwatch.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { CloudWatchService } from './cloudwatch.service';
+
+@Module({
+  providers: [CloudWatchService],
+  exports: [CloudWatchService],
+})
+export class CloudWatchModule {}

package/templates/recipes/cloud-aws/cloudwatch/src/infrastructure/aws/cloudwatch.service.ts

@@ -0,0 +1,40 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  CloudWatchLogsClient,
+  PutLogEventsCommand,
+  type InputLogEvent,
+} from '@aws-sdk/client-cloudwatch-logs';
+
+@Injectable()
+export class CloudWatchService {
+  private readonly client: CloudWatchLogsClient;
+  private readonly logger = new Logger(CloudWatchService.name);
+
+  constructor(private readonly configService: ConfigService) {
+    this.client = new CloudWatchLogsClient({
+      region: this.configService.get<string>('AWS_REGION', 'eu-west-1'),
+    });
+  }
+
+  async putLogEvents(
+    logGroupName: string,
+    logStreamName: string,
+    messages: string[],
+  ): Promise<void> {
+    const logEvents: InputLogEvent[] = messages.map((message) => ({
+      message,
+      timestamp: Date.now(),
+    }));
+
+    await this.client.send(
+      new PutLogEventsCommand({
+        logGroupName,
+        logStreamName,
+        logEvents,
+      }),
+    );
+
+    this.logger.debug(`Put ${messages.length} log event(s) to ${logGroupName}/${logStreamName}`);
+  }
+}

package/templates/recipes/cloud-aws/cognito/README.md

@@ -0,0 +1,39 @@
+# AWS Cognito
+
+AWS Cognito user pool authentication and authorization for NestJS.
+
+## Documentation
+
+- [AWS Cognito Developer Guide](https://docs.aws.amazon.com/cognito/latest/developerguide/)
+- [@aws-sdk/client-cognito-identity-provider on npm](https://www.npmjs.com/package/@aws-sdk/client-cognito-identity-provider)
+- [NestJS Authentication](https://docs.nestjs.com/security/authentication)
+
+## Dependencies
+
+| Package                                     | Version   | Purpose                   |
+| ------------------------------------------- | --------- | ------------------------- |
+| `@aws-sdk/client-cognito-identity-provider` | `3.712.0` | AWS SDK v3 Cognito client |
+
+## Environment Variables
+
+| Variable               | Default     | Description           |
+| ---------------------- | ----------- | --------------------- |
+| `AWS_REGION`           | `eu-west-1` | AWS region            |
+| `COGNITO_USER_POOL_ID` | —           | Cognito user pool ID  |
+| `COGNITO_CLIENT_ID`    | —           | Cognito app client ID |
+
+## Usage
+
+```typescript
+import { CognitoAuthGuard } from '@/aws/cognito-auth.guard';
+import { CurrentUser } from '@/auth/current-user.decorator';
+
+@Controller('orders')
+@UseGuards(CognitoAuthGuard)
+export class OrdersController {
+  @Get()
+  findAll(@CurrentUser() user: CognitoUser) {
+    return this.ordersService.findByUser(user.sub);
+  }
+}
+```

package/templates/recipes/cloud-aws/cognito/src/infrastructure/aws/cognito.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { CognitoService } from './cognito.service';
+
+@Module({
+  providers: [CognitoService],
+  exports: [CognitoService],
+})
+export class CognitoModule {}

package/templates/recipes/cloud-aws/cognito/src/infrastructure/aws/cognito.service.ts

@@ -0,0 +1,47 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  CognitoIdentityProviderClient,
+  GetUserCommand,
+  type AttributeType,
+} from '@aws-sdk/client-cognito-identity-provider';
+import { CognitoJwtVerifier } from 'aws-jwt-verify';
+
+@Injectable()
+export class CognitoService {
+  private readonly client: CognitoIdentityProviderClient;
+  private readonly verifier: ReturnType<typeof CognitoJwtVerifier.create>;
+  private readonly logger = new Logger(CognitoService.name);
+
+  constructor(private readonly configService: ConfigService) {
+    this.client = new CognitoIdentityProviderClient({
+      region: this.configService.get<string>('AWS_REGION', 'eu-west-1'),
+    });
+
+    this.verifier = CognitoJwtVerifier.create({
+      userPoolId: this.configService.getOrThrow<string>('COGNITO_USER_POOL_ID'),
+      clientId: this.configService.getOrThrow<string>('COGNITO_CLIENT_ID'),
+      tokenUse: 'access',
+    });
+  }
+
+  async verifyToken(token: string): Promise<Record<string, unknown>> {
+    const payload = await this.verifier.verify(token);
+    this.logger.debug(`Token verified for sub: ${payload.sub}`);
+    return payload as unknown as Record<string, unknown>;
+  }
+
+  async getUser(accessToken: string): Promise<Record<string, string>> {
+    const result = await this.client.send(new GetUserCommand({ AccessToken: accessToken }));
+
+    const attributes: Record<string, string> = {};
+    result.UserAttributes?.forEach((attr: AttributeType) => {
+      if (attr.Name && attr.Value) {
+        attributes[attr.Name] = attr.Value;
+      }
+    });
+
+    this.logger.debug(`Retrieved user: ${result.Username}`);
+    return attributes;
+  }
+}

package/templates/recipes/cloud-aws/dynamodb/README.md

@@ -0,0 +1,48 @@
+# AWS DynamoDB
+
+Amazon DynamoDB NoSQL database integration for NestJS.
+
+## Documentation
+
+- [AWS DynamoDB Developer Guide](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/)
+- [@aws-sdk/client-dynamodb on npm](https://www.npmjs.com/package/@aws-sdk/client-dynamodb)
+- [@aws-sdk/lib-dynamodb on npm](https://www.npmjs.com/package/@aws-sdk/lib-dynamodb)
+
+## Dependencies
+
+| Package                    | Version   | Purpose                                    |
+| -------------------------- | --------- | ------------------------------------------ |
+| `@aws-sdk/client-dynamodb` | `3.712.0` | AWS SDK v3 DynamoDB client                 |
+| `@aws-sdk/lib-dynamodb`    | `3.712.0` | Document client with automatic marshalling |
+
+## Environment Variables
+
+| Variable              | Default     | Description         |
+| --------------------- | ----------- | ------------------- |
+| `AWS_REGION`          | `eu-west-1` | AWS region          |
+| `DYNAMODB_TABLE_NAME` | `app-table` | DynamoDB table name |
+
+## Usage
+
+```typescript
+import { DynamoDbService } from '@/aws/dynamodb.service';
+
+@Injectable()
+export class UserRepository {
+  constructor(private readonly dynamo: DynamoDbService) {}
+
+  async findById(userId: string): Promise<User | undefined> {
+    return this.dynamo.get({
+      TableName: this.configService.get('DYNAMODB_TABLE_NAME'),
+      Key: { PK: `USER#${userId}`, SK: `PROFILE` },
+    });
+  }
+
+  async save(user: User): Promise<void> {
+    await this.dynamo.put({
+      TableName: this.configService.get('DYNAMODB_TABLE_NAME'),
+      Item: { PK: `USER#${user.id}`, SK: 'PROFILE', ...user },
+    });
+  }
+}
+```

package/templates/recipes/cloud-aws/dynamodb/src/infrastructure/aws/dynamodb.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { DynamoDbService } from './dynamodb.service';
+
+@Module({
+  providers: [DynamoDbService],
+  exports: [DynamoDbService],
+})
+export class DynamoDbModule {}

package/templates/recipes/cloud-aws/dynamodb/src/infrastructure/aws/dynamodb.service.ts

@@ -0,0 +1,49 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import {
+  DynamoDBDocumentClient,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  DeleteCommand,
+  type QueryCommandInput,
+} from '@aws-sdk/lib-dynamodb';
+
+@Injectable()
+export class DynamoDbService {
+  private readonly docClient: DynamoDBDocumentClient;
+  private readonly logger = new Logger(DynamoDbService.name);
+
+  constructor(private readonly configService: ConfigService) {
+    const client = new DynamoDBClient({
+      region: this.configService.get<string>('AWS_REGION', 'eu-west-1'),
+    });
+    this.docClient = DynamoDBDocumentClient.from(client);
+  }
+
+  async get(
+    tableName: string,
+    key: Record<string, unknown>,
+  ): Promise<Record<string, unknown> | undefined> {
+    const result = await this.docClient.send(new GetCommand({ TableName: tableName, Key: key }));
+    this.logger.debug(`Get from ${tableName}`);
+    return result.Item as Record<string, unknown> | undefined;
+  }
+
+  async put(tableName: string, item: Record<string, unknown>): Promise<void> {
+    await this.docClient.send(new PutCommand({ TableName: tableName, Item: item }));
+    this.logger.debug(`Put item to ${tableName}`);
+  }
+
+  async query(params: QueryCommandInput): Promise<Record<string, unknown>[]> {
+    const result = await this.docClient.send(new QueryCommand(params));
+    this.logger.debug(`Query ${params.TableName}: ${result.Count} item(s)`);
+    return (result.Items as Record<string, unknown>[]) ?? [];
+  }
+
+  async delete(tableName: string, key: Record<string, unknown>): Promise<void> {
+    await this.docClient.send(new DeleteCommand({ TableName: tableName, Key: key }));
+    this.logger.debug(`Deleted item from ${tableName}`);
+  }
+}

package/templates/recipes/cloud-aws/elasticache/README.md

@@ -0,0 +1,45 @@
+# AWS ElastiCache
+
+AWS ElastiCache (Redis) managed caching service integration for NestJS.
+
+## Documentation
+
+- [AWS ElastiCache for Redis User Guide](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/)
+- [ioredis on npm](https://www.npmjs.com/package/ioredis)
+- [NestJS Caching](https://docs.nestjs.com/techniques/caching)
+
+## Dependencies
+
+| Package   | Version | Purpose                  |
+| --------- | ------- | ------------------------ |
+| `ioredis` | `5.4.2` | Redis client for Node.js |
+
+## Environment Variables
+
+| Variable               | Default | Description                  |
+| ---------------------- | ------- | ---------------------------- |
+| `ELASTICACHE_ENDPOINT` | —       | ElastiCache primary endpoint |
+| `ELASTICACHE_PORT`     | `6379`  | ElastiCache port             |
+
+## Usage
+
+```typescript
+import Redis from 'ioredis';
+
+@Module({
+  providers: [
+    {
+      provide: 'REDIS_CLIENT',
+      useFactory: (config: ConfigService) =>
+        new Redis({
+          host: config.getOrThrow('ELASTICACHE_ENDPOINT'),
+          port: config.get<number>('ELASTICACHE_PORT', 6379),
+          tls: {},
+        }),
+      inject: [ConfigService],
+    },
+  ],
+  exports: ['REDIS_CLIENT'],
+})
+export class RedisModule {}
+```

package/templates/recipes/cloud-aws/elasticache/src/infrastructure/aws/redis.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { RedisService } from './redis.service';
+
+@Module({
+  providers: [RedisService],
+  exports: [RedisService],
+})
+export class RedisModule {}

package/templates/recipes/cloud-aws/elasticache/src/infrastructure/aws/redis.service.ts

@@ -0,0 +1,47 @@
+import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import Redis from 'ioredis';
+
+@Injectable()
+export class RedisService implements OnModuleDestroy {
+  private readonly client: Redis;
+  private readonly logger = new Logger(RedisService.name);
+
+  constructor(private readonly configService: ConfigService) {
+    this.client = new Redis({
+      host: this.configService.getOrThrow<string>('REDIS_HOST'),
+      port: this.configService.get<number>('REDIS_PORT', 6379),
+      password: this.configService.get<string>('REDIS_PASSWORD'),
+      tls: this.configService.get<boolean>('REDIS_TLS', false) ? {} : undefined,
+    });
+  }
+
+  async get(key: string): Promise<string | null> {
+    const value = await this.client.get(key);
+    this.logger.debug(`GET ${key}: ${value !== null ? 'hit' : 'miss'}`);
+    return value;
+  }
+
+  async set(key: string, value: string, ttlSeconds?: number): Promise<void> {
+    if (ttlSeconds) {
+      await this.client.set(key, value, 'EX', ttlSeconds);
+    } else {
+      await this.client.set(key, value);
+    }
+    this.logger.debug(`SET ${key}`);
+  }
+
+  async del(key: string): Promise<number> {
+    const result = await this.client.del(key);
+    this.logger.debug(`DEL ${key}: ${result}`);
+    return result;
+  }
+
+  async ttl(key: string): Promise<number> {
+    return this.client.ttl(key);
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    await this.client.quit();
+  }
+}

package/templates/recipes/cloud-aws/eventbridge/README.md

@@ -0,0 +1,46 @@
+# AWS EventBridge
+
+Amazon EventBridge integration for event-driven architectures in NestJS.
+
+## Documentation
+
+- [AWS EventBridge User Guide](https://docs.aws.amazon.com/eventbridge/latest/userguide/)
+- [@aws-sdk/client-eventbridge on npm](https://www.npmjs.com/package/@aws-sdk/client-eventbridge)
+- [NestJS CQRS — Events](https://docs.nestjs.com/recipes/cqrs)
+
+## Dependencies
+
+| Package                       | Version   | Purpose                       |
+| ----------------------------- | --------- | ----------------------------- |
+| `@aws-sdk/client-eventbridge` | `3.712.0` | AWS SDK v3 EventBridge client |
+
+## Environment Variables
+
+| Variable               | Default     | Description          |
+| ---------------------- | ----------- | -------------------- |
+| `AWS_REGION`           | `eu-west-1` | AWS region           |
+| `EVENTBRIDGE_BUS_NAME` | `default`   | EventBridge bus name |
+
+## Usage
+
+```typescript
+import { EventBridgeService } from '@/aws/eventbridge.service';
+
+@Injectable()
+export class DomainEventPublisher {
+  constructor(private readonly eventBridge: EventBridgeService) {}
+
+  async publishEvent(detailType: string, detail: Record<string, unknown>): Promise<void> {
+    await this.eventBridge.putEvents({
+      Entries: [
+        {
+          Source: 'com.myapp.orders',
+          DetailType: detailType,
+          Detail: JSON.stringify(detail),
+          EventBusName: this.configService.get('EVENTBRIDGE_BUS_NAME'),
+        },
+      ],
+    });
+  }
+}
+```

package/templates/recipes/cloud-aws/eventbridge/src/infrastructure/aws/eventbridge.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { EventBridgeService } from './eventbridge.service';
+
+@Module({
+  providers: [EventBridgeService],
+  exports: [EventBridgeService],
+})
+export class EventBridgeModule {}

package/templates/recipes/cloud-aws/eventbridge/src/infrastructure/aws/eventbridge.service.ts

@@ -0,0 +1,48 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  EventBridgeClient,
+  PutEventsCommand,
+  type PutEventsRequestEntry,
+  type PutEventsResultEntry,
+} from '@aws-sdk/client-eventbridge';
+
+@Injectable()
+export class EventBridgeService {
+  private readonly client: EventBridgeClient;
+  private readonly logger = new Logger(EventBridgeService.name);
+
+  constructor(private readonly configService: ConfigService) {
+    this.client = new EventBridgeClient({
+      region: this.configService.get<string>('AWS_REGION', 'eu-west-1'),
+    });
+  }
+
+  async putEvents(entries: PutEventsRequestEntry[]): Promise<PutEventsResultEntry[]> {
+    const result = await this.client.send(new PutEventsCommand({ Entries: entries }));
+
+    if (result.FailedEntryCount && result.FailedEntryCount > 0) {
+      this.logger.warn(`${result.FailedEntryCount} event(s) failed to deliver`);
+    }
+
+    this.logger.debug(`Put ${entries.length} event(s) to EventBridge`);
+    return result.Entries ?? [];
+  }
+
+  async putEvent(
+    source: string,
+    detailType: string,
+    detail: Record<string, unknown>,
+    eventBusName?: string,
+  ): Promise<PutEventsResultEntry> {
+    const entries = await this.putEvents([
+      {
+        Source: source,
+        DetailType: detailType,
+        Detail: JSON.stringify(detail),
+        EventBusName: eventBusName,
+      },
+    ]);
+    return entries[0];
+  }
+}

package/templates/recipes/cloud-aws/rds/README.md

@@ -0,0 +1,59 @@
+# AWS RDS
+
+AWS RDS managed database connection with IAM authentication support for NestJS.
+
+> **Note:** RDS does not require a dedicated service wrapper. Database access is handled through
+> TypeORM or Prisma, configured directly in a module. See the
+> [`typeorm-postgres`](../../typeorm-postgres/) recipe for a complete setup.
+
+## Documentation
+
+- [AWS RDS User Guide](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/)
+- [AWS RDS IAM Authentication](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.html)
+- [@nestjs/typeorm on npm](https://www.npmjs.com/package/@nestjs/typeorm)
+- [NestJS Database — TypeORM](https://docs.nestjs.com/techniques/database)
+
+## Dependencies
+
+| Package           | Version  | Purpose                    |
+| ----------------- | -------- | -------------------------- |
+| `@nestjs/typeorm` | `10.0.2` | NestJS TypeORM integration |
+| `typeorm`         | `0.3.20` | TypeORM core               |
+| `pg`              | `8.13.1` | PostgreSQL driver          |
+
+## Environment Variables
+
+| Variable       | Default     | Description           |
+| -------------- | ----------- | --------------------- |
+| `AWS_REGION`   | `eu-west-1` | AWS region            |
+| `RDS_HOST`     | —           | RDS instance endpoint |
+| `RDS_PORT`     | `5432`      | RDS port              |
+| `RDS_DATABASE` | `app`       | RDS database name     |
+| `RDS_USERNAME` | `postgres`  | RDS username          |
+| `RDS_PASSWORD` | —           | RDS password          |
+
+## Usage
+
+```typescript
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ConfigService } from '@nestjs/config';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRootAsync({
+      inject: [ConfigService],
+      useFactory: (config: ConfigService) => ({
+        type: 'postgres',
+        host: config.get('RDS_HOST'),
+        port: config.getOrThrow<number>('RDS_PORT'),
+        database: config.get('RDS_DATABASE'),
+        username: config.get('RDS_USERNAME'),
+        password: config.get('RDS_PASSWORD'),
+        ssl: { rejectUnauthorized: true },
+        autoLoadEntities: true,
+      }),
+    }),
+  ],
+})
+export class DatabaseModule {}
+```

package/templates/recipes/cloud-aws/s3/README.md

@@ -0,0 +1,44 @@
+# AWS S3
+
+Amazon S3 object storage integration for file uploads and downloads in NestJS.
+
+## Documentation
+
+- [AWS S3 Developer Guide](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)
+- [@aws-sdk/client-s3 on npm](https://www.npmjs.com/package/@aws-sdk/client-s3)
+- [@aws-sdk/s3-request-presigner on npm](https://www.npmjs.com/package/@aws-sdk/s3-request-presigner)
+- [NestJS File Upload](https://docs.nestjs.com/techniques/file-upload)
+
+## Dependencies
+
+| Package                         | Version   | Purpose                 |
+| ------------------------------- | --------- | ----------------------- |
+| `@aws-sdk/client-s3`            | `3.712.0` | AWS SDK v3 S3 client    |
+| `@aws-sdk/s3-request-presigner` | `3.712.0` | Generate presigned URLs |
+
+## Environment Variables
+
+| Variable     | Default     | Description    |
+| ------------ | ----------- | -------------- |
+| `AWS_REGION` | `eu-west-1` | AWS region     |
+| `S3_BUCKET`  | `my-bucket` | S3 bucket name |
+
+## Usage
+
+```typescript
+import { S3Service } from '@/infrastructure/aws/s3.service';
+
+@Injectable()
+export class FileUploader {
+  constructor(private readonly s3: S3Service) {}
+
+  async upload(bucket: string, key: string, body: Buffer): Promise<string> {
+    await this.s3.upload(bucket, key, body);
+    return this.s3.getPresignedUrl(bucket, key, 3600);
+  }
+
+  async download(bucket: string, key: string): Promise<Readable> {
+    return this.s3.download(bucket, key);
+  }
+}
+```

package/templates/recipes/cloud-aws/s3/src/infrastructure/aws/s3.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { S3Service } from './s3.service';
+
+@Module({
+  providers: [S3Service],
+  exports: [S3Service],
+})
+export class S3Module {}

package/templates/recipes/cloud-aws/s3/src/infrastructure/aws/s3.service.ts

@@ -0,0 +1,42 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  S3Client,
+  PutObjectCommand,
+  GetObjectCommand,
+  DeleteObjectCommand,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { type Readable } from 'stream';
+
+@Injectable()
+export class S3Service {
+  private readonly client: S3Client;
+  private readonly logger = new Logger(S3Service.name);
+
+  constructor(private readonly configService: ConfigService) {
+    this.client = new S3Client({
+      region: this.configService.get<string>('AWS_REGION', 'eu-west-1'),
+    });
+  }
+
+  async upload(bucket: string, key: string, body: Buffer | Readable | string): Promise<void> {
+    await this.client.send(new PutObjectCommand({ Bucket: bucket, Key: key, Body: body }));
+    this.logger.debug(`Uploaded s3://${bucket}/${key}`);
+  }
+
+  async download(bucket: string, key: string): Promise<Readable> {
+    const result = await this.client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    return result.Body as Readable;
+  }
+
+  async getPresignedUrl(bucket: string, key: string, expiresIn = 3600): Promise<string> {
+    const command = new GetObjectCommand({ Bucket: bucket, Key: key });
+    return getSignedUrl(this.client, command, { expiresIn });
+  }
+
+  async deleteObject(bucket: string, key: string): Promise<void> {
+    await this.client.send(new DeleteObjectCommand({ Bucket: bucket, Key: key }));
+    this.logger.debug(`Deleted s3://${bucket}/${key}`);
+  }
+}

package/templates/recipes/cloud-aws/secrets-manager/README.md

@@ -0,0 +1,38 @@
+# AWS Secrets Manager
+
+Retrieve and cache secrets from AWS Secrets Manager in NestJS.
+
+## Documentation
+
+- [AWS Secrets Manager User Guide](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)
+- [@aws-sdk/client-secrets-manager on npm](https://www.npmjs.com/package/@aws-sdk/client-secrets-manager)
+- [NestJS Configuration](https://docs.nestjs.com/techniques/configuration)
+
+## Dependencies
+
+| Package                           | Version   | Purpose                           |
+| --------------------------------- | --------- | --------------------------------- |
+| `@aws-sdk/client-secrets-manager` | `3.712.0` | AWS SDK v3 Secrets Manager client |
+
+## Environment Variables
+
+| Variable     | Default     | Description |
+| ------------ | ----------- | ----------- |
+| `AWS_REGION` | `eu-west-1` | AWS region  |
+
+## Usage
+
+```typescript
+import { SecretsService } from '@/aws/secrets.service';
+
+@Injectable()
+export class DatabaseConfig {
+  constructor(private readonly secrets: SecretsService) {}
+
+  async getConnectionString(): Promise<string> {
+    const secret = await this.secrets.getSecret('prod/database/credentials');
+    const parsed = JSON.parse(secret);
+    return `postgresql://${parsed.username}:${parsed.password}@${parsed.host}:${parsed.port}/${parsed.dbname}`;
+  }
+}
+```

package/templates/recipes/cloud-aws/secrets-manager/src/infrastructure/aws/secrets.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { SecretsService } from './secrets.service';
+
+@Module({
+  providers: [SecretsService],
+  exports: [SecretsService],
+})
+export class SecretsModule {}